source/src/qt/gui/menu_main.cpp

   1 /*
   2  * Common Source code Project:
   3  * Ui->Qt->gui->menu_main for generic.
   4  * (C) 2015 K.Ohta <whatisthis.sowhat _at_ gmail.com>
   5  *   License : GPLv2
   6  *   History :
   7  * Jan 14, 2015 : Initial, moved from qt/x1turboz/MainWindow.cpp .
   8  */
   9
  10 #include <QApplication>
  11 #include <QVariant>
  12 #include <QtGui>
  13 #include <QIcon>
  14 #include <QImage>
  15 #include <QImageReader>
  16 #include <QPixmap>
  17 #include <QApplication>
  18 #include <QLocale>
  19 #include <QTranslator>
  20 #include <QStatusBar>
  21 #include <QHBoxLayout>
  22 #include <QVBoxLayout>
  23 #include <QDockWidget>
  24 #include <QToolBar>
  25 #include <QMenu>
  26 #include <QMenuBar>
  27 #include <QStyle>
  28
  29 #include "commonclasses.h"
  30 #include "display_about.h"
  31 #include "display_text_document.h"
  32 #include "mainwidget_base.h"
  33 //#include "menuclasses.h"
  34 #include "menu_disk.h"
  35 #include "menu_harddisk.h"
  36 #include "menu_cmt.h"
  37 #include "menu_cart.h"
  38 #include "menu_quickdisk.h"
  39 #include "menu_binary.h"
  40 #include "menu_compactdisc.h"
  41 #include "menu_laserdisc.h"
  42 #include "menu_bubble.h"
  43 #include "dock_disks.h"
  44
  45 #include "qt_gldraw.h"
  46 //#include "emu.h"
  47 #include "qt_main.h"
  48 #include "menu_flags.h"
  49 #include "csp_logger.h"
  50 #include "common.h"
  51
  52 extern EMU *emu;
  53 //extern USING_FLAGS *using_flags;
  54 void DLL_PREFIX _resource_init(void)
  55 {
  56         Q_INIT_RESOURCE(commontexts);
  57         Q_INIT_RESOURCE(shaders);
  58 }
  59
  60 void DLL_PREFIX _resource_free(void)
  61 {
  62         Q_CLEANUP_RESOURCE(shaders);
  63         Q_CLEANUP_RESOURCE(commontexts);
  64 }
  65
  66 Ui_MainWindowBase::Ui_MainWindowBase(USING_FLAGS *p, CSP_Logger *logger, QWidget *parent) : QMainWindow(parent)
  67 {
  68         csp_logger = logger;
  69         using_flags = p;
  70         p_config = p->get_config_ptr();
  71         driveData = NULL;
  72         ledUpdateTimer = NULL;
  73         setupUi();
  74         createContextMenu();
  75         max_vm_nodes = 0;
  76         ui_retranslate_completed = false;
  77         //csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "GUI OK");
  78 }
  79
  80 Ui_MainWindowBase::~Ui_MainWindowBase()
  81 {
  82         graphicsView->releaseKeyboard();
  83         if(ledUpdateTimer != NULL) delete ledUpdateTimer;
  84         if(driveData != NULL) delete driveData;
  85         delete using_flags;
  86 }
  87
  88 QString Ui_MainWindowBase::get_gui_version()
  89 {
  90         QString retval;
  91         retval.clear();
  92 #if defined(__GUI_LIBRARY_NAME)
  93         retval = QString::fromUtf8(__GUI_LIBRARY_NAME);
  94 #endif
  95         return retval;
  96 }
  97
  98 void Action_Control::do_check_grab_mouse(bool flag)
  99 {
 100         this->toggle();
 101 }
 102
 103 void Action_Control::do_send_string(void)
 104 {
 105         emit sig_send_string(bindString);
 106 }
 107
 108 void Action_Control::do_set_string(QString s)
 109 {
 110         bindString = s;
 111 }
 112
 113 void Action_Control::do_select_render_platform(void)
 114 {
 115         int num = this->binds->getValue1();
 116         emit sig_select_render_platform(num);
 117 }
 118
 119 void Action_Control::do_set_window_focus_type(bool f)
 120 {
 121         emit sig_set_window_focus_type(f);
 122 }
 123
 124 void Action_Control::do_set_emulate_cursor_as(void)
 125 {
 126         int num = this->binds->getValue1();
 127         emit sig_set_emulate_cursor_as(num);
 128 }
 129
 130 void Action_Control::do_set_dev_log_to_console(bool f)
 131 {
 132         int num = this->binds->getValue1();
 133         emit sig_set_dev_log_to_console(num, f);
 134 }
 135
 136 void Action_Control::do_set_dev_log_to_syslog(bool f)
 137 {
 138         int num = this->binds->getValue1();
 139         emit sig_set_dev_log_to_syslog(num, f);
 140 }
 141
 142
 143 void Ui_MainWindowBase::do_set_window_focus_type(bool flag)
 144 {
 145         p_config->focus_with_click = flag;
 146         if(flag) {
 147                 graphicsView->setFocusPolicy(Qt::ClickFocus);
 148                 graphicsView->setFocus(Qt::MouseFocusReason);
 149         } else {
 150                 graphicsView->setFocusPolicy(Qt::NoFocus);
 151                 graphicsView->clearFocus();
 152         }
 153 }
 154
 155 void Ui_MainWindowBase::do_show_about(void)
 156 {
 157         Dlg_AboutCSP *dlg = new Dlg_AboutCSP(using_flags, static_cast<QWidget *>(this));
 158         dlg->show();
 159 }
 160
 161 void Ui_MainWindowBase::do_browse_document(QString fname)
 162 {
 163         Dlg_BrowseText *dlg = new Dlg_BrowseText(fname, using_flags);
 164         dlg->show();
 165 }
 166
 167 void Ui_MainWindowBase::do_set_sound_files_fdd(bool f)
 168 {
 169         if(f) {
 170                 p_config->sound_noise_fdd = 1;
 171         } else {
 172                 p_config->sound_noise_fdd = 0;
 173         }
 174 }
 175
 176 void Ui_MainWindowBase::do_set_sound_files_relay(bool f)
 177 {
 178         if(f) {
 179                 p_config->sound_noise_cmt = 1;
 180         } else {
 181                 p_config->sound_noise_cmt = 0;
 182         }
 183 }
 184
 185
 186 void Ui_MainWindowBase::do_set_conslog(bool f)
 187 {
 188         p_config->log_to_console = f;
 189         csp_logger->set_log_stdout(-1, f);
 190 }
 191
 192 void Ui_MainWindowBase::do_set_syslog(bool f)
 193 {
 194         p_config->log_to_syslog = f;
 195         csp_logger->set_log_syslog(-1, f);
 196 }
 197
 198 void Ui_MainWindowBase::do_update_device_node_name(int id, const _TCHAR *name)
 199 {
 200         if(action_DevLogToConsole[id] == NULL) return;
 201         if(!ui_retranslate_completed) return;
 202         if(using_flags->get_vm_node_size() > id) {
 203                 action_DevLogToConsole[id]->setEnabled(true);
 204                 action_DevLogToConsole[id]->setVisible(true);
 205 #if !defined(Q_OS_WIN)
 206                 action_DevLogToSyslog[id]->setEnabled(true);
 207                 action_DevLogToSyslog[id]->setVisible(true);
 208 #endif
 209         } else {
 210                 action_DevLogToConsole[id]->setEnabled(false);
 211                 action_DevLogToConsole[id]->setVisible(false);
 212
 213 #if !defined(Q_OS_WIN)
 214                 action_DevLogToSyslog[id]->setEnabled(false);
 215                 action_DevLogToSyslog[id]->setVisible(false);
 216 #endif
 217         }
 218         char s[64] = {0};
 219         snprintf(s, 60, "#%02d: %s", id, name);
 220         action_DevLogToConsole[id]->setText(QString::fromUtf8(s));
 221 #if !defined(Q_OS_WIN)
 222         action_DevLogToSyslog[id]->setText(QString::fromUtf8(s));
 223 #endif
 224 }
 225
 226
 227 void Ui_MainWindowBase::do_set_logging_fdc(bool f)
 228 {
 229         p_config->special_debug_fdc = f;
 230         emit sig_emu_update_config();
 231 }
 232
 233 void Ui_MainWindowBase::do_set_dev_log_to_console(int num, bool f)
 234 {
 235         csp_logger->set_device_node_log(num, 2, CSP_LOG_DEBUG, f);
 236         p_config->dev_log_to_console[num][0] = f;
 237 }
 238
 239 void Ui_MainWindowBase::do_set_state_log_to_console(bool f)
 240 {
 241         csp_logger->set_state_log(2, f);
 242         p_config->state_log_to_console = f;
 243 }
 244
 245 void Ui_MainWindowBase::do_set_state_log_to_syslog(bool f)
 246 {
 247         csp_logger->set_state_log(1, f);
 248         p_config->state_log_to_syslog = f;
 249 }
 250
 251 void Ui_MainWindowBase::do_set_state_log_to_record(bool f)
 252 {
 253         csp_logger->set_state_log(0, f);
 254         p_config->state_log_to_recording = f;
 255 }
 256
 257
 258
 259 void Ui_MainWindowBase::do_set_emulate_cursor_as(int num)
 260 {
 261         if((num < 0) || (num > 2)) return;
 262         p_config->cursor_as_ten_key = num;
 263         emit sig_emu_update_config();
 264 }
 265
 266 void Ui_MainWindowBase::do_set_dev_log_to_syslog(int num, bool f)
 267 {
 268         csp_logger->set_device_node_log(num, 2, CSP_LOG_DEBUG, f);
 269         p_config->dev_log_to_syslog[num][0] = f;
 270 }
 271
 272 void Ui_MainWindowBase::do_select_render_platform(int num)
 273 {
 274         int _major = 0;
 275         int _minor = 0;
 276         int _type = -1;
 277
 278         switch(num) {
 279         case RENDER_PLATFORMS_OPENGL_ES_2:
 280                 _type = CONFIG_RENDER_PLATFORM_OPENGL_ES;
 281                 _major = 2;
 282                 _minor = 0;
 283                 break;
 284         case RENDER_PLATFORMS_OPENGL3_MAIN:
 285                 _type = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
 286                 _major = 3;
 287                 _minor = 0;
 288                 break;
 289         case RENDER_PLATFORMS_OPENGL2_MAIN:
 290                 _type = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
 291                 _major = 2;
 292                 _minor = 0;
 293                 break;
 294         case RENDER_PLATFORMS_OPENGL_CORE:
 295                 _type = CONFIG_RENDER_PLATFORM_OPENGL_CORE;
 296                 _major = 4;
 297                 _minor = 5;
 298                 break;
 299         default:
 300                 break;
 301         }
 302         if(_type >= 0) {
 303                 p_config->render_platform = _type;
 304                 p_config->render_major_version = _major;
 305                 p_config->render_minor_version = _minor;
 306         }
 307 }
 308
 309 void Ui_MainWindowBase::set_dipsw(int num, bool flag)
 310 {
 311         if((num < 0) || (num >= 32)) return;
 312         if(flag) {
 313                 p_config->dipswitch = p_config->dipswitch | (1 << num);
 314         } else {
 315                 p_config->dipswitch = p_config->dipswitch & ~(1 << num);
 316         }
 317 }
 318
 319 bool Ui_MainWindowBase::get_dipsw(int num)
 320 {
 321         if((num < 0) || (num >= 32)) return false;
 322         if(((1 << num) & p_config->dipswitch) == 0) return false;
 323         return true;
 324 }
 325
 326
 327 void Ui_MainWindowBase::setupUi(void)
 328 {
 329         int w, h;
 330         //   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
 331         MainWindow = new QMainWindow();
 332         if (MainWindow->objectName().isEmpty())
 333                 MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
 334         //MainWindow->resize(1288, 862);
 335         ConfigControlMenu();
 336         ConfigFloppyMenu();
 337         ConfigHardDiskMenu();
 338         ConfigCMTMenu();
 339         if(!using_flags->is_without_sound()) {
 340                 ConfigSoundMenu();
 341         }
 342         if(using_flags->is_use_binary_file()) {
 343                 ConfigBinaryMenu();
 344         }
 345         if(using_flags->is_use_qd()) {
 346                 ConfigQuickDiskMenu();
 347         }
 348         ConfigScreenMenu();
 349         if(using_flags->is_use_cart()) {
 350                 ConfigCartMenu();
 351         }
 352         if(using_flags->is_use_compact_disc()) {
 353                 ConfigCDROMMenu();
 354         }
 355         if(using_flags->is_use_laser_disc()) {
 356                 ConfigLaserdiscMenu();
 357         }
 358         if(using_flags->is_use_bubble()) {
 359                 ConfigBubbleMenu();
 360         }
 361         ConfigEmulatorMenu();
 362         actionAbout = new Action_Control(this, using_flags);
 363         actionAbout->setObjectName(QString::fromUtf8("actionAbout"));
 364
 365         {
 366
 367                 QSurfaceFormat fmt;
 368                 {
 369                         int render_type = p_config->render_platform;
 370                         QOpenGLContext *glContext = QOpenGLContext::globalShareContext();
 371                         //int _major_version = p_config->render_major_version;
 372                         //int _minor_version = p_config->render_minor_version;
 373
 374                         if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_ES) {
 375                                 fmt.setRenderableType(QSurfaceFormat::OpenGLES);
 376                                 csp_logger->debug_log(CSP_LOG_DEBUG,  CSP_LOG_TYPE_GENERAL, "Try to use OpenGL ES.");
 377                         } else if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_CORE) {
 378                                 fmt.setProfile(QSurfaceFormat::CoreProfile); // Requires >=Qt-4.8.0
 379                                 fmt.setVersion(4, 7); // Requires >=Qt-4.8.0
 380                                 csp_logger->debug_log(CSP_LOG_DEBUG,  CSP_LOG_TYPE_GENERAL, "Try to use OpenGL CORE profile.");
 381                         } else { // Fallback
 382                                 fmt.setProfile(QSurfaceFormat::CompatibilityProfile); // Requires >=Qt-4.8.0
 383                                 csp_logger->debug_log(CSP_LOG_DEBUG,  CSP_LOG_TYPE_GENERAL, "Try to use OpenGL Compatible(MAIN) profile.");
 384                         }
 385                 }
 386                 graphicsView = new GLDrawClass(using_flags, csp_logger, this, fmt);
 387                 graphicsView->setObjectName(QString::fromUtf8("graphicsView"));
 388                 graphicsView->setMaximumSize(2560, 2560); // ?
 389                 graphicsView->setMinimumSize(240, 192); // ?
 390                 csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "GraphicsView OK");
 391                 graphicsView->setAttribute(Qt::WA_InputMethodEnabled, false); // Disable [Zenkaku / Hankaku] with IM.
 392                 graphicsView->setAttribute(Qt::WA_KeyboardFocusChange, false);
 393                 graphicsView->setAttribute(Qt::WA_KeyCompression, false);
 394                 connect(this, SIGNAL(sig_set_display_osd(bool)), graphicsView, SLOT(do_set_display_osd(bool)));
 395                 connect(this, SIGNAL(sig_set_led_width(int)), graphicsView, SLOT(do_set_led_width(int)));
 396         }
 397
 398         bitmapImage = NULL;
 399         driveData = new CSP_DockDisks(this, using_flags);
 400         MainWindow->setDockOptions(QMainWindow::AnimatedDocks);
 401         if(p_config->virtual_media_position > 0) {
 402                 driveData->setVisible(true);
 403         } else {
 404                 driveData->setVisible(false);
 405         }
 406
 407         pCentralWidget = new QWidget(this);
 408         pCentralLayout = new QVBoxLayout(pCentralWidget);
 409         pCentralLayout->setContentsMargins(0, 0, 0, 0);
 410         pCentralLayout->addWidget(graphicsView);
 411         pCentralLayout->addWidget(driveData);
 412         switch(p_config->virtual_media_position) {
 413         case 0:
 414                 pCentralLayout->setDirection(QBoxLayout::TopToBottom);
 415                 pCentralLayout->removeWidget(driveData);
 416                 driveData->setVisible(false);
 417                 graphicsView->setVisible(true);
 418                 //emit sig_set_display_osd(true);
 419                 break;
 420         case 1:
 421                 pCentralLayout->setDirection(QBoxLayout::BottomToTop);
 422                 driveData->setVisible(true);
 423                 graphicsView->setVisible(true);
 424                 //emit sig_set_display_osd(false);
 425                 break;
 426         case 2:
 427                 pCentralLayout->setDirection(QBoxLayout::TopToBottom);
 428                 driveData->setVisible(true);
 429                 graphicsView->setVisible(true);
 430                 //emit sig_set_display_osd(false);
 431                 break;
 432         default:
 433                 pCentralLayout->setDirection(QBoxLayout::TopToBottom);
 434                 driveData->setVisible(true);
 435                 graphicsView->setVisible(true);
 436                 //emit sig_set_display_osd(false);
 437                 break;
 438         }
 439         pCentralWidget->setLayout(pCentralLayout);
 440         MainWindow->setCentralWidget(pCentralWidget);
 441
 442         if(p_config->focus_with_click) {
 443                 graphicsView->setFocusPolicy(Qt::ClickFocus);
 444                 graphicsView->setFocus(Qt::MouseFocusReason);
 445         } else {
 446                 graphicsView->setFocusPolicy(Qt::NoFocus);
 447         }
 448         driveData->setOrientation(p_config->virtual_media_position);
 449         connect(this, SIGNAL(sig_set_orientation_osd(int)), driveData, SLOT(setOrientation(int)));
 450         connect(graphicsView, SIGNAL(sig_resize_osd(int)), driveData, SLOT(setScreenWidth(int)));
 451
 452         MainWindow->setFocusProxy(graphicsView);
 453         MainWindow->centralWidget()->adjustSize();
 454         MainWindow->adjustSize();
 455
 456         statusbar = new QStatusBar(this);
 457         statusbar->setObjectName(QString::fromUtf8("statusbar"));
 458         MainWindow->setStatusBar(statusbar);
 459         initStatusBar();
 460
 461         menubar = new QMenuBar(this);
 462         menubar->setObjectName(QString::fromUtf8("menubar"));
 463         menubar->setGeometry(QRect(0, 0, 1288, 27));
 464         menuControl = new QMenu(menubar);
 465         menuControl->setToolTipsVisible(true);
 466         menuControl->setObjectName(QString::fromUtf8("menuControl"));
 467         menuState = new QMenu(menuControl);
 468         menuState->setToolTipsVisible(true);
 469         menuState->setObjectName(QString::fromUtf8("menuState"));
 470
 471         menuSave_State = new QMenu(menuState);
 472         menuSave_State->setToolTipsVisible(true);
 473         menuSave_State->setObjectName(QString::fromUtf8("menuSaveState"));
 474
 475         menuLoad_State = new QMenu(menuState);
 476         menuLoad_State->setToolTipsVisible(true);
 477         menuLoad_State->setObjectName(QString::fromUtf8("menuLoadState"));
 478
 479         if(using_flags->is_use_auto_key()) {
 480                 menuCopy_Paste = new QMenu(menuControl);
 481                 menuCopy_Paste->setObjectName(QString::fromUtf8("menuCopy_Paste"));
 482                 menuCopy_Paste->setToolTipsVisible(true);
 483         }
 484         menuCpu_Speed = new QMenu(menuControl);
 485         menuCpu_Speed->setObjectName(QString::fromUtf8("menuCpu_Speed"));
 486         menuCpu_Speed->setToolTipsVisible(true);
 487         menuDebugger = new QMenu(menuControl);
 488         menuDebugger->setObjectName(QString::fromUtf8("menuDebugger"));
 489         menuDebugger->setToolTipsVisible(true);
 490         if(using_flags->is_use_fd()) {
 491                 int base_drv = using_flags->get_base_floppy_disk_num();
 492                 for(int i = 0; i < using_flags->get_max_drive(); i++) CreateFloppyMenu(i, base_drv + i);
 493         }
 494         if(using_flags->is_use_qd()) {
 495                 int base_drv = using_flags->get_base_quick_disk_num();
 496                 for(int i = 0; i < using_flags->get_max_qd(); i++) CreateQuickDiskMenu(i, base_drv + i);
 497         }
 498         if(using_flags->is_use_tape()) {
 499                 int base_drv = using_flags->get_base_tape_num();
 500                 for(int i = 0; i < using_flags->get_max_tape(); i++) CreateCMTMenu(i, base_drv + i);
 501         }
 502         if(using_flags->is_use_hdd()) {
 503                 int base_drv = using_flags->get_base_hdd_num();
 504                 for(int i = 0; i < using_flags->get_max_hdd(); i++) CreateHardDiskMenu(i, base_drv + i);
 505         }
 506         CreateScreenMenu();
 507         if(using_flags->is_use_cart()) {
 508                 int base_drv = using_flags->get_base_cart_num();
 509                 for(int i = 0; i < using_flags->get_max_cart(); i++) {
 510                         CreateCartMenu(i, base_drv + i);
 511                 }
 512         }
 513         if(using_flags->is_use_binary_file()) {
 514                 int base_drv = using_flags->get_base_binary_num();
 515                 for(int i = 0; i < using_flags->get_max_binary(); i++) {
 516                         CreateBinaryMenu(i, base_drv + i);
 517                 }
 518         }
 519         if(using_flags->is_use_compact_disc()) {
 520                 int base_drv = using_flags->get_base_compact_disc_num();
 521                 for(int i = 0; i < using_flags->get_max_cd(); i++) {
 522                         CreateCDROMMenu(i, base_drv + i);
 523                 }
 524         }
 525         if(using_flags->is_use_laser_disc()) {
 526                 int base_drv = using_flags->get_base_laser_disc_num();
 527                 for(int i = 0; i < using_flags->get_max_ld(); i++) {
 528                         CreateLaserdiscMenu(i, base_drv + i);
 529                 }
 530         }
 531         if(using_flags->is_use_bubble()) {
 532                 int base_drv = using_flags->get_base_bubble_num();
 533                 for(int i = 0; i < using_flags->get_max_bubble(); i++) {
 534                         CreateBubbleMenu(i, base_drv + i);
 535                 }
 536         }
 537         connect(this, SIGNAL(sig_update_screen(void)), graphicsView, SLOT(update(void)));
 538         //connect(this, SIGNAL(sig_update_screen(void)), graphicsView, SLOT(updateGL(void)));
 539
 540         menuMachine = new QMenu(menubar);
 541         menuMachine->setObjectName(QString::fromUtf8("menuMachine"));
 542         menuMachine->setToolTipsVisible(true);
 543
 544         if(using_flags->is_use_mouse()) {
 545                 actionMouseEnable = new Action_Control(this, using_flags);
 546                 actionMouseEnable->setCheckable(true);
 547                 actionMouseEnable->setVisible(true);
 548                 actionMouseEnable->setChecked(false);
 549                 menuMachine->addAction(actionMouseEnable);
 550                 connect(actionMouseEnable, SIGNAL(toggled(bool)),
 551                                 this, SLOT(do_set_mouse_enable(bool)));
 552                 connect(graphicsView, SIGNAL(sig_check_grab_mouse(bool)),
 553                                 actionMouseEnable, SLOT(do_check_grab_mouse(bool)));
 554         }
 555
 556         ConfigDeviceType();
 557         ConfigMouseType();
 558         ConfigKeyboardType();
 559         ConfigJoystickType();
 560         ConfigDriveType();
 561         ConfigSoundDeviceType();
 562         ConfigPrinterType();
 563         ConfigMonitorType();
 564
 565         if(!using_flags->is_without_sound()) {
 566                 menuSound = new QMenu(menubar);
 567                 menuSound->setObjectName(QString::fromUtf8("menuSound"));
 568                 menuSound->setToolTipsVisible(true);
 569         }
 570         menuEmulator = new QMenu(menubar);
 571         menuEmulator->setObjectName(QString::fromUtf8("menuEmulator"));
 572         menuEmulator->setToolTipsVisible(true);
 573
 574         menuHELP = new QMenu(menubar);
 575         menuHELP->setObjectName(QString::fromUtf8("menuHELP"));
 576         menuHELP->setToolTipsVisible(true);
 577         MainWindow->setMenuBar(menubar);
 578
 579         menubar->addAction(menuControl->menuAction());
 580         connectActions_ControlMenu();
 581         if(using_flags->is_use_fd()) {
 582                 int i;
 583                 for(i = 0; i < using_flags->get_max_drive(); i++) {
 584                         menubar->addAction(menu_fds[i]->menuAction());
 585                 }
 586         }
 587         if(using_flags->is_use_qd()) {
 588                 int i;
 589                 for(i = 0; i < using_flags->get_max_qd(); i++) {
 590                         menubar->addAction(menu_QDs[i]->menuAction());
 591                 }
 592         }
 593         if(using_flags->is_use_hdd()) {
 594                 int i;
 595                 for(i = 0; i < using_flags->get_max_hdd(); i++) {
 596                         menubar->addAction(menu_hdds[i]->menuAction());
 597                 }
 598         }
 599         if(using_flags->is_use_tape()) {
 600                 for(int i = 0; i < using_flags->get_max_tape(); i++) menubar->addAction(menu_CMT[i]->menuAction());
 601         }
 602         if(using_flags->is_use_cart()) {
 603                 int i;
 604                 for(i = 0; i < using_flags->get_max_cart(); i++) {
 605                         menubar->addAction(menu_Cart[i]->menuAction());
 606                 }
 607         }
 608         if(using_flags->is_use_binary_file()) {
 609                 for(int i = 0; i < using_flags->get_max_binary(); i++) {
 610                         menubar->addAction(menu_BINs[i]->menuAction());
 611                 }
 612         }
 613         if(using_flags->is_use_compact_disc()) {
 614                 for(int i = 0; i < using_flags->get_max_cd(); i++) {
 615                         menubar->addAction(menu_CDROM[i]->menuAction());
 616                 }
 617         }
 618         if(using_flags->is_use_laser_disc()) {
 619                 for(int i = 0; i < using_flags->get_max_ld(); i++) {
 620                         menubar->addAction(menu_Laserdisc[i]->menuAction());
 621                 }
 622         }
 623         if(using_flags->is_use_bubble()) {
 624                 int i;
 625                 for(i = 0; i < using_flags->get_max_bubble(); i++) {
 626                         menubar->addAction(menu_bubbles[i]->menuAction());
 627                 }
 628         }
 629         menubar->addAction(menuMachine->menuAction());
 630         if(!using_flags->is_without_sound()) {
 631                 menubar->addAction(menuSound->menuAction());
 632         }
 633
 634         menubar->addAction(menuScreen->menuAction());
 635 //      menubar->addAction(menuRecord->menuAction());
 636         menubar->addAction(menuEmulator->menuAction());
 637         menubar->addAction(menuHELP->menuAction());
 638         if(using_flags->is_use_qd()) {
 639                 int i;
 640                 for(i = 0; i < using_flags->get_max_qd(); i++) {
 641                         CreateQuickDiskPulldownMenu(i);
 642                 }
 643         }
 644         if(using_flags->is_use_binary_file()) {
 645                 int i;
 646                 for(i = 0; i < using_flags->get_max_binary(); i++) {
 647                         CreateBinaryPulldownMenu(1);
 648                 }
 649         }
 650         if(!using_flags->is_without_sound()) {
 651                 CreateSoundMenu();
 652         }
 653         CreateEmulatorMenu();
 654
 655         menuHELP->addAction(actionAbout);
 656         connect(actionAbout, SIGNAL(triggered()), this, SLOT(do_show_about()));
 657         menuHELP->addSeparator();
 658
 659         actionHelp_AboutQt = new Action_Control(this, using_flags);
 660         actionHelp_AboutQt->setObjectName(QString::fromUtf8("menuHelp_AboutQt"));
 661         menuHELP->addAction(actionHelp_AboutQt);
 662         menuHELP->addSeparator();
 663         menuHelp_Readme = new QMenu(menuHELP);
 664         menuHelp_Readme->setObjectName(QString::fromUtf8("menuHelp_Readme_menu"));;
 665         menuHelp_Readme->setToolTipsVisible(true);
 666         menuHELP->addAction(menuHelp_Readme->menuAction());
 667
 668         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README, "menuHelp_README", "readme.txt");
 669         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_QT, "menuHelp_README_QT", "readme.qt.txt");
 670         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_Artane, "menuHelp_README_Artane", "readme_by_artane.txt");
 671         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_Umaiboux, "menuHelp_README_Umaiboux", "readme_by_umaiboux.txt");
 672         menuHelp_Readme->addSeparator();
 673         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_BIOS, "menuHelp_README_BIOS", "bios_and_keys.txt");
 674         menuHelp_Readme->addSeparator();
 675         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_MR_TANAM, "menuHelp_README_MR_TANAM", "readme_by_mr_tanam.txt");
 676         menuHelp_Readme->addSeparator();
 677         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_FAQ, "menuHelp_README_FAQ", "FAQ.html");
 678         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_FAQ_JP, "menuHelp_README_FAQ_JP", "FAQ.ja.html");
 679         menuHelp_Readme->addSeparator();
 680         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_FM7, "menuHelp_README_FM7", "readme_fm7.txt");
 681         SET_HELP_MENUENTRY(menuHelp_Readme, actionHelp_README_FM7_JP, "menuHelp_README_FM7_JP", "readme_fm7.jp.txt");
 682
 683         menuHelp_Histories = new QMenu(menuHELP);
 684         menuHelp_Histories->setObjectName(QString::fromUtf8("menuHelp_Histories"));;
 685         menuHelp_Histories->setToolTipsVisible(true);
 686         menuHELP->addAction(menuHelp_Histories->menuAction());
 687
 688         SET_HELP_MENUENTRY(menuHelp_Histories, actionHelp_History, "menuHelp_History", "history.txt");
 689         SET_HELP_MENUENTRY(menuHelp_Histories, actionHelp_History_Relnote, "menuHelp_History_Relnote", "RELEASENOTE.txt");
 690         SET_HELP_MENUENTRY(menuHelp_Histories, actionHelp_History_ChangeLog, "menuHelp_History_Changelog", "ChangeLog.txt");
 691         SET_HELP_MENUENTRY(menuHelp_Histories, actionHelp_History_MR_TANAM, "menuHelp_History_MR_TANAM", "history_by_mr_tanam.txt");
 692
 693         SET_HELP_MENUENTRY(menuHELP, actionHelp_License, "menuHelp_License", "LICENSE.txt");
 694         SET_HELP_MENUENTRY(menuHELP, actionHelp_License_JP, "menuHelp_License_JP", "LICENSE.ja.txt");
 695
 696         if(p_config->window_mode <= 0) p_config->window_mode = 0;
 697         if(p_config->window_mode >= using_flags->get_screen_mode_num()) p_config->window_mode = using_flags->get_screen_mode_num() - 1;
 698         w = using_flags->get_screen_width();
 699         h = using_flags->get_screen_height();
 700         if(actionScreenSize[p_config->window_mode] != NULL) {
 701                 double nd = actionScreenSize[p_config->window_mode]->binds->getDoubleValue();
 702                 w = (int)(nd * (double)w);
 703                 h = (int)(nd * (double)h);
 704                 switch(p_config->rotate_type) {
 705                 case 0:
 706                 case 2:
 707                         break;
 708                 case 1:
 709                 case 4:
 710                          {
 711                                 int tmp_w = w;
 712                                 w = h;
 713                                 h = tmp_w;
 714                         }
 715                 }
 716         } else {
 717                 switch(p_config->rotate_type) {
 718                 case 0:
 719                 case 2:
 720                         w = 1208;
 721                         h = 800;
 722                         break;
 723                 case 1:
 724                 case 4:
 725                         w = 600;
 726                         h = 960;
 727                         break;
 728                 }
 729         }
 730         graphicsView->setFixedSize(w, h);
 731         for(int i = 0; i < using_flags->get_screen_mode_num(); i++) {
 732                 if(actionScreenSize[i] != NULL) {
 733                         connect(actionScreenSize[i]->binds, SIGNAL(sig_screen_multiply(float)),
 734                                 graphicsView, SLOT(do_set_screen_multiply(float)));
 735                 }
 736         }
 737         this->set_screen_size(w, h);
 738         this->set_screen_aspect(p_config->window_stretch_type);
 739         if(actionScreenSize[p_config->window_mode] != NULL) {
 740                 double nd = actionScreenSize[p_config->window_mode]->binds->getDoubleValue();
 741                 graphicsView->do_set_screen_multiply(nd);
 742         }
 743         if(using_flags->is_use_joystick()) {
 744                 connect(action_SetupJoykey, SIGNAL(triggered()), this, SLOT(rise_joykey_dialog()));
 745                 connect(action_SetupJoystick, SIGNAL(triggered()), this, SLOT(rise_joystick_dialog()));
 746         }
 747
 748         if(using_flags->is_use_sound_files_fdd()) {
 749                 connect(action_SoundFilesFDD, SIGNAL(toggled(bool)), this, SLOT(do_set_sound_files_fdd(bool)));
 750         }
 751         if(using_flags->is_use_sound_files_relay()) {
 752                 connect(action_SoundFilesRelay, SIGNAL(toggled(bool)), this, SLOT(do_set_sound_files_relay(bool)));
 753         }
 754         connect(action_SetupKeyboard, SIGNAL(triggered()), this, SLOT(rise_keyboard_dialog()));
 755 #if !defined(Q_OS_WIN)
 756         connect(action_LogToSyslog, SIGNAL(toggled(bool)), this, SLOT(do_set_syslog(bool)));
 757 #endif
 758         connect(action_LogToConsole, SIGNAL(toggled(bool)), this, SLOT(do_set_conslog(bool)));
 759         csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Menu OK");
 760
 761         QImageReader reader(":/default.ico");
 762         QImage result = reader.read();
 763
 764         MainWindow->setWindowIcon(QPixmap::fromImage(result));
 765         this->set_window_title();
 766 //      QIcon WindowIcon;
 767         InsertIcon = QApplication::style()->standardIcon(QStyle::SP_FileDialogStart);
 768         EjectIcon  = QIcon(":/icon_eject.png");
 769         StopIcon = QIcon(":/icon_process_stop.png");
 770         RecordSoundIcon = QIcon(":/icon_record_to_wav.png");
 771         ResetIcon = QApplication::style()->standardIcon(QStyle::SP_BrowserReload);
 772
 773         VolumeMutedIcon = QIcon(":/icon_volume_muted.png");
 774         VolumeLowIcon = QIcon(":/icon_volume_low.png");
 775         VolumeMidIcon = QIcon(":/icon_volume_mid.png");
 776         VolumeHighIcon = QIcon(":/icon_volume_high.png");
 777
 778         ExitIcon = QIcon(":/icon_exit.png");
 779
 780         QMetaObject::connectSlotsByName(MainWindow);
 781         csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "setupUI() OK");
 782 } // setupUi
 783
 784 // Emulator
 785 #include "dropdown_joystick.h"
 786 #include "dropdown_joykey.h"
 787 #include "dialog_set_key.h"
 788
 789 void Ui_MainWindowBase::retranslateEmulatorMenu(void)
 790 {
 791         if(using_flags->is_use_joystick()) {
 792                 action_SetupJoystick->setText(QApplication::translate("MenuEmulator", "Configure Joysticks", 0));
 793                 action_SetupJoystick->setToolTip(QApplication::translate("MenuEmulator", "Configure assigning buttons/directions of joysticks.", 0));
 794                 action_SetupJoykey->setText(QApplication::translate("MenuEmulator", "Configure Joystick to KEYBOARD", 0));
 795                 action_SetupJoykey->setToolTip(QApplication::translate("MenuEmulator", "Configure assigning keycode to joystick buttons.\nThis feature using Joystick #1.", 0));
 796                 action_UseJoykey->setText(QApplication::translate("MenuEmulator", "Joystick to KEYBOARD", 0));
 797                 action_UseJoykey->setToolTip(QApplication::translate("MenuEmulator", "Use Joystick axis/buttons to input keyboard.\nThis feature using Joystick #1.", 0));
 798                 action_SetupJoystick->setIcon(QIcon(":/icon_gamepad.png"));
 799         }
 800         if(using_flags->is_use_auto_key()) {
 801                 action_UseRomaKana->setText(QApplication::translate("MenuEmulator", "ROMA-KANA Conversion", 0));
 802                 action_UseRomaKana->setToolTip(QApplication::translate("MenuEmulator", "Use romaji-kana conversion assistant of emulator.", 0));
 803         }
 804         actionSpeed_FULL->setText(QApplication::translate("MenuEmulator", "Emulate as FULL SPEED", 0));
 805         actionSpeed_FULL->setToolTip(QApplication::translate("MenuEmulator", "Run emulation thread without frame sync.", 0));
 806
 807         action_NumPadEnterAsFullkey->setText(QApplication::translate("MenuEmulator", "Numpad's Enter is Fullkey's", 0));
 808         action_NumPadEnterAsFullkey->setToolTip(QApplication::translate("MenuEmulator", "Numpad's enter key makes full key's enter.\nUseful for some VMs.", 0));
 809
 810         action_PrintCpuStatistics->setText(QApplication::translate("MenuEmulator", "Print Statistics", 0));
 811         action_PrintCpuStatistics->setToolTip(QApplication::translate("MenuEmulator", "Print statistics of CPUs (or some devices).\nUseful for debugging.", 0));
 812
 813         if(action_Logging_FDC != NULL) {
 814                 action_Logging_FDC->setText(QApplication::translate("MenuEmulator", "FDC: Turn ON Debug log.", 0));
 815                 action_Logging_FDC->setToolTip(QApplication::translate("MenuEmulator", "Turn ON debug logging for FDCs.Useful to resolve issues from guest software.", 0));
 816         }
 817         // ToDo
 818         menu_EmulateCursorAs->setTitle(QApplication::translate("MenuEmulator", "Emulate cursor as", 0));
 819         menu_EmulateCursorAs->setToolTip(QApplication::translate("MenuEmulator", "Emulate cursor as ten-key.", 0));
 820         action_EmulateCursorAs[0]->setText(QApplication::translate("MenuEmulator", "None", 0));
 821         action_EmulateCursorAs[1]->setText(QApplication::translate("MenuEmulator", "2 4 6 8", 0));
 822         action_EmulateCursorAs[2]->setText(QApplication::translate("MenuEmulator", "1 2 3 5", 0));
 823
 824         menuEmulator->setTitle(QApplication::translate("MenuEmulator", "Emulator", 0));
 825
 826
 827         action_FocusWithClick->setText(QApplication::translate("MenuEmulator", "Focus on click", 0));
 828         action_FocusWithClick->setToolTip(QApplication::translate("MenuEmulator", "If set, focus with click, not mouse-over.", 0));
 829
 830         action_SetupKeyboard->setText(QApplication::translate("MenuEmulator", "Configure Keyboard", 0));
 831         action_SetupKeyboard->setToolTip(QApplication::translate("MenuEmulator", "Set addignation of keyboard.", 0));
 832         action_SetupKeyboard->setIcon(QIcon(":/icon_keyboard.png"));
 833         action_SetupMovie->setText(QApplication::translate("MenuEmulator", "Configure movie encoding", 0));
 834         action_SetupMovie->setToolTip(QApplication::translate("MenuEmulator", "Configure parameters of movie encoding.", 0));
 835
 836         action_LogToConsole->setText(QApplication::translate("MenuEmulator", "Log to Console", 0));
 837         action_LogToConsole->setToolTip(QApplication::translate("MenuEmulator", "Enable logging to STDOUT if checked.", 0));
 838 #if !defined(Q_OS_WIN)
 839         action_LogToSyslog->setText(QApplication::translate("MenuEmulator", "Log to Syslog", 0));
 840         action_LogToSyslog->setToolTip(QApplication::translate("MenuEmulator", "Enable logging to SYSTEM log.\nMay be having permission to system and using *nix OS.", 0));
 841         //action_LogRecord->setText(QApplication::translate("MenuEmulator", "Recording Log", 0));
 842 #endif
 843         if(using_flags->is_use_sound_files_fdd()) {
 844                 action_SoundFilesFDD->setText(QApplication::translate("MenuEmulator", "Sound FDD Seek", 0));
 845                 action_SoundFilesFDD->setToolTip(QApplication::translate("MenuEmulator", "Enable FDD HEAD seeking sound.\nNeeds sound file.\nSee HELP->READMEs->Bios and Key assigns", 0));
 846         }
 847         if(using_flags->is_use_sound_files_relay()) {
 848                 action_SoundFilesRelay->setText(QApplication::translate("MenuEmulator", "Sound CMT Relay and Buttons", 0));
 849                 action_SoundFilesRelay->setToolTip(QApplication::translate("MenuEmulator", "Enable CMT relay's sound and buttons's sounds.\nNeeds sound file.\nSee HELP->READMEs->Bios and Key assigns", 0));
 850                 if(using_flags->is_tape_binary_only()) action_SoundFilesRelay->setEnabled(false);
 851         }
 852         menuDevLogToConsole->setTitle(QApplication::translate("MenuEmulator", "Per Device", 0));
 853 #if !defined(Q_OS_WIN)
 854         menuDevLogToSyslog->setTitle(QApplication::translate("MenuEmulator", "Per Device", 0));
 855 #endif
 856         menu_SetRenderPlatform->setTitle(QApplication::translate("MenuEmulator", "Video Platform(need restart)", 0));
 857         if(menu_SetFixedCpu != NULL) {
 858                 menu_SetFixedCpu->setTitle(QApplication::translate("MenuEmulator", "Occupy Fixed CPU", 0));
 859
 860                 if(action_ResetFixedCpu != NULL) {
 861                         action_ResetFixedCpu->setText(QApplication::translate("MenuEmulator", "Using all CPU", 0));
 862                         action_ResetFixedCpu->setToolTip(QApplication::translate("MenuEmulator", "Using all CPU to emulation.\nReset cpu usings.", 0));
 863                 }
 864                 for(int ii = 0; ii < 128; ii++) {
 865                         if(action_SetFixedCpu[ii] != NULL) {
 866                                 QString numname = QString::number(ii);
 867                                 QString numtip = QApplication::translate("MenuEmulator", "Set Fixed logical CPU #%1 to be occupied by emulation thread.\nMay useful for heavy VM (i.e. using i386 CPU).\nStill implement LINUX host only, not another operating systems.", 0).arg(numname);
 868                                 action_SetFixedCpu[ii]->setText(QString::fromUtf8("CPU #") + numname);
 869                                 action_SetFixedCpu[ii]->setToolTip(numtip);
 870                         }
 871                 }
 872         }
 873         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL_ES_2]->setText(QApplication::translate("MenuEmulator", "OpenGL ES v2.0", 0));
 874         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL3_MAIN]->setText(QApplication::translate("MenuEmulator", "OpenGLv3.0", 0));
 875         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL2_MAIN]->setText(QApplication::translate("MenuEmulator", "OpenGLv2.0", 0));
 876         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL_CORE]->setText(QApplication::translate("MenuEmulator", "OpenGL(Core profile)", 0));
 877
 878         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL_ES_2]->setToolTip(QApplication::translate("MenuEmulator", "Using OpenGL ES v2.0.\nThis is recommanded.\nIf changed, need to restart this emulator.", 0));
 879         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL3_MAIN]->setToolTip(QApplication::translate("MenuEmulator", "Using OpenGL v3.0(MAIN).\nThis is recommanded.\nIf changed, need to restart this emulator.", 0));
 880         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL2_MAIN]->setToolTip(QApplication::translate("MenuEmulator", "Using OpenGLv2.\nThis is fallback of some systems.\nIf changed, need to restart this emulator.", 0));
 881         action_SetRenderPlatform[RENDER_PLATFORMS_OPENGL_CORE]->setToolTip(QApplication::translate("MenuEmulator", "Using OpenGL core profile.\nThis still not implement.\nIf changed, need to restart this emulator.", 0));
 882
 883         menu_DispVirtualMedias->setTitle(QApplication::translate("MenuEmulator", "Show Virtual Medias.", 0));
 884         action_DispVirtualMedias[0]->setText(QApplication::translate("MenuEmulator", "None.", 0));
 885         action_DispVirtualMedias[1]->setText(QApplication::translate("MenuEmulator", "Upper.", 0));
 886         action_DispVirtualMedias[2]->setText(QApplication::translate("MenuEmulator", "Lower.", 0));
 887         //action_DispVirtualMedias[3]->setText(QApplication::translate("MenuEmulator", "Left.", 0));
 888         //action_DispVirtualMedias[4]->setText(QApplication::translate("MenuEmulator", "Right.", 0));
 889         action_LogView->setText(QApplication::translate("MenuEmulator", "View Log", 0));
 890         action_LogView->setToolTip(QApplication::translate("MenuEmulator", "View emulator logs with a dialog.", 0));
 891 }
 892
 893 void Ui_MainWindowBase::retranselateUi_Depended_OSD(void)
 894 {
 895         for(int i=0; i < (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1) ; i++) {
 896                 const _TCHAR *p;
 897                 p = using_flags->get_vm_node_name(i);
 898                 do_update_device_node_name(i, p);
 899         }
 900 }
 901
 902 void Ui_MainWindowBase::do_set_roma_kana(bool flag)
 903 {
 904         p_config->romaji_to_kana = flag;
 905         emit sig_set_roma_kana(flag);
 906 }
 907
 908 void Ui_MainWindowBase::do_set_numpad_enter_as_fullkey(bool flag)
 909 {
 910         p_config->numpad_enter_as_fullkey = flag;
 911 }
 912
 913 void Ui_MainWindowBase::do_set_joy_to_key(bool flag)
 914 {
 915         p_config->use_joy_to_key = flag;
 916 }
 917
 918 void Ui_MainWindowBase::do_set_print_cpu_statistics(bool flag)
 919 {
 920         p_config->print_statistics = flag;
 921         emit sig_emu_update_config();
 922 }
 923
 924 void Ui_MainWindowBase::CreateEmulatorMenu(void)
 925 {
 926         //menuEmulator->addAction(action_LogRecord);
 927         menuEmulator->addAction(action_FocusWithClick);
 928         menuEmulator->addAction(menu_DispVirtualMedias->menuAction());
 929         menuEmulator->addSeparator();
 930         if(using_flags->is_use_auto_key()) {
 931                 menuEmulator->addAction(action_UseRomaKana);
 932         }
 933         if(using_flags->is_use_joystick()) {
 934                 menuEmulator->addAction(action_UseJoykey);
 935         }
 936         menuEmulator->addAction(action_NumPadEnterAsFullkey);
 937         menuEmulator->addSeparator();
 938         menuEmulator->addAction(actionSpeed_FULL);
 939         if(menu_SetFixedCpu != NULL) {
 940                 menuEmulator->addAction(menu_SetFixedCpu->menuAction());
 941         }
 942         menuEmulator->addSeparator();
 943         menuEmulator->addAction(menu_EmulateCursorAs->menuAction());
 944         if(action_Logging_FDC != NULL) {
 945                 menuEmulator->addSeparator();
 946                 menuEmulator->addAction(action_Logging_FDC);
 947         }
 948         menuEmulator->addAction(action_PrintCpuStatistics);
 949         menuEmulator->addSeparator();
 950         menuEmulator->addAction(action_LogToConsole);
 951         menuEmulator->addAction(menuDevLogToConsole->menuAction());
 952         menuEmulator->addSeparator();
 953 #if !defined(Q_OS_WIN)
 954         menuEmulator->addAction(action_LogToSyslog);
 955         menuEmulator->addAction(menuDevLogToSyslog->menuAction());
 956 #endif
 957         menuEmulator->addSeparator();
 958         menuEmulator->addAction(action_LogView);
 959         menuEmulator->addSeparator();
 960         if(using_flags->is_use_sound_files_fdd() || using_flags->is_use_sound_files_relay()) {
 961                 if(using_flags->is_use_sound_files_fdd())     menuEmulator->addAction(action_SoundFilesFDD);
 962                 if(using_flags->is_use_sound_files_relay())   menuEmulator->addAction(action_SoundFilesRelay);
 963                 menuEmulator->addSeparator();
 964         }
 965         menuEmulator->addAction(menu_SetRenderPlatform->menuAction());
 966
 967         if(using_flags->is_use_joystick()) {
 968                 menuEmulator->addAction(action_SetupJoystick);
 969                 menuEmulator->addAction(action_SetupJoykey);
 970         }
 971         menuEmulator->addAction(action_SetupKeyboard);
 972         menuEmulator->addAction(action_SetupMovie);
 973 }
 974
 975 void Ui_MainWindowBase::ConfigMonitorType(void)
 976 {
 977         if(using_flags->get_use_monitor_type() > 0) {
 978                 int ii;
 979                 menuMonitorType = new QMenu(menuMachine);
 980                 menuMonitorType->setObjectName(QString::fromUtf8("menuControl_MonitorType"));
 981                 menuMachine->addAction(menuMonitorType->menuAction());
 982
 983                 actionGroup_MonitorType = new QActionGroup(this);
 984                 actionGroup_MonitorType->setExclusive(true);
 985                 for(ii = 0; ii < using_flags->get_use_monitor_type(); ii++) {
 986                         actionMonitorType[ii] = new Action_Control(this, using_flags);
 987                         actionGroup_MonitorType->addAction(actionMonitorType[ii]);
 988                         actionMonitorType[ii]->setCheckable(true);
 989                         actionMonitorType[ii]->setVisible(true);
 990                         actionMonitorType[ii]->binds->setValue1(ii);
 991                         if(p_config->monitor_type == ii) actionMonitorType[ii]->setChecked(true);
 992                         menuMonitorType->addAction(actionMonitorType[ii]);
 993                         connect(actionMonitorType[ii], SIGNAL(triggered()),
 994                                         actionMonitorType[ii]->binds, SLOT(do_set_monitor_type()));
 995                         connect(actionMonitorType[ii]->binds, SIGNAL(sig_monitor_type(int)),
 996                                         this, SLOT(set_monitor_type(int)));
 997                 }
 998         }
 999 }
1000 #if defined(Q_OS_LINUX)
1001 //#define _GNU_SOURCE
1002 #include <unistd.h>
1003 #include <sched.h>
1004 #endif
1005
1006 void Ui_MainWindowBase::ConfigEmulatorMenu(void)
1007 {
1008         int i;
1009         QString tmps;
1010         actionGroup_DispVirtualMedias = new QActionGroup(this);
1011         actionGroup_DispVirtualMedias->setExclusive(true);
1012         menu_DispVirtualMedias = new QMenu(this);
1013         menu_DispVirtualMedias->setToolTipsVisible(true);
1014         for(i = 0; i < 3; i++) {
1015                 action_DispVirtualMedias[i] = new Action_Control(this, using_flags);
1016                 action_DispVirtualMedias[i]->setCheckable(true);
1017                 action_DispVirtualMedias[i]->setChecked(false);
1018                 if(i == p_config->virtual_media_position) action_DispVirtualMedias[i]->setChecked(true);
1019                 action_DispVirtualMedias[i]->setEnabled(true);
1020                 actionGroup_DispVirtualMedias->addAction(action_DispVirtualMedias[i]);
1021                 menu_DispVirtualMedias->addAction(action_DispVirtualMedias[i]);
1022         }
1023         connect(action_DispVirtualMedias[0], SIGNAL(triggered()), this, SLOT(do_set_visible_virtual_media_none()));
1024         connect(action_DispVirtualMedias[1], SIGNAL(triggered()), this, SLOT(do_set_visible_virtual_media_upper()));
1025         connect(action_DispVirtualMedias[2], SIGNAL(triggered()), this, SLOT(do_set_visible_virtual_media_lower()));
1026
1027         if(using_flags->is_use_joystick()) {
1028                 SET_ACTION_SINGLE(action_UseJoykey, true, true, (p_config->use_joy_to_key));
1029                 connect(action_UseJoykey, SIGNAL(toggled(bool)), this, SLOT(do_set_joy_to_key(bool)));
1030         }
1031
1032         if(using_flags->is_use_auto_key()) {
1033                 // ToDo: Setup if checked.
1034                 SET_ACTION_SINGLE(action_UseRomaKana, true, true, (p_config->romaji_to_kana));
1035                 connect(action_UseRomaKana, SIGNAL(toggled(bool)), this, SLOT(do_set_roma_kana(bool)));
1036         }
1037         SET_ACTION_SINGLE(action_NumPadEnterAsFullkey, true, true, (p_config->numpad_enter_as_fullkey));
1038         connect(action_NumPadEnterAsFullkey, SIGNAL(toggled(bool)), this, SLOT(do_set_numpad_enter_as_fullkey(bool)));
1039
1040         SET_ACTION_SINGLE(action_PrintCpuStatistics, true, true, (p_config->print_statistics));
1041         connect(action_PrintCpuStatistics, SIGNAL(toggled(bool)), this, SLOT(do_set_print_cpu_statistics(bool)));
1042
1043         // Cursor to ten key.
1044         menu_EmulateCursorAs = new QMenu(this);
1045         menu_EmulateCursorAs->setToolTipsVisible(true);
1046         actionGroup_EmulateCursorAs = new QActionGroup(this);
1047         actionGroup_EmulateCursorAs->setExclusive(true);
1048         {
1049                 for(i = 0; i < 3; i++) {
1050                         tmps = QString::number(i);
1051                         action_EmulateCursorAs[i] = new Action_Control(this, using_flags);
1052                         action_EmulateCursorAs[i]->setObjectName(QString::fromUtf8("action_EmulateCursorAs", -1) + tmps);
1053                         action_EmulateCursorAs[i]->setCheckable(true);
1054                         action_EmulateCursorAs[i]->binds->setValue1(i);
1055                         actionGroup_EmulateCursorAs->addAction(action_EmulateCursorAs[i]);
1056                         menu_EmulateCursorAs->addAction(action_EmulateCursorAs[i]);
1057                         if(i == p_config->cursor_as_ten_key) action_EmulateCursorAs[i]->setChecked(true);
1058
1059                         connect(action_EmulateCursorAs[i], SIGNAL(triggered()),
1060                                         action_EmulateCursorAs[i], SLOT(do_set_emulate_cursor_as()));
1061                         connect(action_EmulateCursorAs[i], SIGNAL(sig_set_emulate_cursor_as(int)),
1062                                         this, SLOT(do_set_emulate_cursor_as(int)));
1063                 }
1064         }
1065
1066         actionSpeed_FULL = new Action_Control(this, using_flags);
1067         actionSpeed_FULL->setObjectName(QString::fromUtf8("actionSpeed_FULL"));
1068         actionSpeed_FULL->setVisible(true);
1069         actionSpeed_FULL->setCheckable(true);
1070         actionSpeed_FULL->setChecked(false);
1071         if(p_config->full_speed) actionSpeed_FULL->setChecked(true);
1072         connect(actionSpeed_FULL, SIGNAL(toggled(bool)), this,SLOT(do_emu_full_speed(bool))); // OK?
1073
1074         if(using_flags->is_use_joystick()) {
1075                 action_SetupJoystick = new Action_Control(this, using_flags);
1076                 action_SetupJoykey = new Action_Control(this, using_flags);
1077         }
1078         if(using_flags->is_use_sound_files_fdd()) {
1079                 /*
1080                 action_SoundFilesFDD = new Action_Control(this, using_flags);
1081                 action_SoundFilesFDD->setCheckable(true);
1082                 action_SoundFilesFDD->setEnabled(true);
1083                 action_SoundFilesFDD->setChecked(false);
1084                 if(p_config->sound_noise_fdd != 0) {
1085                         action_SoundFilesFDD->setChecked(true);
1086                 }
1087                 */
1088                 SET_ACTION_SINGLE(action_SoundFilesFDD, true, true, (p_config->sound_noise_fdd != 0));
1089         }
1090         if(using_flags->is_use_sound_files_relay()) {
1091                 /*
1092                 action_SoundFilesRelay = new Action_Control(this, using_flags);
1093                 action_SoundFilesRelay->setCheckable(true);
1094                 action_SoundFilesRelay->setEnabled(true);
1095                 action_SoundFilesRelay->setChecked(false);
1096                 if(p_config->sound_noise_cmt != 0) {
1097                         action_SoundFilesRelay->setChecked(true);
1098                 }
1099                 */
1100                 SET_ACTION_SINGLE(action_SoundFilesRelay, true, true, (p_config->sound_noise_cmt != 0));
1101         }
1102         action_FocusWithClick = new Action_Control(this, using_flags);
1103         action_FocusWithClick->setCheckable(true);
1104         action_FocusWithClick->setEnabled(true);
1105         if(p_config->focus_with_click) {
1106                 action_FocusWithClick->setChecked(true);
1107         }
1108
1109         connect(action_FocusWithClick, SIGNAL(toggled(bool)),
1110                                 this, SLOT(do_set_window_focus_type(bool)));
1111         //connect(action_FocusWithClick, SIGNAL(sig_set_window_focus_type(bool)),
1112         //                      this, SLOT(do_set_window_focus_type(bool)));
1113
1114         action_Logging_FDC = NULL;
1115         if(using_flags->is_use_fd()) {
1116                 SET_ACTION_SINGLE(action_Logging_FDC, true, true, (p_config->special_debug_fdc != 0));
1117                 connect(action_Logging_FDC, SIGNAL(toggled(bool)), this, SLOT(do_set_logging_fdc(bool)));
1118         }
1119 #if !defined(Q_OS_WIN)
1120         action_LogToSyslog = new Action_Control(this, using_flags);
1121         action_LogToSyslog->setCheckable(true);
1122         action_LogToSyslog->setEnabled(true);
1123         if(p_config->log_to_syslog != 0) action_LogToSyslog->setChecked(true);
1124         menuDevLogToSyslog = new QMenu(this);
1125         menuDevLogToSyslog->setToolTipsVisible(true);
1126         for(int i = 0; i < (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1); i++) {
1127                 action_DevLogToSyslog[i] = new Action_Control(this, using_flags);
1128                 action_DevLogToSyslog[i]->setCheckable(true);
1129                 action_DevLogToSyslog[i]->setEnabled(false);
1130                 action_DevLogToSyslog[i]->binds->setValue1(i);
1131                 menuDevLogToSyslog->addAction(action_DevLogToSyslog[i]);
1132                 if(p_config->dev_log_to_syslog[i][0]) action_DevLogToSyslog[i]->setChecked(true);
1133                 connect(action_DevLogToSyslog[i], SIGNAL(toggled(bool)),
1134                                 action_DevLogToSyslog[i], SLOT(do_set_dev_log_to_syslog(bool)));
1135                 connect(action_DevLogToSyslog[i], SIGNAL(sig_set_dev_log_to_syslog(int, bool)),
1136                                 this, SLOT(do_set_dev_log_to_syslog(int, bool)));
1137         }
1138 #endif
1139         action_LogToConsole = new Action_Control(this, using_flags);
1140         action_LogToConsole->setCheckable(true);
1141         action_LogToConsole->setEnabled(true);
1142         if(p_config->log_to_console != 0) action_LogToConsole->setChecked(true);
1143
1144         //menuDevLogToConsole = new QMenu(menuEmulator);
1145         menuDevLogToConsole = new QMenu(this);
1146         menuDevLogToConsole->setToolTipsVisible(true);
1147
1148         SET_ACTION_CONTROL_ARRAY(0, (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1),
1149                                                          this, using_flags,
1150                                                          menuDevLogToConsole, action_DevLogToConsole, true, false,
1151                                                          dev_log_to_console,
1152                                                          SIGNAL(toggled(bool)),
1153                                                          SLOT(do_set_dev_log_to_console(bool)),
1154                                                          SIGNAL(sig_set_dev_log_to_console(int, bool)),
1155                                                          SLOT(do_set_dev_log_to_console(int, bool)));
1156         /*
1157         for(int i = 0; i < (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1); i++) {
1158                 action_DevLogToConsole[i] = new Action_Control(this, using_flags);
1159                 action_DevLogToConsole[i]->setCheckable(true);
1160                 action_DevLogToConsole[i]->setEnabled(false);
1161                 action_DevLogToConsole[i]->binds->setValue1(i);
1162                 menuDevLogToConsole->addAction(action_DevLogToConsole[i]);
1163                 if(p_config->dev_log_to_console[i][0]) action_DevLogToConsole[i]->setChecked(true);
1164                 connect(action_DevLogToConsole[i], SIGNAL(toggled(bool)),
1165                                 action_DevLogToConsole[i], SLOT(do_set_dev_log_to_console(bool)));
1166                 connect(action_DevLogToConsole[i], SIGNAL(sig_set_dev_log_to_console(int, bool)),
1167                                 this, SLOT(do_set_dev_log_to_console(int, bool)));
1168         }
1169         */
1170         action_LogView = new Action_Control(this, using_flags);
1171         connect(action_LogView, SIGNAL(triggered()),
1172                         this, SLOT(rise_log_viewer()));
1173
1174         long cpus = -1;
1175 #if defined(Q_OS_LINUX)
1176         {
1177                 cpus = sysconf(_SC_NPROCESSORS_ONLN);
1178         }
1179 #endif
1180         menu_SetFixedCpu = NULL;
1181         action_ResetFixedCpu = NULL;
1182         for(i = 0; i < 128; i++) {
1183                 action_SetFixedCpu[i] = NULL;
1184         }
1185         if(cpus > 0) {
1186                 menu_SetFixedCpu = new QMenu(this);
1187                 menu_SetFixedCpu->setToolTipsVisible(true);
1188                 actionGroup_SetFixedCpu = new QActionGroup(this);
1189                 actionGroup_SetFixedCpu->setExclusive(true);
1190                 if(cpus >= 128) cpus = 128;
1191                 action_ResetFixedCpu = new Action_Control(this, using_flags);
1192                 action_ResetFixedCpu->setObjectName(QString::fromUtf8("action_SetFixedCpu", -1) + tmps);
1193                 action_ResetFixedCpu->setCheckable(true);
1194                 action_ResetFixedCpu->binds->setValue1(-1);
1195                 actionGroup_SetFixedCpu->addAction(action_ResetFixedCpu);
1196                 menu_SetFixedCpu->addAction(action_ResetFixedCpu);
1197                 connect(action_ResetFixedCpu, SIGNAL(triggered()),
1198                                 action_ResetFixedCpu->binds, SLOT(do_select_fixed_cpu(void)));
1199                 connect(action_ResetFixedCpu->binds, SIGNAL(sig_set_fixed_cpu(int)),
1200                                 this, SLOT(do_select_fixed_cpu(int)));
1201
1202                 for(i = 0; i < cpus; i++) {
1203                         tmps = QString::number(i);
1204                         action_SetFixedCpu[i] = new Action_Control(this, using_flags);
1205                         action_SetFixedCpu[i]->setObjectName(QString::fromUtf8("action_SetFixedCpu", -1) + tmps);
1206                         action_SetFixedCpu[i]->setCheckable(true);
1207                         action_SetFixedCpu[i]->binds->setValue1(i);
1208                         actionGroup_SetFixedCpu->addAction(action_SetFixedCpu[i]);
1209                         menu_SetFixedCpu->addAction(action_SetFixedCpu[i]);
1210                         connect(action_SetFixedCpu[i], SIGNAL(triggered()),
1211                                         action_SetFixedCpu[i]->binds, SLOT(do_select_fixed_cpu(void)));
1212                         connect(action_SetFixedCpu[i]->binds, SIGNAL(sig_set_fixed_cpu(int)),
1213                                         this, SLOT(do_select_fixed_cpu(int)));
1214                 }
1215         }
1216         menu_SetRenderPlatform = new QMenu(this);
1217         menu_SetRenderPlatform->setToolTipsVisible(true);
1218         actionGroup_SetRenderPlatform = new QActionGroup(this);
1219         actionGroup_SetRenderPlatform->setExclusive(true);
1220         {
1221                         int render_type = p_config->render_platform;
1222                         int _major_version = p_config->render_major_version;
1223                         //int _minor_version = p_config->render_minor_version; // ToDo
1224                         for(i = 0; i < MAX_RENDER_PLATFORMS; i++) {
1225                                 tmps = QString::number(i);
1226                                 action_SetRenderPlatform[i] = new Action_Control(this, using_flags);
1227                                 action_SetRenderPlatform[i]->setObjectName(QString::fromUtf8("action_SetRenderPlatform", -1) + tmps);
1228                                 action_SetRenderPlatform[i]->setCheckable(true);
1229                                 action_SetRenderPlatform[i]->binds->setValue1(i);
1230                                 actionGroup_SetRenderPlatform->addAction(action_SetRenderPlatform[i]);
1231                                 menu_SetRenderPlatform->addAction(action_SetRenderPlatform[i]);
1232                                 if(i >= RENDER_PLATFORMS_END) {
1233                                         action_SetRenderPlatform[i]->setVisible(false);
1234                                 } else {
1235                                         if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_ES) {
1236                                                 if(_major_version >= 2) {
1237                                                         if(i == RENDER_PLATFORMS_OPENGL_ES_2) {
1238                                                                 action_SetRenderPlatform[i]->setChecked(true);
1239                                                         }
1240                                                 }
1241                                         } else if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_MAIN) {
1242                                                 if(_major_version >= 3) {
1243                                                         if(i == RENDER_PLATFORMS_OPENGL3_MAIN) {
1244                                                                 action_SetRenderPlatform[i]->setChecked(true);
1245                                                         }
1246                                                 } else if(i == RENDER_PLATFORMS_OPENGL2_MAIN) {
1247                                                         action_SetRenderPlatform[i]->setChecked(true);
1248                                                 }
1249                                         } else if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_CORE) {
1250                                                 if(i == RENDER_PLATFORMS_OPENGL_CORE) {
1251                                                         action_SetRenderPlatform[i]->setChecked(true);
1252                                                 }
1253                                         }
1254                                 }
1255                                 connect(action_SetRenderPlatform[i], SIGNAL(triggered()),
1256                                                 action_SetRenderPlatform[i], SLOT(do_select_render_platform(void)));
1257                                 connect(action_SetRenderPlatform[i], SIGNAL(sig_select_render_platform(int)),
1258                                                 this, SLOT(do_select_render_platform(int)));
1259                         }
1260         }
1261         action_SetupKeyboard = new Action_Control(this, using_flags);
1262
1263         action_SetupMovie = new Action_Control(this, using_flags);
1264
1265 }
1266 #if defined(Q_OS_LINUX)
1267 //#undef _GNU_SOURCE
1268 #endif
1269
1270 #include "display_log.h"
1271
1272 void Ui_MainWindowBase::rise_log_viewer(void)
1273 {
1274         Dlg_LogViewer *dlg = new Dlg_LogViewer(using_flags, csp_logger, NULL);
1275         dlg->show();
1276 }
1277
1278 void Ui_MainWindowBase::rise_joystick_dialog(void)
1279 {
1280         if(graphicsView != NULL) {
1281                 QStringList *lst = graphicsView->getVKNames();
1282                 CSP_DropDownJoysticks *dlg = new CSP_DropDownJoysticks(NULL, lst, using_flags);
1283                 dlg->setWindowTitle(QApplication::translate("CSP_DropDownJoysticks", "Configure Joysticks", 0));
1284                 dlg->show();
1285         }
1286 }
1287
1288 void Ui_MainWindowBase::rise_joykey_dialog(void)
1289 {
1290         if(graphicsView != NULL) {
1291                 QStringList *lst = graphicsView->getVKNames();
1292                 CSP_DropDownJoykey *dlg = new CSP_DropDownJoykey(NULL, lst, using_flags);
1293                 dlg->setWindowTitle(QApplication::translate("CSP_DropDownJoysticks", "Configure Joystick to KEYBOARD", 0));
1294                 dlg->show();
1295         }
1296 }
1297
1298 QString Ui_MainWindowBase::get_system_version()
1299 {
1300         return QString::fromUtf8("Dummy");
1301 }
1302
1303 QString Ui_MainWindowBase::get_build_date()
1304 {
1305         return QString::fromUtf8("Dummy");
1306 }
1307
1308
1309 void Ui_MainWindowBase::rise_movie_dialog(void)
1310 {
1311
1312 }
1313
1314 void Ui_MainWindowBase::rise_keyboard_dialog(void)
1315 {
1316         if(graphicsView != NULL) {
1317                 CSP_KeySetDialog *dlg = new CSP_KeySetDialog(NULL, graphicsView);
1318                 dlg->setWindowTitle(QApplication::translate("KeySetDialog", "Configure Keyboard", 0));
1319                 dlg->show();
1320         }
1321 }
1322 // Retranslate
1323 void Ui_MainWindowBase::retranslateUI_Help(void)
1324 {
1325         menuHELP->setTitle(QApplication::translate("MenuHelp", "Help", 0));
1326         actionHelp_AboutQt->setText(QApplication::translate("MenuHelp", "About Qt", 0));
1327         actionHelp_AboutQt->setToolTip(QApplication::translate("MenuHelp", "Display Qt version.", 0));
1328         actionHelp_AboutQt->setIcon(QApplication::style()->standardIcon(QStyle::SP_TitleBarMenuButton));
1329
1330         actionAbout->setText(QApplication::translate("MenuHelp", "About...", 0));
1331         actionAbout->setIcon(QApplication::style()->standardIcon(QStyle::SP_MessageBoxQuestion));
1332         actionAbout->setToolTip(QApplication::translate("MenuHelp", "About this emulator.", 0));
1333
1334         menuHelp_Readme->setTitle(QApplication::translate("MenuHelp", "READMEs", 0));
1335
1336         actionHelp_README->setText(QApplication::translate("MenuHelp", "General Document", 0));
1337         actionHelp_README_QT->setText(QApplication::translate("MenuHelp", "About Qt ports", 0));
1338         actionHelp_README_Artane->setText(QApplication::translate("MenuHelp", "About Qt ports (Japanese).", 0));
1339         actionHelp_README_Umaiboux->setText(QApplication::translate("MenuHelp", "By Mr. Umaiboux.", 0));
1340         actionHelp_README_MR_TANAM->setText(QApplication::translate("MenuHelp", "By Mr. tanam", 0));
1341         actionHelp_README_FM7->setText(QApplication::translate("MenuHelp", "About eFM-7/8/77/AV.", 0));
1342         actionHelp_README_FM7_JP->setText(QApplication::translate("MenuHelp", "About eFM-7/8/77/AV (Japanese).", 0));
1343         actionHelp_README_FAQ->setText(QApplication::translate("MenuHelp", "FAQs(English)", 0));
1344         actionHelp_README_FAQ_JP->setText(QApplication::translate("MenuHelp", "FAQs(Japanese)", 0));
1345         actionHelp_README_BIOS->setText(QApplication::translate("MenuHelp", "BIOS and Key assigns", 0));
1346
1347         menuHelp_Histories->setTitle(QApplication::translate("MenuHelp", "Histories", 0));
1348         actionHelp_History->setText(QApplication::translate("MenuHelp", "General History", 0));
1349         actionHelp_History_Relnote->setText(QApplication::translate("MenuHelp", "Release Note", 0));
1350         actionHelp_History_ChangeLog->setText(QApplication::translate("MenuHelp", "Change Log", 0));
1351         actionHelp_History_MR_TANAM->setText(QApplication::translate("MenuHelp", "History by Tanam", 0));
1352
1353         actionHelp_License->setText(QApplication::translate("MenuHelp", "Show License", 0));
1354         actionHelp_License->setToolTip(QApplication::translate("MenuHelp", "Show general license (GPLv2).", 0));
1355         actionHelp_License_JP->setText(QApplication::translate("MenuHelp", "Show License (Japanese)", 0));
1356         actionHelp_License_JP->setToolTip(QApplication::translate("MenuHelp", "Show general license (GPLv2).\nTranslated to Japanese.", 0));
1357         ui_retranslate_completed = true;
1358 }
1359
1360 // You can Override this function: Re-define on foo/MainWindow.cpp.
1361 // This code is example: by X1(TurboZ).
1362 void Ui_MainWindowBase::retranslateMachineMenu(void)
1363 {
1364         int i;
1365         QString tmps;
1366         QString tmps2;
1367         menuMachine->setTitle(QApplication::translate("MenuMachine", "Machine", 0));
1368         if(using_flags->get_use_device_type() > 0) {
1369                 menuDeviceType->setTitle(QApplication::translate("MenuMachine", "Device Type", 0));
1370                 for(i = 0; i < using_flags->get_use_device_type(); i++) {
1371                         tmps2.setNum(i + 1);
1372                         tmps = QString::fromUtf8("Machine Device ") + tmps2;
1373                         actionDeviceType[i]->setText(tmps);
1374                 }
1375         }
1376         if(using_flags->get_use_sound_device_type() > 0) {
1377                 menuSoundDevice->setTitle(QApplication::translate("MenuMachine", "Sound Cards", 0));
1378                 for(i = 0; i < using_flags->get_use_sound_device_type(); i++) {
1379                         tmps2.setNum(i + 1);
1380                         tmps = QString::fromUtf8("Sound Device ") + tmps2;
1381                         actionSoundDevice[i]->setText(tmps);
1382                 }
1383         }
1384         if(using_flags->get_use_drive_type() > 0) {
1385                 menuDriveType->setTitle(QApplication::translate("MenuMachine", "Drive Type", 0));
1386                 for(i = 0; i < using_flags->get_use_drive_type(); i++) {
1387                         tmps2.setNum(i + 1);
1388                         tmps = QString::fromUtf8("Drive Type ") + tmps2;
1389                         actionDriveType[i]->setText(tmps);
1390                 }
1391         }
1392         if(using_flags->is_use_printer()) {
1393                 menuPrintDevice->setTitle(QApplication::translate("MenuMachine", "Printer (Need RESET)", 0));
1394                 i = 1;
1395                 actionPrintDevice[0]->setText(QApplication::translate("MenuMachine", "Dump to File", 0));
1396                 actionPrintDevice[0]->setToolTip(QApplication::translate("MenuMachine", "Dump printer output to file.\nMaybe output only ascii text.", 0));
1397                 if(using_flags->get_use_printer_type() > 0) {
1398                         for(i = 1; i < (using_flags->get_use_printer_type() - 1); i++) {
1399                                 tmps2.setNum(i + 1);
1400                                 tmps = QApplication::translate("MenuMachine", "Printer", 0) + tmps2;
1401                                 actionPrintDevice[i]->setText(tmps);
1402                                 actionPrintDevice[i]->setToolTip(tmps);
1403                         }
1404                 }
1405                 actionPrintDevice[i]->setText(QApplication::translate("MenuMachine", "Not Connect", 0));
1406                 actionPrintDevice[i]->setToolTip(QApplication::translate("MenuMachine", "None devices connect to printer port.", 0));
1407         }
1408         if(using_flags->get_use_monitor_type() > 0) {
1409                 menuMonitorType->setTitle(QApplication::translate("MenuMachine", "Monitor Type", 0));
1410                 menuMonitorType->setToolTipsVisible(true);
1411                 for(int ii = 0; ii < using_flags->get_use_monitor_type(); ii++) {
1412                         tmps = QString::fromUtf8("Monitor %1").arg(ii + 1);
1413                         actionMonitorType[ii]->setText(tmps);
1414                 }
1415         }
1416 }
1417 void Ui_MainWindowBase::retranslateUi(void)
1418 {
1419         retranslateControlMenu("Reset",  true);
1420         if(!using_flags->is_without_sound()) {
1421                 retranslateSoundMenu();
1422         }
1423         retranslateScreenMenu();
1424         retranslateMachineMenu();
1425         retranslateEmulatorMenu();
1426         retranslateUI_Help();
1427         if(using_flags->is_use_binary_file()) {
1428                 int basedrv = using_flags->get_base_binary_num();
1429                 for(int i = 0; i < using_flags->get_max_binary(); i++) {
1430                         retranslateBinaryMenu(i, basedrv);
1431                 }
1432         }
1433         if(using_flags->is_use_bubble()) {
1434                 int basedrv = using_flags->get_base_bubble_num();
1435                 for(int i = 0; i < using_flags->get_max_bubble(); i++) {
1436                         retranslateBubbleMenu(i, basedrv);
1437                 }
1438         }
1439         if(using_flags->is_use_cart()) {
1440                 int basedrv = using_flags->get_base_cart_num();
1441                 for(int i = 0; i < using_flags->get_max_cart(); i++) {
1442                         retranslateCartMenu(i, basedrv);
1443                 }
1444         }
1445         if(using_flags->is_use_compact_disc()) {
1446                 retranslateCDROMMenu();
1447         }
1448         if(using_flags->is_use_tape()) {
1449                 int basedrv = using_flags->get_base_tape_num();
1450                 for(int i = 0; i < using_flags->get_max_tape(); i++) {
1451                         retranslateCMTMenu(i);
1452                 }
1453         }
1454         if(using_flags->is_use_fd()) {
1455                 int basedrv = using_flags->get_base_floppy_disk_num();
1456                 for(int i = 0; i < using_flags->get_max_drive(); i++) {
1457                         retranslateFloppyMenu(i, basedrv + i);
1458                 }
1459         }
1460         if(using_flags->is_use_hdd()) {
1461                 int basedrv = using_flags->get_base_hdd_num();
1462                 for(int i = 0; i < using_flags->get_max_hdd(); i++) {
1463                         retranslateHardDiskMenu(i, basedrv + i);
1464                 }
1465         }
1466         if(using_flags->is_use_laser_disc()) {
1467                 retranslateLaserdiscMenu();
1468         }
1469         if(using_flags->is_use_qd()) {
1470                 int basedrv = using_flags->get_base_quick_disk_num();
1471                 for(int i = 0; i < using_flags->get_max_qd(); i++) {
1472                         retranslateQuickDiskMenu(i, basedrv);
1473                 }
1474         }
1475 } // retranslateUi
1476
1477 void Ui_MainWindowBase::doBeforeCloseMainWindow(void)
1478 {
1479         //emit quit_debugger_thread();
1480         emit quit_emulator_all();
1481 }
1482
1483 void Ui_MainWindowBase::setCoreApplication(QApplication *p)
1484 {
1485         this->CoreApplication = p;
1486         connect(actionExit_Emulator, SIGNAL(triggered()),
1487                         this, SLOT(doBeforeCloseMainWindow())); // OnGuiExit()?
1488         connect(this, SIGNAL(quit_emulator_all()), CoreApplication, SLOT(closeAllWindows()));
1489         connect(actionHelp_AboutQt, SIGNAL(triggered()),
1490                         this->CoreApplication, SLOT(aboutQt()));
1491
1492 }
1493
1494 #include <string>
1495 // Move from common/qt_main.cpp
1496 // menu
1497 DLL_PREFIX std::string cpp_confdir;
1498 extern std::string my_procname;
1499 extern bool now_menuloop;
1500 // timing control
1501
1502 // screen
1503 extern unsigned int desktop_width;
1504 extern unsigned int desktop_height;
1505 //int desktop_bpp;
1506 extern int prev_window_mode;
1507 extern bool now_fullscreen;
1508 extern int window_mode_count;
1509
1510 void Ui_MainWindowBase::set_window(int mode)
1511 {
1512         //      static LONG style = WS_VISIBLE;
1513 }
1514
1515 void Ui_MainWindowBase::do_emu_update_volume_level(int num, int level)
1516 {
1517         emit sig_emu_update_volume_level(num, level);
1518 }
1519
1520 void Ui_MainWindowBase::do_emu_update_volume_balance(int num, int level)
1521 {
1522         emit sig_emu_update_volume_balance(num, level);
1523 }
1524
1525 void Ui_MainWindowBase::do_emu_update_config(void)
1526 {
1527         emit sig_emu_update_config();
1528 }
1529
1530 void Ui_MainWindowBase::doChangeMessage_EmuThread(QString message)
1531 {
1532       emit message_changed(message);
1533 }
1534
1535 void Ui_MainWindowBase::do_set_visible_virtual_media_none()
1536 {
1537         QRect rect;
1538         driveData->setVisible(false);
1539         p_config->virtual_media_position = 0;
1540         set_screen_size(graphicsView->width(), graphicsView->height());
1541
1542         pCentralLayout->setDirection(QBoxLayout::TopToBottom);
1543         rect.setRect(0, 0, graphicsView->width(), graphicsView->height() + 2);
1544
1545         pCentralLayout->removeWidget(driveData);
1546         pCentralWidget->setGeometry(rect);
1547         //pCentralLayout->setGeometry(rect);
1548         pCentralLayout->update();
1549         pCentralWidget->setLayout(pCentralLayout);
1550         MainWindow->setCentralWidget(pCentralWidget);
1551         //emit sig_set_display_osd(true);
1552 }
1553
1554 void Ui_MainWindowBase::do_set_visible_virtual_media_upper()
1555 {
1556         QRect rect;
1557         driveData->setVisible(true);
1558         p_config->virtual_media_position = 1;
1559         set_screen_size(graphicsView->width(), graphicsView->height());
1560         emit sig_set_orientation_osd(1);
1561         pCentralLayout->setDirection(QBoxLayout::TopToBottom);
1562         pCentralLayout->removeWidget(driveData);
1563         pCentralLayout->removeWidget(graphicsView);
1564         pCentralLayout->addWidget(driveData);
1565         pCentralLayout->addWidget(graphicsView);
1566         rect.setRect(0, 0, graphicsView->width(), graphicsView->height() + driveData->height() + 2);
1567         pCentralWidget->setGeometry(rect);
1568         //pCentralLayout->setGeometry(rect);
1569         pCentralLayout->update();
1570         pCentralWidget->setLayout(pCentralLayout);
1571         MainWindow->setCentralWidget(pCentralWidget);
1572         //emit sig_set_display_osd(false);
1573 }
1574
1575 void Ui_MainWindowBase::do_set_visible_virtual_media_lower()
1576 {
1577         QRect rect;
1578         driveData->setVisible(true);
1579         p_config->virtual_media_position = 2;
1580         set_screen_size(graphicsView->width(), graphicsView->height());
1581         emit sig_set_orientation_osd(2);
1582         pCentralLayout->setDirection(QBoxLayout::BottomToTop);
1583         pCentralLayout->removeWidget(driveData);
1584         pCentralLayout->removeWidget(graphicsView);
1585         pCentralLayout->addWidget(driveData);
1586         pCentralLayout->addWidget(graphicsView);
1587
1588         rect.setRect(0, 0, graphicsView->width(), graphicsView->height() + driveData->height() + 2);
1589         pCentralWidget->setGeometry(rect);
1590         pCentralLayout->update();
1591         pCentralWidget->setLayout(pCentralLayout);
1592         MainWindow->setCentralWidget(pCentralWidget);
1593 }
1594
1595 void Ui_MainWindowBase::do_set_visible_virtual_media_left()
1596 {
1597 #if 0
1598         driveData->setVisible(true);
1599         p_config->virtual_media_position = 3;
1600         set_screen_size(graphicsView->width(), graphicsView->height());
1601         emit sig_set_orientation_osd(3);
1602         pCentralLayout->removeWidget(driveData);
1603         pCentralLayout->addWidget(driveData, 1, 0);
1604         //emit sig_set_display_osd(false);
1605 #endif
1606 }
1607
1608 void Ui_MainWindowBase::do_set_visible_virtual_media_right()
1609 {
1610 #if 0
1611         driveData->setVisible(true);
1612         p_config->virtual_media_position = 4;
1613         set_screen_size(graphicsView->width(), graphicsView->height());
1614         emit sig_set_orientation_osd(4);
1615         pCentralLayout->removeWidget(driveData);
1616         pCentralLayout->addWidget(driveData, 1, 2);
1617         //emit sig_set_display_osd(false);
1618 #endif
1619 }
1620
1621 void Ui_MainWindowBase::StopEmuThread(void)
1622 {
1623         emit quit_emu_thread();
1624 }
1625
1626 void Ui_MainWindowBase::delete_emu_thread(void)
1627 {
1628         //do_release_emu_resources();
1629         emit sig_quit_all();
1630 }
1631 // Utility
1632 #include <QTextCodec>
1633 #include <QString>
1634 #include <QByteArray>
1635
1636 void Convert_CP932_to_UTF8(char *dst, char *src, int n_limit, int i_limit)
1637 {
1638         QTextCodec *srcCodec = QTextCodec::codecForName( "SJIS" );
1639         QTextCodec *dstCodec = QTextCodec::codecForName( "UTF-8" );
1640         QString dst_b;
1641         QByteArray dst_s;
1642         if(src == NULL) {
1643                 if(dst != NULL) dst[0] = '\0';
1644                 return;
1645         }
1646         if(dst == NULL) return;
1647         dst_b = srcCodec->toUnicode(src, strlen(src));
1648         dst_s = dstCodec->fromUnicode(dst_b);
1649         if(n_limit > 0) {
1650                 memset(dst, 0x00, n_limit);
1651                 strncpy(dst, dst_s.constData(), n_limit - 1);
1652         }
1653 }
1654
1655 void Ui_MainWindowBase::set_window_title()
1656 {
1657         QString tmps;
1658         tmps = QString::fromUtf8("emu");
1659         tmps = tmps + using_flags->get_config_name();
1660         tmps = tmps + QString::fromUtf8(" (");
1661         tmps = tmps + using_flags->get_device_name();
1662         tmps = tmps + QString::fromUtf8(")");
1663         MainWindow->setWindowTitle(tmps);
1664 }
1665
1666 void Ui_MainWindowBase::do_set_window_title(QString s)
1667 {
1668         QString tmps;
1669         tmps = QString::fromUtf8("emu");
1670         tmps = tmps + using_flags->get_config_name();
1671         tmps = tmps + QString::fromUtf8(" (");
1672         if(!s.isEmpty()) {
1673                 tmps = tmps + s;
1674         }
1675         tmps = tmps + QString::fromUtf8(")");
1676         MainWindow->setWindowTitle(tmps);
1677
1678 }
1679
1680 void Ui_MainWindowBase::do_set_mouse_enable(bool flag)
1681 {
1682 }
1683
1684 void Ui_MainWindowBase::do_select_fixed_cpu(int num)
1685 {
1686         emit sig_emu_thread_to_fixed_cpu(num);
1687 }
1688
1689 void Ui_MainWindowBase::do_toggle_mouse(void)
1690 {
1691 }
1692
1693 void Ui_MainWindowBase::LaunchEmuThread(void)
1694 {
1695 }
1696
1697 void Ui_MainWindowBase::LaunchJoyThread(void)
1698 {
1699 }
1700
1701 void Ui_MainWindowBase::StopJoyThread(void)
1702 {
1703 }
1704
1705 void Ui_MainWindowBase::delete_joy_thread(void)
1706 {
1707 }
1708
1709 void Ui_MainWindowBase::on_actionExit_triggered()
1710 {
1711         OnMainWindowClosed();
1712 }
1713
1714 void Ui_MainWindowBase::OnWindowMove(void)
1715 {
1716 }
1717
1718
1719 void Ui_MainWindowBase::OnWindowRedraw(void)
1720 {
1721 }
1722
1723 bool Ui_MainWindowBase::GetPowerState(void)
1724 {
1725         return true;
1726 }
1727
1728 void Ui_MainWindowBase::OnMainWindowClosed(void)
1729 {
1730 }
1731
1732
1733 void Ui_MainWindowBase::do_release_emu_resources(void)
1734 {
1735 }
1736
1737 void Ui_MainWindowBase::OnOpenDebugger(int no)
1738 {
1739 }
1740
1741 void Ui_MainWindowBase::OnCloseDebugger(void )
1742 {
1743 }
1744
1745 /*
1746  * This is main for Qt.
1747  */
1748 DLL_PREFIX CSP_Logger *csp_logger;
1749