message("* qt/osd")
-SET(THIS_LIB_VERSION 2.11.2)
+SET(THIS_LIB_VERSION 2.11.3)
set(s_qt_osd_headers
osd_base.h
message("* qt/avio")
-SET(THIS_LIB_VERSION 2.7.5)
+SET(THIS_LIB_VERSION 2.7.6)
set(s_qt_avio_headers
movie_saver.h
movie_loader.h
//do_add_option(QString::fromUtf8("c:v"), QString::fromUtf8("theora"));
do_add_option(QString::fromUtf8("c:a"), QString::fromUtf8("vorbis"));
- video_encode_threads = p_config->video_threads;
- video_geometry = QSize(p_config->video_width, p_config->video_height);
- audio_bit_rate = p_config->audio_bitrate * 1000;
+ video_encode_threads = config.video_threads;
+ video_geometry = QSize(config.video_width, config.video_height);
+ audio_bit_rate = config.audio_bitrate * 1000;
}
return false;
fmt = oc->oformat;
- switch(p_config->video_codec_type) {
+ switch(config.video_codec_type) {
case VIDEO_CODEC_MPEG4:
fmt->video_codec = AV_CODEC_ID_MPEG4;
break;
fmt->video_codec = AV_CODEC_ID_H264;
break;
}
- switch(p_config->audio_codec_type) {
+ switch(config.audio_codec_type) {
case AUDIO_CODEC_MP3:
fmt->audio_codec = AV_CODEC_ID_MP3;
break;
#if defined(USE_LIBAV)
AVCodecContext *c = (AVCodecContext *)_codec_context;
- c->qmin = p_config->video_h264_minq;
- c->qmax = p_config->video_h264_maxq;
- c->bit_rate = p_config->video_h264_bitrate * 1000;
- c->max_b_frames = p_config->video_h264_bframes;
+ c->qmin = config.video_h264_minq;
+ c->qmax = config.video_h264_maxq;
+ c->bit_rate = config.video_h264_bitrate * 1000;
+ c->max_b_frames = config.video_h264_bframes;
c->b_quant_offset = 2;
c->temporal_cplx_masking = 0.1;
c->spatial_cplx_masking = 0.15;
c->refs = 5;
c->chromaoffset = 2;
c->max_qdiff = 6;
- c->b_frame_strategy = p_config->video_h264_b_adapt;
- c->me_subpel_quality = p_config->video_h264_subme;
+ c->b_frame_strategy = config.video_h264_b_adapt;
+ c->me_subpel_quality = config.video_h264_subme;
c->i_quant_offset = 1.2;
c->i_quant_factor = 1.5;
c->trellis = 2;
{
#if defined(USE_LIBAV)
AVCodecContext *c = (AVCodecContext *)_codec;
- c->qmin = p_config->video_mpeg4_minq;
- c->qmax = p_config->video_mpeg4_maxq;
- c->max_b_frames = p_config->video_mpeg4_bframes;
- c->bit_rate = p_config->video_mpeg4_bitrate * 1000;
+ c->qmin = config.video_mpeg4_minq;
+ c->qmax = config.video_mpeg4_maxq;
+ c->max_b_frames = config.video_mpeg4_bframes;
+ c->bit_rate = config.video_mpeg4_bitrate * 1000;
c->b_quant_offset = 2;
c->temporal_cplx_masking = 0.1;
c->spatial_cplx_masking = 0.15;
//
QString ctext;
bool req_draw = true;
- bool vert_line_bak = using_flags->get_config_ptr()->opengl_scanline_vert;
- bool horiz_line_bak = using_flags->get_config_ptr()->opengl_scanline_horiz;
- bool gl_crt_filter_bak = using_flags->get_config_ptr()->use_opengl_filters;
- int opengl_filter_num_bak = using_flags->get_config_ptr()->opengl_filter_num;
+ bool vert_line_bak = config.opengl_scanline_vert;
+ bool horiz_line_bak = config.opengl_scanline_horiz;
+ bool gl_crt_filter_bak = config.use_opengl_filters;
+ int opengl_filter_num_bak = config.opengl_filter_num;
//uint32_t key_mod_old = 0xffffffff;
int no_draw_count = 0;
bool prevRecordReq = false;
double nr_fps = -1.0;
int _queue_begin;
- bool multithread_draw = using_flags->get_config_ptr()->use_separate_thread_draw;
+ bool multithread_draw = config.use_separate_thread_draw;
doing_debug_command = false;
ctext.clear();
}
#endif
#if defined(USE_MINIMUM_RENDERING)
- if((vert_line_bak != p_config->opengl_scanline_vert) ||
- (horiz_line_bak != p_config->opengl_scanline_horiz) ||
- (gl_crt_filter_bak != p_config->use_opengl_filters) ||
- (opengl_filter_num_bak != p_config->opengl_filter_num)) req_draw = true;
- vert_line_bak = p_config->opengl_scanline_vert;
- horiz_line_bak = p_config->opengl_scanline_horiz;
- gl_crt_filter_bak = p_config->use_opengl_filters;
- opengl_filter_num_bak = p_config->opengl_filter_num;
+ if((vert_line_bak != config.opengl_scanline_vert) ||
+ (horiz_line_bak != config.opengl_scanline_horiz) ||
+ (gl_crt_filter_bak != config.use_opengl_filters) ||
+ (opengl_filter_num_bak != config.opengl_filter_num)) req_draw = true;
+ vert_line_bak = config.opengl_scanline_vert;
+ horiz_line_bak = config.opengl_scanline_horiz;
+ gl_crt_filter_bak = config.use_opengl_filters;
+ opengl_filter_num_bak = config.opengl_filter_num;
#endif
if(bStartRecordSoundReq != false) {
p_emu->start_record_sound();
#if defined(USE_SOUND_VOLUME)
for(int ii = 0; ii < USE_SOUND_VOLUME; ii++) {
if(bUpdateVolumeReq[ii]) {
- p_emu->set_sound_device_volume(ii, p_config->sound_volume_l[ii], p_config->sound_volume_r[ii]);
+ p_emu->set_sound_device_volume(ii, config.sound_volume_l[ii], config.sound_volume_r[ii]);
bUpdateVolumeReq[ii] = false;
}
}
p_emu->key_up(sp.code, true); // need decicion of extend.
break;
case KEY_QUEUE_DOWN:
- if(p_config->romaji_to_kana) {
+ if(config.romaji_to_kana) {
p_emu->get_osd()->key_modifiers(sp.mod);
p_emu->key_char(sp.code);
} else {
#if defined(USE_STATE)
use_state = true;
#endif
- p_config = cfg;
+ p_config = &config;
}
USING_FLAGS_EXT::~USING_FLAGS_EXT()
#include "common.h"
#include "fileio.h"
+#include "config.h"
#include "emu.h"
#include "menuclasses.h"
#include "mainwidget.h"
EMU* emu;
QApplication *GuiMain = NULL;
+extern config_t config;
// Start to define MainWindow.
class META_MainWindow *rMainWindow;
connect(hDrawEmu, SIGNAL(message_changed(QString)), this, SLOT(message_status_bar(QString)));
connect(actionCapture_Screen, SIGNAL(triggered()), glv, SLOT(do_save_frame_screen()));
- /*if(using_flags->get_config_ptr()->use_separate_thread_draw) {
+ /*if(config.use_separate_thread_draw) {
connect(hRunEmu, SIGNAL(sig_draw_thread(bool)), hDrawEmu, SLOT(doDraw(bool)), Qt::QueuedConnection);
connect(hRunEmu, SIGNAL(sig_set_draw_fps(double)), hDrawEmu, SLOT(do_set_frames_per_second(double)), Qt::QueuedConnection);
connect(hRunEmu, SIGNAL(sig_draw_one_turn(bool)), hDrawEmu, SLOT(do_draw_one_turn(bool)), Qt::QueuedConnection);
objNameStr = QString("EmuDrawThread");
hDrawEmu->setObjectName(objNameStr);
- if(using_flags->get_config_ptr()->use_separate_thread_draw) hDrawEmu->start();
+ if(config.use_separate_thread_draw) hDrawEmu->start();
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "DrawThread : Launch done.");
- hSaveMovieThread = new MOVIE_SAVER(640, 400, 30, emu->get_osd(), using_flags->get_config_ptr());
+ hSaveMovieThread = new MOVIE_SAVER(640, 400, 30, emu->get_osd(), &config);
connect(actionStart_Record_Movie->binds, SIGNAL(sig_start_record_movie(int)), hRunEmu, SLOT(do_start_record_video(int)));
connect(this, SIGNAL(sig_start_saving_movie()),
hRunEmu->start();
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "EmuThread : Launch done.");
- this->set_screen_aspect(using_flags->get_config_ptr()->window_stretch_type);
+ this->set_screen_aspect(config.window_stretch_type);
emit sig_movie_set_width(SCREEN_WIDTH);
emit sig_movie_set_height(SCREEN_HEIGHT);
}
void Ui_MainWindow::LaunchJoyThread(void)
{
#if defined(USE_JOYSTICK)
- hRunJoy = new JoyThreadClass(emu, emu->get_osd(), using_flags, using_flags->get_config_ptr(), csp_logger);
+ hRunJoy = new JoyThreadClass(emu, emu->get_osd(), using_flags, &config, csp_logger);
connect(this, SIGNAL(quit_joy_thread()), hRunJoy, SLOT(doExit()));
hRunJoy->setObjectName("JoyThread");
hRunJoy->start();
/*
* Into Qt's Loop.
*/
- USING_FLAGS_EXT *using_flags = new USING_FLAGS_EXT(&config);
- // initialize emulation core
//SetupTranslators();
QTranslator local_translator;
}
}
+ USING_FLAGS_EXT *using_flags = new USING_FLAGS_EXT(&config);
+ // initialize emulation core
rMainWindow = new META_MainWindow(using_flags, csp_logger);
rMainWindow->connect(rMainWindow, SIGNAL(sig_quit_all(void)), rMainWindow, SLOT(deleteLater(void)));
rMainWindow->setCoreApplication(GuiMain);
{
int i;
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
- menu_bubbles[drv]->do_set_initialize_directory(p_config->initial_bubble_casette_dir);
+ menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
if(GetBubbleCasetteIsProtected(drv)) {
menu_bubbles[drv]->do_write_protect_media();
} else {
char path_shadow[PATH_MAX];
int i;
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(p_config->recent_bubble_casette_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_bubble_casette_path[drv], listBubbles[drv]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ s_path = QString::fromLocal8Bit(config.recent_bubble_casette_path[drv][num]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_bubble_casette_path[drv], listBubbles[drv]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
- strcpy(p_config->initial_bubble_casette_dir, get_parent_dir((const _TCHAR *)path_shadow));
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strcpy(config.initial_bubble_casette_dir, get_parent_dir((const _TCHAR *)path_shadow));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
{
emit sig_close_bubble(drv);
emit sig_open_bubble(drv, s_path, 0);
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
- menu_bubbles[drv]->do_set_initialize_directory(p_config->initial_bubble_casette_dir);
+ menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
if(check_file_extension(path_shadow, ".b77")) {
UPDATE_B77_LIST(drv, listB77[drv]);
menu_bubbles[drv]->do_update_inner_media_bubble(listB77[drv], 0);
if(fname.length() <= 0) return;
drv = drv & 7;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_bubble_casette_path[drv], listBubbles[drv]);
- strcpy(p_config->initial_bubble_casette_dir, get_parent_dir((const _TCHAR *)path_shadow));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_bubble_casette_path[drv], listBubbles[drv]);
+ strcpy(config.initial_bubble_casette_dir, get_parent_dir((const _TCHAR *)path_shadow));
// Update List
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
{
emit sig_close_bubble(drv);
emit sig_open_bubble(drv, fname, 0);
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
- menu_bubbles[drv]->do_set_initialize_directory(p_config->initial_bubble_casette_dir);
+ menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
if(check_file_extension(path_shadow, ".b77")) {
UPDATE_B77_LIST(drv, listB77[drv]);
menu_bubbles[drv]->do_update_inner_media_bubble(listB77[drv], 0);
{
if(emu == NULL) return;
menu_fds[drv]->do_update_histories(listFDs[drv]);
- menu_fds[drv]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
+ menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
if(emu->is_floppy_disk_protected(drv)) {
menu_fds[drv]->do_write_protect_media();
} else {
QString s_path;
char path_shadow[PATH_MAX];
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(p_config->recent_floppy_disk_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_floppy_disk_path[drv], listFDs[drv]);
- //strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ s_path = QString::fromLocal8Bit(config.recent_floppy_disk_path[drv][num]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_floppy_disk_path[drv], listFDs[drv]);
- strncpy(p_config->initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow), _MAX_PATH);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(config.initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow), _MAX_PATH - 1);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
if(emu) {
emit sig_close_disk(drv);
emit sig_open_disk(drv, s_path, 0);
menu_fds[drv]->do_update_histories(listFDs[drv]);
- menu_fds[drv]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
+ menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
UPDATE_D88_LIST(drv, listD88[drv]);
menu_fds[drv]->do_update_inner_media(listD88[drv], 0);
menu_fds[drv]->do_clear_inner_media();
}
if(using_flags->get_max_drive() >= 2) {
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
if(((drv & 1) == 0) && (drv + 1 < using_flags->get_max_drive()) && (1 < emu->d88_file[drv].bank_num)) {
int drv2 = drv + 1;
emit sig_close_disk(drv2);
emit sig_open_disk(drv2, s_path, 1);
menu_fds[drv2]->do_update_histories(listFDs[drv2]);
- menu_fds[drv2]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
+ menu_fds[drv2]->do_set_initialize_directory(config.initial_floppy_disk_dir);
UPDATE_D88_LIST(drv2, listD88[drv2]);
menu_fds[drv2]->do_update_inner_media(listD88[drv2], 1);
}
if(fname.length() <= 0) return;
drv = drv & 7;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_floppy_disk_path[drv], listFDs[drv]);
- strcpy(p_config->initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_floppy_disk_path[drv], listFDs[drv]);
+ strcpy(config.initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow));
// Update List
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
if(emu) {
emit sig_close_disk(drv);
//emu->LockVM();
emit sig_open_disk(drv, fname, 0);
menu_fds[drv]->do_update_histories(listFDs[drv]);
- menu_fds[drv]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
+ menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
UPDATE_D88_LIST(drv, listD88[drv]);
menu_fds[drv]->do_update_inner_media(listD88[drv], 0);
int drv2 = drv + 1;
emit sig_close_disk(drv2);
//emu->LockVM();
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_open_disk(drv2, fname, 1);
menu_fds[drv2]->do_update_histories(listFDs[drv2]);
- menu_fds[drv2]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
+ menu_fds[drv2]->do_set_initialize_directory(config.initial_floppy_disk_dir);
UPDATE_D88_LIST(drv2, listD88[drv2]);
menu_fds[drv2]->do_update_inner_media(listD88[drv2], 1);
}
{
if(emu == NULL) return;
menu_hdds[drv]->do_update_histories(listHDDs[drv]);
- menu_hdds[drv]->do_set_initialize_directory(p_config->initial_hard_disk_dir);
+ menu_hdds[drv]->do_set_initialize_directory(config.initial_hard_disk_dir);
}
int Ui_MainWindow::set_recent_hard_disk(int drv, int num)
QString s_path;
char path_shadow[PATH_MAX];
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(p_config->recent_hard_disk_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_hard_disk_path[drv], listHDDs[drv]);
+ s_path = QString::fromLocal8Bit(config.recent_hard_disk_path[drv][num]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_hard_disk_path[drv], listHDDs[drv]);
- strncpy(p_config->initial_hard_disk_dir, get_parent_dir((const _TCHAR *)path_shadow), _MAX_PATH);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(config.initial_hard_disk_dir, get_parent_dir((const _TCHAR *)path_shadow), _MAX_PATH - 1);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
if(emu) {
emit sig_close_hard_disk(drv);
emit sig_open_hard_disk(drv, s_path);
menu_hdds[drv]->do_update_histories(listHDDs[drv]);
- menu_hdds[drv]->do_set_initialize_directory(p_config->initial_hard_disk_dir);
+ menu_hdds[drv]->do_set_initialize_directory(config.initial_hard_disk_dir);
menu_hdds[drv]->do_clear_inner_media();
}
return 0;
if(fname.length() <= 0) return;
drv = drv & 7;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, p_config->recent_hard_disk_path[drv], listHDDs[drv]);
- strcpy(p_config->initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_hard_disk_path[drv], listHDDs[drv]);
+ strcpy(config.initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow));
// Update List
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
if(emu) {
emit sig_close_hard_disk(drv);
//emu->LockVM();
emit sig_open_hard_disk(drv, fname);
menu_hdds[drv]->do_update_histories(listHDDs[drv]);
- menu_hdds[drv]->do_set_initialize_directory(p_config->initial_hard_disk_dir);
+ menu_hdds[drv]->do_set_initialize_directory(config.initial_hard_disk_dir);
menu_hdds[drv]->do_clear_inner_media();
}
}
dest_x = (dest_x < 0) ? 0 : dest_x;
dest_y = (dest_y < 0) ? 0 : dest_y;
- p_config->window_mode = prev_window_mode = mode;
+ config.window_mode = prev_window_mode = mode;
// set screen size to emu class
emit sig_emu_set_display_size(width, height, width, height);
height = (int)(nd * (double)using_flags->get_screen_height());
if(using_flags->is_use_screen_rotate()) {
- if(p_config->rotate_type) {
+ if(config.rotate_type) {
int tmp_w = width;
width = height;
height = tmp_w;
}
}
- p_config->window_mode = mode;
+ config.window_mode = mode;
emit sig_emu_set_display_size(using_flags->get_screen_width(), using_flags->get_screen_height(), width, height);
emit sig_resize_osd(width);
this->resize_statusbar(width, height);
)
#include(cotire)
-SET(THIS_LIB_VERSION 2.9.1)
+SET(THIS_LIB_VERSION 2.9.2)
if(WIN32)
include (GenerateExportHeader)
message("* qt/gui")
-set(THIS_LIB_VERSION 2.12.2)
+set(THIS_LIB_VERSION 2.12.3)
#include(cotire)
#include(PrecompiledHeader)
if(l > 0) {
memset(tmpbuf, 0x00, 8192);
if(l >= 8192) l = 8192 -1;
- strncpy(tmpbuf, ns.constData(), l);
+ if(l != 0) strncpy(tmpbuf, ns.constData(), l);
}
if(((int64_t)l + total_size) < buf_size) {
- strncpy(pp, tmpbuf, l);
+ if(l != 0)strncpy(pp, tmpbuf, l);
pp += l;
total_size += (int64_t)l;
} else {
len = get_console_list(strbuf, 0x20000, utf8, (char *)domain_name, forget);
if(len > 0x20000) break; // Illegal
if(len <= 0) break;
- if(fio->Fwrite(strbuf, (uint32_t)len, 1) != len) break;
+ if((int64_t)(fio->Fwrite(strbuf, (uint32_t)len, 1)) != len) break;
n_len += len;
} while(len > 0);
fio->Fclose();
connect(this, SIGNAL(sig_push_frames_to_avio(int, int, int)), glv->extfunc, SLOT(paintGL_OffScreen(int, int, int)));
//connect(this, SIGNAL(sig_call_draw_screen()), p_osd, SLOT(draw_screen()));
//connect(this, SIGNAL(sig_call_no_draw_screen()), p_osd, SLOT(no_draw_screen()));
- use_separate_thread_draw = false;
- if(using_flags != NULL) use_separate_thread_draw = using_flags->get_config_ptr()->use_separate_thread_draw;
+ use_separate_thread_draw = config.use_separate_thread_draw;
rec_frame_width = 640;
rec_frame_height = 480;
if((button_num < 0) || (button_num >= 16)) return;
if((jsnum < 0) || (jsnum >= 4)) return;
//printf("Select: %d %d %d\n", jsnum, button_num, assigned_value);
- using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] = assigned_value;
+ config.joy_buttons[jsnum][button_num] = assigned_value;
}
void CSP_DropDownJoysticks::do_set_js_button_idx(int jsnum, int button_num, int assigned_value)
if((button_num < 0) || (button_num >= 16)) return;
if((jsnum < 0) || (jsnum >= 4)) return;
//printf("Select_Idx: %d %d %d\n", jsnum, button_num, assigned_value);
- using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] = assigned_value;
+ config.joy_buttons[jsnum][button_num] = assigned_value;
}
}
if((button_num < 16) && (button_num >= 0)) {
if((jsnum < 4) && (jsnum >= 0)){
- if((using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] < 0) && (using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] > -256)) {
- combo->setCurrentIndex(-using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] + 16);
- } else if((using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] >= 0) && (using_flags->get_config_ptr()->joy_buttons[jsnum][button_num] < 16)) {
- combo->setCurrentIndex(using_flags->get_config_ptr()->joy_buttons[jsnum][button_num]);
+ if((config.joy_buttons[jsnum][button_num] < 0) && (config.joy_buttons[jsnum][button_num] > -256)) {
+ combo->setCurrentIndex(-config.joy_buttons[jsnum][button_num] + 16);
+ } else if((config.joy_buttons[jsnum][button_num] >= 0) && (config.joy_buttons[jsnum][button_num] < 16)) {
+ combo->setCurrentIndex(config.joy_buttons[jsnum][button_num]);
}
}
}
if(using_flags->get_use_sound_volume() > 0) {
for(int i = 0; i < using_flags->get_use_sound_volume(); i++) {
bUpdateVolumeReq[i] = true;
- volume_avg[i] = (using_flags->get_config_ptr()->sound_volume_l[i] +
- using_flags->get_config_ptr()->sound_volume_r[i]) / 2;
- volume_balance[i] = (using_flags->get_config_ptr()->sound_volume_r[i] -
- using_flags->get_config_ptr()->sound_volume_l[i]) / 2;
+ volume_avg[i] = (config.sound_volume_l[i] +
+ config.sound_volume_r[i]) / 2;
+ volume_balance[i] = (config.sound_volume_r[i] -
+ config.sound_volume_l[i]) / 2;
}
}
keyMutex->lock();
volume_balance[num] = balance;
right = level + balance;
left = level - balance;
- using_flags->get_config_ptr()->sound_volume_l[num] = left;
- using_flags->get_config_ptr()->sound_volume_r[num] = right;
+ config.sound_volume_l[num] = left;
+ config.sound_volume_r[num] = right;
}
void EmuThreadClassBase::calc_volume_from_level(int num, int level)
volume_avg[num] = level;
right = level + balance;
left = level - balance;
- using_flags->get_config_ptr()->sound_volume_l[num] = left;
- using_flags->get_config_ptr()->sound_volume_r[num] = right;
+ config.sound_volume_l[num] = left;
+ config.sound_volume_r[num] = right;
}
void EmuThreadClassBase::doExit(void)
fileInfo = QFileInfo(_file);
}
if(fileInfo.isFile()) {
- _TCHAR *path_shadow = fileInfo.absoluteFilePath().toLocal8Bit().constData();
+ const _TCHAR *path_shadow = (const _TCHAR *)(fileInfo.absoluteFilePath().toLocal8Bit().constData());
if(_dom_type == QString::fromUtf8("vFloppyDisk")) {
emit sig_open_fd(_dom_num, fileInfo.absoluteFilePath());
if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
snprintf(buf, 255, _T("%s - %d fps (%d %%)"), get_device_name(), draw_frames, ratio);
}
}
- if(p_config->romaji_to_kana) {
+ if(config.romaji_to_kana) {
message = QString::fromUtf8("[R]");
message = message + QString::fromUtf8(buf);
} else {
s->type = _type;
s->code = (uint32_t)key_fifo->read();
s->mod = (uint32_t)key_fifo->read();
- uint32_t dummy = key_fifo->read();
+ volatile uint32_t dummy = key_fifo->read();
s->repeat = false;
} else {
s->type = 0;
void Ui_MainWindowBase::do_emu_full_speed(bool flag)
{
- using_flags->get_config_ptr()->full_speed = flag;
+ config.full_speed = flag;
}
void Ui_MainWindowBase::OnCpuPower(int mode)
{
- using_flags->get_config_ptr()->cpu_power = mode;
+ config.cpu_power = mode;
emit sig_emu_update_config();
}
void GLDraw_2_0::drawGrids(void)
{
- gl_grid_horiz = using_flags->get_config_ptr()->opengl_scanline_horiz;
- gl_grid_vert = using_flags->get_config_ptr()->opengl_scanline_vert;
+ gl_grid_horiz = config.opengl_scanline_horiz;
+ gl_grid_vert = config.opengl_scanline_vert;
if(gl_grid_horiz && (vert_lines > 0)) {
drawGridsHorizonal();
} // Will fix.
}
if(uVramTextureID == NULL) return;
QVector4D color;
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = config.use_opengl_filters;
if(set_brightness) {
color = QVector4D(fBrightR, fBrightG, fBrightB, 1.0);
} else {
prg->setUniformValue("tex_height", (float)p->height());
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
if(!using_flags->is_use_one_board_computer() && (using_flags->get_max_button() <= 0)) {
drawGrids();
}
- if(using_flags->get_config_ptr()->use_osd_virtual_media) drawOsdIcons();
+ if(config.use_osd_virtual_media) drawOsdIcons();
extfunc_2->glFlush();
}
GL_BGRA, GL_UNSIGNED_BYTE, p->constBits());
extfunc->glBindTexture(GL_TEXTURE_2D, 0);
}
- if(using_flags->is_support_tv_render() && (using_flags->get_config_ptr()->rendering_type == CONFIG_RENDER_TYPE_TV)) {
+ if(using_flags->is_support_tv_render() && (config.rendering_type == CONFIG_RENDER_TYPE_TV)) {
renderToTmpFrameBuffer_nPass(uVramTextureID->textureId(),
screen_texture_width,
screen_texture_height,
}
QVector4D color;
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = config.use_opengl_filters;
if(set_brightness) {
color = QVector4D(fBrightR, fBrightG, fBrightB, 1.0);
} else {
prg->setUniformValue(ii, (float)screen_texture_height);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
prg->setUniformValue(ii, color);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
prg->setUniformValue(ii, GL_FALSE);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
void GLDraw_3_0::drawBitmapTexture(void)
{
QVector4D color = QVector4D(1.0f, 1.0f, 1.0f, 1.0f);
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = config.use_opengl_filters;
if(uBitmapTextureID == NULL) return;
if(using_flags->is_use_one_board_computer()) {
extfunc->glDisable(GL_BLEND);
extfunc->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
extfunc->glDisable(GL_DEPTH_TEST);
//drawOsdLeds();
- if(using_flags->get_config_ptr()->use_osd_virtual_media) drawOsdIcons();
+ if(config.use_osd_virtual_media) drawOsdIcons();
extfunc->glDisable(GL_BLEND);
if(!using_flags->is_use_one_board_computer() && (using_flags->get_max_button() <= 0)) {
drawGrids();
extfunc->glBindTexture(GL_TEXTURE_2D, 0);
}
#if 1
- if(using_flags->is_support_tv_render() && (using_flags->get_config_ptr()->rendering_type == CONFIG_RENDER_TYPE_TV)) {
+ if(using_flags->is_support_tv_render() && (config.rendering_type == CONFIG_RENDER_TYPE_TV)) {
renderToTmpFrameBuffer_nPass(uVramTextureID->textureId(),
screen_texture_width,
screen_texture_height,
}
QVector4D color;
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = config.use_opengl_filters;
if(set_brightness) {
color = QVector4D(fBrightR, fBrightG, fBrightB, 1.0);
} else {
prg->setUniformValue(ii, (float)screen_texture_height);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
prg->setUniformValue(ii, color);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
prg->setUniformValue(ii, GL_FALSE);
}
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
prg->setUniformValue("rotate", GL_TRUE);
} else {
prg->setUniformValue("rotate", GL_FALSE);
void GLDraw_ES_2::drawBitmapTexture(void)
{
QVector4D color = QVector4D(1.0f, 1.0f, 1.0f, 1.0f);
- smoosing = using_flags->get_config_ptr()->use_opengl_filters;
+ smoosing = config.use_opengl_filters;
if(using_flags->is_use_one_board_computer() && (uBitmapTextureID != NULL)) {
//extfunc->glDisable(GL_BLEND);
extfunc->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
extfunc->glDisable(GL_DEPTH_TEST);
//drawOsdLeds();
- if(using_flags->get_config_ptr()->use_osd_virtual_media) drawOsdIcons();
+ if(config.use_osd_virtual_media) drawOsdIcons();
extfunc->glDisable(GL_BLEND);
if(!using_flags->is_use_one_board_computer() && (using_flags->get_max_button() <= 0)) {
drawGrids();
if(controller_table[num] != NULL) {
names[num] = QString::fromUtf8(SDL_GameControllerNameForIndex(num));
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Controller %d : %s : is plugged.", num, names[num].toUtf8().constData());
- strncpy(p_config->assigned_joystick_name[num], names[num].toUtf8().constData(), 255);
+ strncpy(config.assigned_joystick_name[num], names[num].toUtf8().constData(),
+ (sizeof(config.assigned_joystick_name) / sizeof(char)) - 1);
joy_num[num] = num;
}
} else
joy_num[i] = SDL_JoystickInstanceID(joyhandle[i]);
names[i] = QString::fromUtf8(SDL_JoystickNameForIndex(num));
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "JoyThread : Joystick %d : %s : is plugged.", num, names[i].toUtf8().data());
- strncpy(p_config->assigned_joystick_name[num], names[num].toUtf8().constData(), 255);
+ strncpy(config.assigned_joystick_name[num], names[num].toUtf8().constData(),
+ (sizeof(config.assigned_joystick_name) / sizeof(char)) - 1);
break;
}
}
}
}
names[num] = QString::fromUtf8("");
- memset(p_config->assigned_joystick_name[num], 0x00, 255);
+ memset(config.assigned_joystick_name[num], 0x00, 255);
}
void JoyThreadClass::x_axis_changed(int index, int value)
__action[_i]->setEnabled(__enabled); \
__action[_i]->binds->setValue1(_i); \
__menu->addAction(__action[_i]); \
- if(using_flags->get_config_ptr()->__cnf[_i][0]) __action[_i]->setChecked(true); \
+ if(config.__cnf[_i][0]) __action[_i]->setChecked(true); \
connect(__action[_i], __signal1, __action[_i], __slot1); \
connect(__action[_i], __signal2, this, __slot2); \
} \
void Ui_MainWindowBase::set_latency(int num)
{
if((num < 0) || (num >= 8)) return;
- using_flags->get_config_ptr()->sound_latency = num;
+ config.sound_latency = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_freq(int num)
{
if((num < 0) || (num >= 16)) return;
- using_flags->get_config_ptr()->sound_frequency = num;
+ config.sound_frequency = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_sound_device(int num)
{
if((num < 0) || (num >= using_flags->get_use_sound_device_type())) return;
- using_flags->get_config_ptr()->sound_type = num;
+ config.sound_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_monitor_type(int num)
{
if((num < 0) || (num >= using_flags->get_use_monitor_type())) return;
- using_flags->get_config_ptr()->monitor_type = num;
+ config.monitor_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_scan_line(bool flag)
{
- using_flags->get_config_ptr()->scan_line = flag;
+ config.scan_line = flag;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_screen_rotate(bool flag)
{
- using_flags->get_config_ptr()->rotate_type = flag;
- if(using_flags->get_config_ptr()->window_mode >= using_flags->get_screen_mode_num()) using_flags->get_config_ptr()->window_mode = using_flags->get_screen_mode_num() - 1;
- if(using_flags->get_config_ptr()->window_mode < 0) using_flags->get_config_ptr()->window_mode = 0;
- if(actionScreenSize[using_flags->get_config_ptr()->window_mode] != NULL) {
- actionScreenSize[using_flags->get_config_ptr()->window_mode]->binds->set_screen_size();
+ config.rotate_type = flag;
+ if(config.window_mode >= using_flags->get_screen_mode_num()) config.window_mode = using_flags->get_screen_mode_num() - 1;
+ if(config.window_mode < 0) config.window_mode = 0;
+ if(actionScreenSize[config.window_mode] != NULL) {
+ actionScreenSize[config.window_mode]->binds->set_screen_size();
}
}
void Ui_MainWindowBase::set_gl_crt_filter(bool flag)
{
- using_flags->get_config_ptr()->use_opengl_filters = flag;
+ config.use_opengl_filters = flag;
}
void Ui_MainWindowBase::set_cmt_sound(bool flag)
{
- //using_flags->get_config_ptr()->tape_sound = flag;
+ //config.tape_sound = flag;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_mouse_type(int num)
{
if((num >= using_flags->get_use_mouse_type()) && (num < 0)) return;
- using_flags->get_config_ptr()->mouse_type = num;
+ config.mouse_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_device_type(int num)
{
if((num >= using_flags->get_use_device_type()) && (num < 0)) return;
- using_flags->get_config_ptr()->device_type = num;
+ config.device_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_keyboard_type(int num)
{
if((num >= using_flags->get_use_keyboard_type()) && (num < 0)) return;
- using_flags->get_config_ptr()->keyboard_type = num;
+ config.keyboard_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_joystick_type(int num)
{
if((num >= using_flags->get_use_joystick_type()) && (num < 0)) return;
- using_flags->get_config_ptr()->joystick_type = num;
+ config.joystick_type = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::set_drive_type(int num)
{
if((num >= using_flags->get_use_drive_type()) && (num < 0)) return;
- using_flags->get_config_ptr()->drive_type = num;
+ config.drive_type = num;
emit sig_emu_update_config();
}
{
if((w <= 0) || (h <= 0)) return;
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
this->graphicsView->setFixedSize(h, w);
this->resize_statusbar(h, w);
//emit sig_resize_osd(h);
// 2 = ASPECT(SCale Y)
// 3 = ASPECT(Scale X,Y)
- using_flags->get_config_ptr()->window_stretch_type = num;
+ config.window_stretch_type = num;
if(using_flags->get_emu()) {
int w, h, n;
float nd, ww, hh;
float xzoom = using_flags->get_screen_x_zoom();
float yzoom = using_flags->get_screen_y_zoom();
- n = using_flags->get_config_ptr()->window_mode;
+ n = config.window_mode;
if(n < 0) n = 1;
nd = actionScreenSize[n]->binds->getDoubleValue();
ww = (float)using_flags->get_screen_width();
float par_w = (float)using_flags->get_screen_width_aspect() / ww;
float par_h = (float)using_flags->get_screen_height_aspect() / hh;
//double par = par_h / par_w;
- switch(using_flags->get_config_ptr()->window_stretch_type) {
+ switch(config.window_stretch_type) {
case 0: // refer to X and Y.
ww = ww * nd * xzoom;
hh = hh * nd * yzoom;
actionDeviceType[ii]->setCheckable(true);
actionDeviceType[ii]->setVisible(true);
actionDeviceType[ii]->binds->setValue1(ii);
- if(using_flags->get_config_ptr()->device_type == ii) actionDeviceType[ii]->setChecked(true);
+ if(config.device_type == ii) actionDeviceType[ii]->setChecked(true);
menuDeviceType->addAction(actionDeviceType[ii]);
connect(actionDeviceType[ii], SIGNAL(triggered()),
actionDeviceType[ii]->binds, SLOT(do_set_device_type()));
actionJoystickType[ii]->setCheckable(true);
actionJoystickType[ii]->setVisible(true);
actionJoystickType[ii]->binds->setValue1(ii);
- if(using_flags->get_config_ptr()->joystick_type == ii) actionJoystickType[ii]->setChecked(true);
+ if(config.joystick_type == ii) actionJoystickType[ii]->setChecked(true);
menuJoystickType->addAction(actionJoystickType[ii]);
connect(actionJoystickType[ii], SIGNAL(triggered()),
actionJoystickType[ii]->binds, SLOT(do_set_joystick_type()));
actionKeyboardType[ii]->setCheckable(true);
actionKeyboardType[ii]->setVisible(true);
actionKeyboardType[ii]->binds->setValue1(ii);
- if(using_flags->get_config_ptr()->keyboard_type == ii) actionKeyboardType[ii]->setChecked(true);
+ if(config.keyboard_type == ii) actionKeyboardType[ii]->setChecked(true);
menuKeyboardType->addAction(actionKeyboardType[ii]);
connect(actionKeyboardType[ii], SIGNAL(triggered()),
actionKeyboardType[ii]->binds, SLOT(do_set_keyboard_type()));
actionMouseType[ii]->setCheckable(true);
actionMouseType[ii]->setVisible(true);
actionMouseType[ii]->binds->setValue1(ii);
- if(using_flags->get_config_ptr()->mouse_type == ii) actionMouseType[ii]->setChecked(true);
+ if(config.mouse_type == ii) actionMouseType[ii]->setChecked(true);
menuMouseType->addAction(actionMouseType[ii]);
connect(actionMouseType[ii], SIGNAL(triggered()),
actionMouseType[ii]->binds, SLOT(do_set_mouse_type()));
actionDriveType[i]->setCheckable(true);
actionDriveType[i]->setVisible(true);
actionDriveType[i]->binds->setValue1(i);
- if(i == using_flags->get_config_ptr()->drive_type) actionDriveType[i]->setChecked(true); // Need to write configure
+ if(i == config.drive_type) actionDriveType[i]->setChecked(true); // Need to write configure
actionGroup_DriveType->addAction(actionDriveType[i]);
menuDriveType->addAction(actionDriveType[i]);
connect(actionDriveType[i], SIGNAL(triggered()),
actionSoundDevice[i] = new Action_Control(this, using_flags);
actionSoundDevice[i]->setCheckable(true);
actionSoundDevice[i]->binds->setValue1(i);
- if(i == using_flags->get_config_ptr()->sound_type) actionSoundDevice[i]->setChecked(true); // Need to write configure
+ if(i == config.sound_type) actionSoundDevice[i]->setChecked(true); // Need to write configure
tmps = QString::fromUtf8("actionSoundDevice_");
actionSoundDevice[i]->setObjectName(tmps + QString::number(i));
menuSoundDevice->addAction(actionSoundDevice[i]);
actionPrintDevice[i] = new Action_Control(this, using_flags);
actionPrintDevice[i]->setCheckable(true);
actionPrintDevice[i]->binds->setValue1(i);
- if(i == using_flags->get_config_ptr()->printer_type) actionPrintDevice[i]->setChecked(true); // Need to write configure
+ if(i == config.printer_type) actionPrintDevice[i]->setChecked(true); // Need to write configure
tmps = QString::fromUtf8("actionPrintDevice_");
actionPrintDevice[i]->setObjectName(tmps + QString::number(i));
menuPrintDevice->addAction(actionPrintDevice[i]);
} else {
if(p_type >= 8) p_type = 0;
}
- using_flags->get_config_ptr()->printer_type = p_type;
+ config.printer_type = p_type;
emit sig_emu_update_config();
}
QDir dir;
char app[PATH_MAX];
initial_dir = dir.currentPath();
- strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX - 1);
initial_dir = QString::fromLocal8Bit(get_parent_dir(app));
}
dlg.setOption(QFileDialog::ReadOnly, false);
action_recording->setVisible(true);
action_recording->setCheckable(false);
- if(using_flags->get_config_ptr()->wave_shaper == 0) {
+ if(config.wave_shaper == 0) {
action_wave_shaper->setChecked(false);
} else {
action_wave_shaper->setChecked(true);
}
if(using_flags->is_machine_cmt_mz_series()) {
- if(using_flags->get_config_ptr()->direct_load_mzt == 0) {
+ if(config.direct_load_mzt == 0) {
action_direct_load_mzt->setChecked(false);
} else {
action_direct_load_mzt->setChecked(true);
QDir dir;
char app[PATH_MAX];
initial_dir = dir.currentPath();
- strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX - 1);
initial_dir = QString::fromLocal8Bit(get_parent_dir(app));
}
dlg.setOption(QFileDialog::ReadOnly, false);
actionGroup_CpuSpeed->addAction(actionSpeed_x16);
//actionGroup_CpuSpeed->addAction(actionSpeed_FULL);
- switch(using_flags->get_config_ptr()->cpu_power) {
+ switch(config.cpu_power) {
case 0:
actionSpeed_x1->setChecked(true);
break;
actionSpeed_x16->setChecked(true);
break;
default:
- using_flags->get_config_ptr()->cpu_power = 0;
+ config.cpu_power = 0;
actionSpeed_x1->setChecked(true);
break;
}
void Ui_MainWindowBase::do_change_boot_mode(int mode)
{
if((mode < 0) || (mode >= 8)) return;
- using_flags->get_config_ptr()->boot_mode = mode;
+ config.boot_mode = mode;
emit sig_emu_update_config();
}
tmps = QString::fromUtf8("actionBootMode_") + tmps;
actionBootMode[i]->setObjectName(tmps);
actionBootMode[i]->setCheckable(true);
- if(i == using_flags->get_config_ptr()->boot_mode) actionBootMode[i]->setChecked(true);
+ if(i == config.boot_mode) actionBootMode[i]->setChecked(true);
actionBootMode[i]->binds->setValue1(i);
menuBootMode->addAction(actionBootMode[i]);
actionGroup_BootMode->addAction(actionBootMode[i]);
void Ui_MainWindowBase::do_change_cpu_type(int mode)
{
if((mode < 0) || (mode >= 8)) return;
- using_flags->get_config_ptr()->cpu_type = mode;
+ config.cpu_type = mode;
emit sig_emu_update_config();
}
tmps = QString::fromUtf8("actionCpuType_") + tmps;
actionCpuType[i]->setObjectName(tmps);
actionCpuType[i]->setCheckable(true);
- if(i == using_flags->get_config_ptr()->cpu_type) actionCpuType[i]->setChecked(true);
+ if(i == config.cpu_type) actionCpuType[i]->setChecked(true);
actionCpuType[i]->binds->setValue1(i);
menuCpuType->addAction(actionCpuType[i]);
actionGroup_CpuType->addAction(actionCpuType[i]);
_TCHAR tmpbuf[_MAX_PATH];
actionSave_State[i] = new Action_Control(this, using_flags);
- strncpy(tmpbuf, create_local_path(_T("%s.sta%d"), using_flags->get_config_name().toLocal8Bit().constData(), i), _MAX_PATH);
+ strncpy(tmpbuf, create_local_path(_T("%s.sta%d"), using_flags->get_config_name().toLocal8Bit().constData(), i), _MAX_PATH - 1);
tmps = QString::fromUtf8("");
tmpss = QString::fromUtf8("");
void Ui_MainWindowBase::do_set_sound_device(int num)
{
if((num < 0) || (num >= using_flags->get_use_sound_device_type())) return;
- using_flags->get_config_ptr()->sound_type = num;
+ config.sound_type = num;
emit sig_emu_update_config();
}
action_count_immediate->setCheckable(true);
action_count_immediate->binds->setDrive(media_drive);
- p = using_flags->get_config_ptr();
+ p = &config;
if(p != NULL) {
if(p->correct_disk_timing[media_drive]) action_correct_timing->setChecked(true);
if(p->ignore_disk_crc[media_drive]) action_ignore_crc_error->setChecked(true);
machine_has_pcengine = false;
machine_sc3000 = false;
machine_z80tvgame = false;
- p_config = cfg;
+ //p_config = cfg;
}
USING_FLAGS::~USING_FLAGS()
void Ui_MainWindowBase::do_set_window_focus_type(bool flag)
{
- using_flags->get_config_ptr()->focus_with_click = flag;
+ config.focus_with_click = flag;
if(flag) {
graphicsView->setFocusPolicy(Qt::ClickFocus);
graphicsView->setFocus(0);
void Ui_MainWindowBase::do_set_sound_files_fdd(bool f)
{
if(f) {
- using_flags->get_config_ptr()->sound_noise_fdd = 1;
+ config.sound_noise_fdd = 1;
} else {
- using_flags->get_config_ptr()->sound_noise_fdd = 0;
+ config.sound_noise_fdd = 0;
}
}
void Ui_MainWindowBase::do_set_sound_files_relay(bool f)
{
if(f) {
- using_flags->get_config_ptr()->sound_noise_cmt = 1;
+ config.sound_noise_cmt = 1;
} else {
- using_flags->get_config_ptr()->sound_noise_cmt = 0;
+ config.sound_noise_cmt = 0;
}
}
void Ui_MainWindowBase::do_set_conslog(bool f)
{
- using_flags->get_config_ptr()->log_to_console = f;
+ config.log_to_console = f;
csp_logger->set_log_stdout(-1, f);
}
void Ui_MainWindowBase::do_set_syslog(bool f)
{
- using_flags->get_config_ptr()->log_to_syslog = f;
+ config.log_to_syslog = f;
csp_logger->set_log_syslog(-1, f);
}
void Ui_MainWindowBase::do_set_logging_fdc(bool f)
{
- using_flags->get_config_ptr()->special_debug_fdc = f;
+ config.special_debug_fdc = f;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::do_set_dev_log_to_console(int num, bool f)
{
csp_logger->set_device_node_log(num, 2, CSP_LOG_DEBUG, f);
- using_flags->get_config_ptr()->dev_log_to_console[num][0] = f;
+ config.dev_log_to_console[num][0] = f;
}
void Ui_MainWindowBase::do_set_state_log_to_console(bool f)
{
csp_logger->set_state_log(2, f);
- using_flags->get_config_ptr()->state_log_to_console = f;
+ config.state_log_to_console = f;
}
void Ui_MainWindowBase::do_set_state_log_to_syslog(bool f)
{
csp_logger->set_state_log(1, f);
- using_flags->get_config_ptr()->state_log_to_syslog = f;
+ config.state_log_to_syslog = f;
}
void Ui_MainWindowBase::do_set_state_log_to_record(bool f)
{
csp_logger->set_state_log(0, f);
- using_flags->get_config_ptr()->state_log_to_recording = f;
+ config.state_log_to_recording = f;
}
void Ui_MainWindowBase::do_set_emulate_cursor_as(int num)
{
if((num < 0) || (num > 2)) return;
- using_flags->get_config_ptr()->cursor_as_ten_key = num;
+ config.cursor_as_ten_key = num;
emit sig_emu_update_config();
}
void Ui_MainWindowBase::do_set_dev_log_to_syslog(int num, bool f)
{
csp_logger->set_device_node_log(num, 2, CSP_LOG_DEBUG, f);
- using_flags->get_config_ptr()->dev_log_to_syslog[num][0] = f;
+ config.dev_log_to_syslog[num][0] = f;
}
void Ui_MainWindowBase::do_select_render_platform(int num)
break;
}
if(_type >= 0) {
- using_flags->get_config_ptr()->render_platform = _type;
- using_flags->get_config_ptr()->render_major_version = _major;
- using_flags->get_config_ptr()->render_minor_version = _minor;
+ config.render_platform = _type;
+ config.render_major_version = _major;
+ config.render_minor_version = _minor;
}
}
{
if((num < 0) || (num >= 32)) return;
if(flag) {
- using_flags->get_config_ptr()->dipswitch = using_flags->get_config_ptr()->dipswitch | (1 << num);
+ config.dipswitch = config.dipswitch | (1 << num);
} else {
- using_flags->get_config_ptr()->dipswitch = using_flags->get_config_ptr()->dipswitch & ~(1 << num);
+ config.dipswitch = config.dipswitch & ~(1 << num);
}
}
bool Ui_MainWindowBase::get_dipsw(int num)
{
if((num < 0) || (num >= 32)) return false;
- if(((1 << num) & using_flags->get_config_ptr()->dipswitch) == 0) return false;
+ if(((1 << num) & config.dipswitch) == 0) return false;
return true;
}
QSurfaceFormat fmt;
{
- int render_type = using_flags->get_config_ptr()->render_platform;
+ int render_type = config.render_platform;
QOpenGLContext *glContext = QOpenGLContext::globalShareContext();
- //int _major_version = using_flags->get_config_ptr()->render_major_version;
- //int _minor_version = using_flags->get_config_ptr()->render_minor_version;
+ //int _major_version = config.render_major_version;
+ //int _minor_version = config.render_minor_version;
if(render_type == CONFIG_RENDER_PLATFORM_OPENGL_ES) {
fmt.setRenderableType(QSurfaceFormat::OpenGLES);
bitmapImage = NULL;
driveData = new CSP_DockDisks(this, using_flags);
MainWindow->setDockOptions(QMainWindow::AnimatedDocks);
- if(using_flags->get_config_ptr()->virtual_media_position > 0) {
+ if(config.virtual_media_position > 0) {
driveData->setVisible(true);
} else {
driveData->setVisible(false);
pCentralLayout->setContentsMargins(0, 0, 0, 0);
pCentralLayout->addWidget(graphicsView);
pCentralLayout->addWidget(driveData);
- switch(using_flags->get_config_ptr()->virtual_media_position) {
+ switch(config.virtual_media_position) {
case 0:
pCentralLayout->setDirection(QBoxLayout::TopToBottom);
pCentralLayout->removeWidget(driveData);
pCentralWidget->setLayout(pCentralLayout);
MainWindow->setCentralWidget(pCentralWidget);
- if(using_flags->get_config_ptr()->focus_with_click) {
+ if(config.focus_with_click) {
graphicsView->setFocusPolicy(Qt::ClickFocus);
graphicsView->setFocus(0);
} else {
graphicsView->setFocusPolicy(Qt::NoFocus);
}
- driveData->setOrientation(using_flags->get_config_ptr()->virtual_media_position);
+ driveData->setOrientation(config.virtual_media_position);
connect(this, SIGNAL(sig_set_orientation_osd(int)), driveData, SLOT(setOrientation(int)));
connect(graphicsView, SIGNAL(sig_resize_osd(int)), driveData, SLOT(setScreenWidth(int)));
SET_HELP_MENUENTRY(menuHELP, actionHelp_License, "menuHelp_License", "LICENSE.txt");
SET_HELP_MENUENTRY(menuHELP, actionHelp_License_JP, "menuHelp_License_JP", "LICENSE.ja.txt");
- if(using_flags->get_config_ptr()->window_mode <= 0) using_flags->get_config_ptr()->window_mode = 0;
- if(using_flags->get_config_ptr()->window_mode >= using_flags->get_screen_mode_num()) using_flags->get_config_ptr()->window_mode = using_flags->get_screen_mode_num() - 1;
+ if(config.window_mode <= 0) config.window_mode = 0;
+ if(config.window_mode >= using_flags->get_screen_mode_num()) config.window_mode = using_flags->get_screen_mode_num() - 1;
w = using_flags->get_screen_width();
h = using_flags->get_screen_height();
- if(actionScreenSize[using_flags->get_config_ptr()->window_mode] != NULL) {
- double nd = actionScreenSize[using_flags->get_config_ptr()->window_mode]->binds->getDoubleValue();
+ if(actionScreenSize[config.window_mode] != NULL) {
+ double nd = actionScreenSize[config.window_mode]->binds->getDoubleValue();
w = (int)(nd * (double)w);
h = (int)(nd * (double)h);
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
int tmp_w = w;
w = h;
h = tmp_w;
}
} else {
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
w = 600;
h = 960;
} else {
}
}
this->set_screen_size(w, h);
- this->set_screen_aspect(using_flags->get_config_ptr()->window_stretch_type);
- if(actionScreenSize[using_flags->get_config_ptr()->window_mode] != NULL) {
- double nd = actionScreenSize[using_flags->get_config_ptr()->window_mode]->binds->getDoubleValue();
+ this->set_screen_aspect(config.window_stretch_type);
+ if(actionScreenSize[config.window_mode] != NULL) {
+ double nd = actionScreenSize[config.window_mode]->binds->getDoubleValue();
graphicsView->do_set_screen_multiply(nd);
}
if(using_flags->is_use_joystick()) {
void Ui_MainWindowBase::do_set_roma_kana(bool flag)
{
- using_flags->get_config_ptr()->romaji_to_kana = flag;
+ config.romaji_to_kana = flag;
emit sig_set_roma_kana(flag);
}
void Ui_MainWindowBase::do_set_numpad_enter_as_fullkey(bool flag)
{
- using_flags->get_config_ptr()->numpad_enter_as_fullkey = flag;
+ config.numpad_enter_as_fullkey = flag;
}
void Ui_MainWindowBase::do_set_print_cpu_statistics(bool flag)
{
- using_flags->get_config_ptr()->print_statistics = flag;
+ config.print_statistics = flag;
}
void Ui_MainWindowBase::CreateEmulatorMenu(void)
actionMonitorType[ii]->setCheckable(true);
actionMonitorType[ii]->setVisible(true);
actionMonitorType[ii]->binds->setValue1(ii);
- if(using_flags->get_config_ptr()->monitor_type == ii) actionMonitorType[ii]->setChecked(true);
+ if(config.monitor_type == ii) actionMonitorType[ii]->setChecked(true);
menuMonitorType->addAction(actionMonitorType[ii]);
connect(actionMonitorType[ii], SIGNAL(triggered()),
actionMonitorType[ii]->binds, SLOT(do_set_monitor_type()));
action_DispVirtualMedias[i] = new Action_Control(this, using_flags);
action_DispVirtualMedias[i]->setCheckable(true);
action_DispVirtualMedias[i]->setChecked(false);
- if(i == using_flags->get_config_ptr()->virtual_media_position) action_DispVirtualMedias[i]->setChecked(true);
+ if(i == config.virtual_media_position) action_DispVirtualMedias[i]->setChecked(true);
action_DispVirtualMedias[i]->setEnabled(true);
actionGroup_DispVirtualMedias->addAction(action_DispVirtualMedias[i]);
menu_DispVirtualMedias->addAction(action_DispVirtualMedias[i]);
if(using_flags->is_use_auto_key()) {
// ToDo: Setup if checked.
- SET_ACTION_SINGLE(action_UseRomaKana, true, true, (using_flags->get_config_ptr()->romaji_to_kana));
+ SET_ACTION_SINGLE(action_UseRomaKana, true, true, (config.romaji_to_kana));
connect(action_UseRomaKana, SIGNAL(toggled(bool)), this, SLOT(do_set_roma_kana(bool)));
}
- SET_ACTION_SINGLE(action_NumPadEnterAsFullkey, true, true, (using_flags->get_config_ptr()->numpad_enter_as_fullkey));
+ SET_ACTION_SINGLE(action_NumPadEnterAsFullkey, true, true, (config.numpad_enter_as_fullkey));
connect(action_NumPadEnterAsFullkey, SIGNAL(toggled(bool)), this, SLOT(do_set_numpad_enter_as_fullkey(bool)));
- SET_ACTION_SINGLE(action_PrintCpuStatistics, true, true, (using_flags->get_config_ptr()->print_statistics));
+ SET_ACTION_SINGLE(action_PrintCpuStatistics, true, true, (config.print_statistics));
connect(action_PrintCpuStatistics, SIGNAL(toggled(bool)), this, SLOT(do_set_print_cpu_statistics(bool)));
// Cursor to ten key.
action_EmulateCursorAs[i]->binds->setValue1(i);
actionGroup_EmulateCursorAs->addAction(action_EmulateCursorAs[i]);
menu_EmulateCursorAs->addAction(action_EmulateCursorAs[i]);
- if(i == using_flags->get_config_ptr()->cursor_as_ten_key) action_EmulateCursorAs[i]->setChecked(true);
+ if(i == config.cursor_as_ten_key) action_EmulateCursorAs[i]->setChecked(true);
connect(action_EmulateCursorAs[i], SIGNAL(triggered()),
action_EmulateCursorAs[i], SLOT(do_set_emulate_cursor_as()));
actionSpeed_FULL->setVisible(true);
actionSpeed_FULL->setCheckable(true);
actionSpeed_FULL->setChecked(false);
- if(using_flags->get_config_ptr()->full_speed) actionSpeed_FULL->setChecked(true);
+ if(config.full_speed) actionSpeed_FULL->setChecked(true);
connect(actionSpeed_FULL, SIGNAL(toggle(bool)), this,SLOT(do_emu_full_speed(bool))); // OK?
if(using_flags->is_use_joystick()) {
action_SoundFilesFDD->setCheckable(true);
action_SoundFilesFDD->setEnabled(true);
action_SoundFilesFDD->setChecked(false);
- if(using_flags->get_config_ptr()->sound_noise_fdd != 0) {
+ if(config.sound_noise_fdd != 0) {
action_SoundFilesFDD->setChecked(true);
}
*/
- SET_ACTION_SINGLE(action_SoundFilesFDD, true, true, (using_flags->get_config_ptr()->sound_noise_fdd != 0));
+ SET_ACTION_SINGLE(action_SoundFilesFDD, true, true, (config.sound_noise_fdd != 0));
}
if(using_flags->is_use_sound_files_relay()) {
/*
action_SoundFilesRelay->setCheckable(true);
action_SoundFilesRelay->setEnabled(true);
action_SoundFilesRelay->setChecked(false);
- if(using_flags->get_config_ptr()->sound_noise_cmt != 0) {
+ if(config.sound_noise_cmt != 0) {
action_SoundFilesRelay->setChecked(true);
}
*/
- SET_ACTION_SINGLE(action_SoundFilesRelay, true, true, (using_flags->get_config_ptr()->sound_noise_cmt != 0));
+ SET_ACTION_SINGLE(action_SoundFilesRelay, true, true, (config.sound_noise_cmt != 0));
}
action_FocusWithClick = new Action_Control(this, using_flags);
action_FocusWithClick->setCheckable(true);
action_FocusWithClick->setEnabled(true);
- if(using_flags->get_config_ptr()->focus_with_click) {
+ if(config.focus_with_click) {
action_FocusWithClick->setChecked(true);
}
action_Logging_FDC = NULL;
if(using_flags->is_use_fd()) {
- SET_ACTION_SINGLE(action_Logging_FDC, true, true, (using_flags->get_config_ptr()->special_debug_fdc != 0));
+ SET_ACTION_SINGLE(action_Logging_FDC, true, true, (config.special_debug_fdc != 0));
connect(action_Logging_FDC, SIGNAL(toggled(bool)), this, SLOT(do_set_logging_fdc(bool)));
}
#if !defined(Q_OS_WIN)
action_LogToSyslog = new Action_Control(this, using_flags);
action_LogToSyslog->setCheckable(true);
action_LogToSyslog->setEnabled(true);
- if(using_flags->get_config_ptr()->log_to_syslog != 0) action_LogToSyslog->setChecked(true);
+ if(config.log_to_syslog != 0) action_LogToSyslog->setChecked(true);
menuDevLogToSyslog = new QMenu(this);
menuDevLogToSyslog->setToolTipsVisible(true);
for(int i = 0; i < (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1); i++) {
action_DevLogToSyslog[i]->setEnabled(false);
action_DevLogToSyslog[i]->binds->setValue1(i);
menuDevLogToSyslog->addAction(action_DevLogToSyslog[i]);
- if(using_flags->get_config_ptr()->dev_log_to_syslog[i][0]) action_DevLogToSyslog[i]->setChecked(true);
+ if(config.dev_log_to_syslog[i][0]) action_DevLogToSyslog[i]->setChecked(true);
connect(action_DevLogToSyslog[i], SIGNAL(toggled(bool)),
action_DevLogToSyslog[i], SLOT(do_set_dev_log_to_syslog(bool)));
connect(action_DevLogToSyslog[i], SIGNAL(sig_set_dev_log_to_syslog(int, bool)),
action_LogToConsole = new Action_Control(this, using_flags);
action_LogToConsole->setCheckable(true);
action_LogToConsole->setEnabled(true);
- if(using_flags->get_config_ptr()->log_to_console != 0) action_LogToConsole->setChecked(true);
+ if(config.log_to_console != 0) action_LogToConsole->setChecked(true);
//menuDevLogToConsole = new QMenu(menuEmulator);
menuDevLogToConsole = new QMenu(this);
action_DevLogToConsole[i]->setEnabled(false);
action_DevLogToConsole[i]->binds->setValue1(i);
menuDevLogToConsole->addAction(action_DevLogToConsole[i]);
- if(using_flags->get_config_ptr()->dev_log_to_console[i][0]) action_DevLogToConsole[i]->setChecked(true);
+ if(config.dev_log_to_console[i][0]) action_DevLogToConsole[i]->setChecked(true);
connect(action_DevLogToConsole[i], SIGNAL(toggled(bool)),
action_DevLogToConsole[i], SLOT(do_set_dev_log_to_console(bool)));
connect(action_DevLogToConsole[i], SIGNAL(sig_set_dev_log_to_console(int, bool)),
actionGroup_SetRenderPlatform = new QActionGroup(this);
actionGroup_SetRenderPlatform->setExclusive(true);
{
- int render_type = using_flags->get_config_ptr()->render_platform;
- int _major_version = using_flags->get_config_ptr()->render_major_version;
- //int _minor_version = using_flags->get_config_ptr()->render_minor_version; // ToDo
+ int render_type = config.render_platform;
+ int _major_version = config.render_major_version;
+ //int _minor_version = config.render_minor_version; // ToDo
for(i = 0; i < MAX_RENDER_PLATFORMS; i++) {
tmps = QString::number(i);
action_SetRenderPlatform[i] = new Action_Control(this, using_flags);
{
QRect rect;
driveData->setVisible(false);
- using_flags->get_config_ptr()->virtual_media_position = 0;
+ config.virtual_media_position = 0;
set_screen_size(graphicsView->width(), graphicsView->height());
pCentralLayout->setDirection(QBoxLayout::TopToBottom);
{
QRect rect;
driveData->setVisible(true);
- using_flags->get_config_ptr()->virtual_media_position = 1;
+ config.virtual_media_position = 1;
set_screen_size(graphicsView->width(), graphicsView->height());
emit sig_set_orientation_osd(1);
pCentralLayout->setDirection(QBoxLayout::TopToBottom);
{
QRect rect;
driveData->setVisible(true);
- using_flags->get_config_ptr()->virtual_media_position = 2;
+ config.virtual_media_position = 2;
set_screen_size(graphicsView->width(), graphicsView->height());
emit sig_set_orientation_osd(2);
pCentralLayout->setDirection(QBoxLayout::BottomToTop);
{
#if 0
driveData->setVisible(true);
- using_flags->get_config_ptr()->virtual_media_position = 3;
+ config.virtual_media_position = 3;
set_screen_size(graphicsView->width(), graphicsView->height());
emit sig_set_orientation_osd(3);
pCentralLayout->removeWidget(driveData);
{
#if 0
driveData->setVisible(true);
- using_flags->get_config_ptr()->virtual_media_position = 4;
+ config.virtual_media_position = 4;
set_screen_size(graphicsView->width(), graphicsView->height());
emit sig_set_orientation_osd(4);
pCentralLayout->removeWidget(driveData);
QDir dir;
char app[PATH_MAX];
initial_dir = dir.currentPath();
- strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX);
+ strncpy(app, initial_dir.toLocal8Bit().constData(), PATH_MAX - 1);
initial_dir = QString::fromLocal8Bit(get_parent_dir(app));
}
dlg.setOption(QFileDialog::ReadOnly, false);
float nd, ww, hh;
float xzoom = using_flags->get_screen_x_zoom();
float yzoom = using_flags->get_screen_y_zoom();
- using_flags->get_config_ptr()->window_mode = getNumber();
+ config.window_mode = getNumber();
nd = getDoubleValue();
ww = (float)using_flags->get_screen_width();
hh = (float)using_flags->get_screen_height();
float par_w = (float)using_flags->get_screen_width_aspect() / ww;
float par_h = (float)using_flags->get_screen_height_aspect() / hh;
//float par = par_h / par_w;
- switch(using_flags->get_config_ptr()->window_stretch_type) {
+ switch(config.window_stretch_type) {
case 0: // refer to X and Y.
ww = ww * nd * xzoom;
hh = hh * nd * yzoom;
void Object_Menu_Control::do_save_as_movie(void)
{
- int fps = using_flags->get_config_ptr()->video_frame_rate;
+ int fps = config.video_frame_rate;
emit sig_start_record_movie(fps);
}
void Ui_MainWindowBase::do_set_render_mode_std(void)
{
- using_flags->get_config_ptr()->rendering_type = CONFIG_RENDER_TYPE_STD;
+ config.rendering_type = CONFIG_RENDER_TYPE_STD;
}
void Ui_MainWindowBase::do_set_render_mode_tv(void)
{
- using_flags->get_config_ptr()->rendering_type = CONFIG_RENDER_TYPE_TV;
+ config.rendering_type = CONFIG_RENDER_TYPE_TV;
}
void Ui_MainWindowBase::do_set_state_saving_movie(bool state)
void Ui_MainWindowBase::set_gl_scan_line_vert(bool f)
{
- using_flags->get_config_ptr()->opengl_scanline_vert = f;
+ config.opengl_scanline_vert = f;
}
void Ui_MainWindowBase::do_set_separate_thread_draw(bool f)
{
- using_flags->get_config_ptr()->use_separate_thread_draw = f;
+ config.use_separate_thread_draw = f;
}
void Ui_MainWindowBase::set_gl_scan_line_horiz(bool f)
{
- using_flags->get_config_ptr()->opengl_scanline_horiz = f;
+ config.opengl_scanline_horiz = f;
}
void Ui_MainWindowBase::set_osd_virtual_media(bool f)
{
- using_flags->get_config_ptr()->use_osd_virtual_media = f;
+ config.use_osd_virtual_media = f;
}
void Ui_MainWindowBase::ConfigScreenMenu_List(void)
actionScreenSize[i]->setCheckable(true);
actionScreenSize[i]->binds->setNumber(i);
- if(i == using_flags->get_config_ptr()->window_mode) actionScreenSize[i]->setChecked(true); // OK?
+ if(i == config.window_mode) actionScreenSize[i]->setChecked(true); // OK?
actionGroup_ScreenSize->addAction(actionScreenSize[i]);
actionScreenSize[i]->binds->setDoubleValue(screen_multiply_table[i]);
actionDisplay_Mode = new Action_Control(this, using_flags);
actionDisplay_Mode->setObjectName(QString::fromUtf8("actionDisplay_Mode"));
- SET_ACTION_SINGLE(action_ScreenSeparateThread, true, true, (using_flags->get_config_ptr()->use_separate_thread_draw));
+ SET_ACTION_SINGLE(action_ScreenSeparateThread, true, true, (config.use_separate_thread_draw));
connect(action_ScreenSeparateThread, SIGNAL(toggled(bool)), this, SLOT(do_set_separate_thread_draw(bool)));
if(using_flags->is_use_scanline()) {
actionScanLine = new Action_Control(this, using_flags);
actionScanLine->setObjectName(QString::fromUtf8("actionScanLine"));
actionScanLine->setCheckable(true);
- if(using_flags->get_config_ptr()->scan_line) {
+ if(config.scan_line) {
actionScanLine->setChecked(true);
} else {
actionScanLine->setChecked(false);
this, SLOT(set_scan_line(bool)));
}
- SET_ACTION_SINGLE(action_ScreenUseOSD, true, true, (using_flags->get_config_ptr()->use_osd_virtual_media));
+ SET_ACTION_SINGLE(action_ScreenUseOSD, true, true, (config.use_osd_virtual_media));
connect(action_ScreenUseOSD, SIGNAL(toggled(bool)),this, SLOT(set_osd_virtual_media(bool)));
if(!using_flags->is_use_one_board_computer() && (using_flags->get_max_button() <= 0)) {
actionGLScanLineHoriz = new Action_Control(this, using_flags);
actionGLScanLineHoriz->setObjectName(QString::fromUtf8("actionGLScanLineHoriz"));
actionGLScanLineHoriz->setCheckable(true);
- if(using_flags->get_config_ptr()->opengl_scanline_horiz != 0) {
+ if(config.opengl_scanline_horiz != 0) {
actionGLScanLineHoriz->setChecked(true);
} else {
actionGLScanLineHoriz->setChecked(false);
actionGLScanLineVert = new Action_Control(this, using_flags);
actionGLScanLineVert->setObjectName(QString::fromUtf8("actionGLScanLineVert"));
actionGLScanLineVert->setCheckable(true);
- if(using_flags->get_config_ptr()->opengl_scanline_vert != 0) {
+ if(config.opengl_scanline_vert != 0) {
actionGLScanLineVert->setChecked(true);
} else {
actionGLScanLineVert->setChecked(false);
actionRotate = new Action_Control(this, using_flags);
actionRotate->setObjectName(QString::fromUtf8("actionScanLine"));
actionRotate->setCheckable(true);
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
actionRotate->setChecked(true);
} else {
actionRotate->setChecked(false);
actionOpenGL_Filter->setObjectName(QString::fromUtf8("actionOpenGL_Filter"));
actionOpenGL_Filter->setEnabled(true);
actionOpenGL_Filter->setCheckable(true);
- if(using_flags->get_config_ptr()->use_opengl_filters) actionOpenGL_Filter->setChecked(true);
+ if(config.use_opengl_filters) actionOpenGL_Filter->setChecked(true);
connect(actionOpenGL_Filter, SIGNAL(toggled(bool)), this, SLOT(set_gl_crt_filter(bool)));
if((using_flags->get_screen_height_aspect() != using_flags->get_screen_height()) ||
actionDot_by_Dot = new Action_Control(this, using_flags);
actionDot_by_Dot->setObjectName(QString::fromUtf8("actionDot_by_Dot"));
actionDot_by_Dot->setCheckable(true);
- if(using_flags->get_config_ptr()->window_stretch_type == 0) actionDot_by_Dot->setChecked(true);
+ if(config.window_stretch_type == 0) actionDot_by_Dot->setChecked(true);
actionDot_by_Dot->binds->setValue1(0);
actionReferToX_Display = new Action_Control(this, using_flags);
actionReferToX_Display->setObjectName(QString::fromUtf8("actionReferToX_Display"));
actionReferToX_Display->setCheckable(true);
actionReferToX_Display->binds->setValue1(1);
- if(using_flags->get_config_ptr()->window_stretch_type == 1) actionReferToX_Display->setChecked(true);
+ if(config.window_stretch_type == 1) actionReferToX_Display->setChecked(true);
actionReferToY_Display = new Action_Control(this, using_flags);
actionReferToY_Display->setObjectName(QString::fromUtf8("actionReferToY_Display"));
actionReferToY_Display->setCheckable(true);
actionReferToY_Display->binds->setValue1(2);
- if(using_flags->get_config_ptr()->window_stretch_type == 2) actionReferToY_Display->setChecked(true);
+ if(config.window_stretch_type == 2) actionReferToY_Display->setChecked(true);
actionFill_Display = new Action_Control(this, using_flags);
actionFill_Display->setObjectName(QString::fromUtf8("actionFill_Display"));
actionFill_Display->setCheckable(true);
actionFill_Display->binds->setValue1(3);
- if(using_flags->get_config_ptr()->window_stretch_type == 3) actionFill_Display->setChecked(true);
+ if(config.window_stretch_type == 3) actionFill_Display->setChecked(true);
actionGroup_Stretch = new QActionGroup(this);
actionGroup_Stretch->setExclusive(true);
action_SetRenderMode[i]->setVisible(false);
action_SetRenderMode[i]->binds->setValue1(i);
- if(i == using_flags->get_config_ptr()->rendering_type) action_SetRenderMode[i]->setChecked(true);
+ if(i == config.rendering_type) action_SetRenderMode[i]->setChecked(true);
if(i == CONFIG_RENDER_TYPE_STD) {
action_SetRenderMode[i]->setEnabled(true);
void Ui_MainWindowBase::do_set_sound_strict_rendering(bool f)
{
if(using_flags != NULL) {
- using_flags->get_config_ptr()->sound_strict_rendering = f;
+ config.sound_strict_rendering = f;
}
}
void Ui_MainWindowBase::do_set_sound_play_tape(bool f)
{
if(using_flags != NULL) {
- using_flags->get_config_ptr()->sound_play_tape = f;
+ config.sound_play_tape = f;
}
}
dlg->setWindowIcon(img);
this->retranslateVolumeLabels(dlg);
- n = (float)(((using_flags->get_config_ptr()->general_sound_level + 32768) * 1000) / 65535) / 10.0;
+ n = (float)(((config.general_sound_level + 32768) * 1000) / 65535) / 10.0;
s_val.setNum(n, 'f', 1);
tmps = QApplication::translate("Ui_SoundDialog", "Set Volume", 0);
tmps = tmps + QString::fromUtf8(" (") + s_val + QString::fromUtf8("%)");
menuSound->addAction(actionStart_Record);
menuSound->addSeparator();
SET_ACTION_CHECKABLE_SINGLE_CONNECT(menuSound, actionSoundStrictRendering,
- "actionSoundStrictRendering", using_flags->get_config_ptr()->sound_strict_rendering,
+ "actionSoundStrictRendering", config.sound_strict_rendering,
SIGNAL(toggled(bool)), SLOT(do_set_sound_strict_rendering(bool)));
SET_ACTION_CHECKABLE_SINGLE_CONNECT(menuSound, actionSoundPlayTape,
- "actionSoundPlayTape", using_flags->get_config_ptr()->sound_play_tape,
+ "actionSoundPlayTape", config.sound_play_tape,
SIGNAL(toggled(bool)), SLOT(do_set_sound_play_tape(bool)));
//actionSoundStrictRendering = new Action_Control(this, using_flags);
//actionSoundStrictRendering->setObjectName(QString::fromUtf8("actionSoundStrictRendering"));
//actionSoundStrictRendering->setCheckable(true);
- //if(using_flags->get_config_ptr()->sound_strict_rendering) actionSoundStrictRendering->setChecked(true);
+ //if(config.sound_strict_rendering) actionSoundStrictRendering->setChecked(true);
//connect(actionSoundStrictRendering, SIGNAL(toggled(bool)),
// this, SLOT(do_set_sound_strict_rendering(bool)));
//menuSound->addAction(actionSoundStrictRendering);
action_Freq[i]->setObjectName(tmps);
action_Freq[i]->setCheckable(true);
action_Freq[i]->binds->setNumber(i);
- if(i == using_flags->get_config_ptr()->sound_frequency) {
+ if(i == config.sound_frequency) {
action_Freq[i]->setChecked(true);
//freq = using_flags->get_s_freq_table(i);
}
action_Latency[i]->setObjectName(tmps);
action_Latency[i]->setCheckable(true);
action_Latency[i]->binds->setNumber(i);
- if(i == using_flags->get_config_ptr()->sound_latency) action_Latency[i]->setChecked(true);
+ if(i == config.sound_latency) action_Latency[i]->setChecked(true);
actionGroup_Sound_Latency->addAction(action_Latency[i]);
}
action_VolumeDialog->setToolTip(QApplication::translate("MenuSound", "Open a VOLUME dialog.", 0));
menuSound->setToolTipsVisible(true);
- do_update_volume(using_flags->get_config_ptr()->general_sound_level);
+ do_update_volume(config.general_sound_level);
}
double xpos = (double)(pos.x()) / (double)width();
double ypos = (double)(pos.y()) / (double)height();
if(using_flags->is_use_screen_rotate()) {
- if(using_flags->get_config_ptr()->rotate_type) {
+ if(config.rotate_type) {
xx = ypos * (double)d_hh;
yy = xpos * (double)d_ww;
} else {
{
QOpenGLContext *glContext = QOpenGLContext::currentContext();
//QOpenGLContext *glContext = QOpenGLContext::globalShareContext();
- int render_type = using_flags->get_config_ptr()->render_platform;
- int _major_version = using_flags->get_config_ptr()->render_major_version;
- int _minor_version = using_flags->get_config_ptr()->render_minor_version;
+ int render_type = config.render_platform;
+ int _major_version = config.render_major_version;
+ int _minor_version = config.render_minor_version;
QSurfaceFormat _fmt = glContext->format();
//QSurfaceFormat::RenderableType capability = _fmt.renderableType();
#if !defined(Q_OS_WIN)
{
uint32_t vk;
vk = key_table->get_vk_from_scan(data);
- if(using_flags->get_config_ptr()->swap_kanji_pause) {
+ if(config.swap_kanji_pause) {
if(vk == VK_KANJI) {
vk = VK_PAUSE;
} else if(vk == VK_PAUSE) {
if((vk == VK_LMENU) || (vk == VK_RMENU)) vk = VK_MENU;
}
if((vk == VK_LCONTROL) || (vk == VK_RCONTROL)) vk = VK_CONTROL;
- if(using_flags->get_config_ptr()->numpad_enter_as_fullkey) {
+ if(config.numpad_enter_as_fullkey) {
if(vk == VK_OEM_CSP_KPRET) vk = VK_RETURN;
}
return vk;
return;
}
l = strlen(file) - i + 1;
- if(l >= maxlen) l = maxlen;
+ if(l >= maxlen) l = maxlen - 1;
strncpy(dst, &file[i + 1], l);
return;
}
float n;
if(level < -32768) level = -32678;
if(level > 32767) level = 32767;
- using_flags->get_config_ptr()->general_sound_level = level;
+ config.general_sound_level = level;
tmps = QApplication::translate("Ui_SoundDialog", "Set Volume", 0);
n = (float)(((level + 32768) * 1000) / 65535) / 10.0;
sliderMasterVolume->setMaximum(32768);
sliderMasterVolume->setSingleStep(256);
sliderMasterVolume->setPageStep(4096);
- sliderMasterVolume->setValue(using_flags->get_config_ptr()->general_sound_level);
+ sliderMasterVolume->setValue(config.general_sound_level);
sliderMasterVolume->connect(sliderMasterVolume, SIGNAL(valueChanged(int)),
sliderMasterVolume, SLOT(setValue(int)));
VBoxMasterVolume = new QVBoxLayout;
int ij = 0;
for(ii = 0; ii < using_flags->get_use_sound_volume(); ii++) {
QString lbl = QApplication::translate("Ui_SoundDialog", using_flags->get_sound_device_caption(ii), 0);
- int l_val = using_flags->get_config_ptr()->sound_volume_l[ii];
- int r_val = using_flags->get_config_ptr()->sound_volume_r[ii];
+ int l_val = config.sound_volume_l[ii];
+ int r_val = config.sound_volume_r[ii];
int s_lvl;
int s_balance;
for(int i = 0; i < combo_vcodec->count(); i++) {
int ii = combo_vcodec->itemData(i).toInt();
- if(ii == using_flags->get_config_ptr()->video_codec_type) {
+ if(ii == config.video_codec_type) {
combo_vcodec->setCurrentIndex(ii);
}
}
- video_codec_type = using_flags->get_config_ptr()->video_codec_type;
+ video_codec_type = config.video_codec_type;
connect(combo_vcodec, SIGNAL(activated(int)), this, SLOT(do_set_video_codec_type(int)));
label_resolution = new QLabel(QApplication::translate("MovieTabGeneral", "Resolution", 0), this);
combo_resolution = new QComboBox(this);
combo_resolution->setToolTip(QApplication::translate("MovieTabGeneral", "Set resolution of encoded movie file.", 0));
- geometry.setWidth(using_flags->get_config_ptr()->video_width);
- geometry.setHeight(using_flags->get_config_ptr()->video_height);
- audio_bitrate = using_flags->get_config_ptr()->audio_bitrate;
- audio_codec_type = using_flags->get_config_ptr()->audio_codec_type;
+ geometry.setWidth(config.video_width);
+ geometry.setHeight(config.video_height);
+ audio_bitrate = config.audio_bitrate;
+ audio_codec_type = config.audio_codec_type;
label_video_threads = new QLabel(QApplication::translate("MovieTabGeneral", "Video Threads", 0), this);
combo_video_threads = new QComboBox(this);
combo_audio_codec->setToolTip(QApplication::translate("MovieTabGeneral", "Set codec of audio.\nMP3 is using LAME.\nAAC is experimental; using libAV's AAC encoder.", 0));
label_video_fps = new QLabel(QApplication::translate("MovieTabGeneral", "Framerate", 0), this);
combo_video_fps = new QComboBox(this);
- video_fps = using_flags->get_config_ptr()->video_frame_rate;
+ video_fps = config.video_frame_rate;
// Value for resolution
//bool skipf = false;
for(int i = 0; i < combo_resolution->count(); i++) {
QSize s = combo_resolution->itemData(i).toSize();
- if((s.width() == using_flags->get_config_ptr()->video_width) && (s.height() == using_flags->get_config_ptr()->video_height)) {
+ if((s.width() == config.video_width) && (s.height() == config.video_height)) {
combo_resolution->setCurrentIndex(i);
}
}
combo_video_threads->addItem(QString::fromUtf8("12"), 12);
for(int i = 0; i < combo_video_threads->count(); i++) {
int br = combo_video_threads->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_threads) {
+ if(br == config.video_threads) {
combo_video_threads->setCurrentIndex(i);
}
}
- video_threads = using_flags->get_config_ptr()->video_threads;
+ video_threads = config.video_threads;
connect(combo_video_threads, SIGNAL(activated(int)), this, SLOT(do_set_video_threads(int)));
// Audio bitrate
combo_audio_bitrate->addItem(QString::fromUtf8("384kbps"), 384);
for(int i = 0; i < combo_audio_bitrate->count(); i++) {
int br = combo_audio_bitrate->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->audio_bitrate) {
+ if(br == config.audio_bitrate) {
combo_audio_bitrate->setCurrentIndex(i);
}
}
//combo_audio_codec->addItem(QString::fromUtf8("VORBIS(Maybe not working)"), AUDIO_CODEC_VORBIS);
for(int i = 0; i < combo_audio_codec->count(); i++) {
int br = combo_audio_codec->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->audio_codec_type) {
+ if(br == config.audio_codec_type) {
combo_audio_codec->setCurrentIndex(i);
}
}
combo_video_fps->addItem(QString::fromUtf8("60fps"), 60); // Temporally disabled
for(int i = 0; i < combo_video_fps->count(); i++) {
int fps = combo_video_fps->itemData(i).toInt();
- if(fps == using_flags->get_config_ptr()->video_frame_rate) {
+ if(fps == config.video_frame_rate) {
combo_video_fps->setCurrentIndex(i);
}
}
// See:
// https://libav.org/avconv.html#Video-Options
- using_flags->get_config_ptr()->audio_bitrate = audio_bitrate;
+ config.audio_bitrate = audio_bitrate;
emit sig_set_audio_bitrate(audio_bitrate);
switch(video_codec_type) {
emit sig_video_add_option(QString::fromUtf8("c:v"), QString::fromUtf8("h264"));
break;
}
- using_flags->get_config_ptr()->video_codec_type = video_codec_type;
+ config.video_codec_type = video_codec_type;
switch(audio_codec_type) {
case AUDIO_CODEC_MP3:
emit sig_video_add_option(QString::fromUtf8("c:a"), QString::fromUtf8("vorbis"));
break;
}
- using_flags->get_config_ptr()->video_codec_type = video_codec_type;
- using_flags->get_config_ptr()->audio_codec_type = audio_codec_type;
+ config.video_codec_type = video_codec_type;
+ config.audio_codec_type = audio_codec_type;
- using_flags->get_config_ptr()->video_threads = video_threads;
- using_flags->get_config_ptr()->video_frame_rate = video_fps;
+ config.video_threads = video_threads;
+ config.video_frame_rate = video_fps;
- using_flags->get_config_ptr()->video_width = geometry.width();
- using_flags->get_config_ptr()->video_height = geometry.height();
+ config.video_width = geometry.width();
+ config.video_height = geometry.height();
emit sig_set_video_resolution(geometry);
- using_flags->get_config_ptr()->video_threads = video_threads;
- using_flags->get_config_ptr()->video_frame_rate = video_fps;
+ config.video_threads = video_threads;
+ config.video_frame_rate = video_fps;
}
p_movie = ms;
p_window = parent_window;
- video_maxq = using_flags->get_config_ptr()->video_h264_maxq;
- video_minq = using_flags->get_config_ptr()->video_h264_minq;
+ video_maxq = config.video_h264_maxq;
+ video_minq = config.video_h264_minq;
label_video_bframes = new QLabel(QApplication::translate("MovieTabH264", "Max B Frames", 0), this);
combo_video_bframes = new QComboBox(this);
for(int i = 0; i < combo_video_bitrate->count(); i++) {
int br = combo_video_bitrate->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_h264_bitrate) {
+ if(br == config.video_h264_bitrate) {
combo_video_bitrate->setCurrentIndex(i);
}
}
connect(combo_video_bitrate, SIGNAL(activated(int)), this, SLOT(do_set_video_bitrate(int)));
- video_bitrate = using_flags->get_config_ptr()->video_h264_bitrate;
+ video_bitrate = config.video_h264_bitrate;
// Video bframes
combo_video_bframes->addItem(QString::fromUtf8("0"), 0);
combo_video_bframes->setToolTip(QApplication::translate("MovieTabH264", "Max numbers of B FRAMEs.\nLarger value will make smaller file, but slowly.", 0));
for(int i = 0; i < combo_video_bframes->count(); i++) {
int br = combo_video_bframes->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_h264_bframes) {
+ if(br == config.video_h264_bframes) {
combo_video_bframes->setCurrentIndex(i);
}
}
- video_bframes = using_flags->get_config_ptr()->video_h264_bframes;
+ video_bframes = config.video_h264_bframes;
connect(combo_video_bframes, SIGNAL(activated(int)), this, SLOT(do_set_bframes(int)));
// B adapt
combo_video_b_adapt->setToolTip(QApplication::translate("MovieTabH264", "Set decision of using B FRAMEs.", 0));
for(int i = 0; i < combo_video_b_adapt->count(); i++) {
int br = combo_video_b_adapt->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_h264_b_adapt) {
+ if(br == config.video_h264_b_adapt) {
combo_video_b_adapt->setCurrentIndex(i);
}
}
- video_b_adapt = using_flags->get_config_ptr()->video_h264_b_adapt;
+ video_b_adapt = config.video_h264_b_adapt;
connect(combo_video_b_adapt, SIGNAL(activated(int)), this, SLOT(do_set_b_adapt(int)));
slider_qmin = new QSlider(Qt::Horizontal, this);
slider_qmin->setMinimum(0);
slider_qmin->setMaximum(63);
- slider_qmin->setValue(using_flags->get_config_ptr()->video_h264_minq);
+ slider_qmin->setValue(config.video_h264_minq);
label_qmin_val = new QLabel(this);
- tmps.setNum(using_flags->get_config_ptr()->video_h264_minq);
+ tmps.setNum(config.video_h264_minq);
label_qmin_val->setText(tmps);
label_qmin_name = new QLabel(QString::fromUtf8("QP Min"), this);
slider_qmin->setToolTip(QApplication::translate("MovieTabH264", "Minimum Quant.\nSmaller value is better quality, but making larger file.\nLarger value is dirty picture, but making smaller file.\n15 to 24 is recommended.", 0));
- video_minq = using_flags->get_config_ptr()->video_h264_minq;
+ video_minq = config.video_h264_minq;
connect(slider_qmin, SIGNAL(valueChanged(int)), this, SLOT(do_set_qmin(int)));
slider_qmax = new QSlider(Qt::Horizontal, this);
slider_qmax->setMinimum(0);
slider_qmax->setMaximum(63);
- slider_qmax->setValue(using_flags->get_config_ptr()->video_h264_maxq);
+ slider_qmax->setValue(config.video_h264_maxq);
label_qmax_val = new QLabel(this);
- tmps.setNum(using_flags->get_config_ptr()->video_h264_maxq);
+ tmps.setNum(config.video_h264_maxq);
label_qmax_val->setText(tmps);
label_qmax_name = new QLabel(QString::fromUtf8("QP Max"), this);
slider_qmax->setToolTip(QApplication::translate("MovieTabH264", "Maximum Quant.\nSmaller value is better quality, but making larger file.\nLarger value is dirty picture, but making smaller file.\n20 to 28 is recommended.", 0));
connect(slider_qmax, SIGNAL(valueChanged(int)), this, SLOT(do_set_qmax(int)));
- video_maxq = using_flags->get_config_ptr()->video_h264_maxq;
+ video_maxq = config.video_h264_maxq;
// Subme
combo_video_subme->addItem(QApplication::translate("MovieTabH264", "RD mode decision for I/P-frames", 0), 6);
for(int i = 0; i < combo_video_subme->count(); i++) {
int br = combo_video_subme->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_h264_subme) {
+ if(br == config.video_h264_subme) {
combo_video_subme->setCurrentIndex(i);
}
}
- video_subme = using_flags->get_config_ptr()->video_h264_subme;
+ video_subme = config.video_h264_subme;
connect(combo_video_subme, SIGNAL(activated(int)), this, SLOT(do_set_subme(int)));
label_title = new QLabel(QApplication::translate("MovieTabH264", "Set H.264 parameter.", 0), this);
QString value;
// See:
// https://libav.org/avconv.html#Video-Options
- using_flags->get_config_ptr()->video_h264_bitrate = video_bitrate;
+ config.video_h264_bitrate = video_bitrate;
- using_flags->get_config_ptr()->video_h264_maxq = video_maxq;
- using_flags->get_config_ptr()->video_h264_minq = video_minq;
- using_flags->get_config_ptr()->video_h264_bframes = video_bframes;
- using_flags->get_config_ptr()->video_h264_b_adapt = video_b_adapt;
- using_flags->get_config_ptr()->video_h264_subme = video_subme;
+ config.video_h264_maxq = video_maxq;
+ config.video_h264_minq = video_minq;
+ config.video_h264_bframes = video_bframes;
+ config.video_h264_b_adapt = video_b_adapt;
+ config.video_h264_subme = video_subme;
}
void CSP_TabMovieH264::do_set_qmin(int n)
p_movie = ms;
p_window = parent_window;
- video_maxq = using_flags->get_config_ptr()->video_mpeg4_maxq;
- video_minq = using_flags->get_config_ptr()->video_mpeg4_minq;
+ video_maxq = config.video_mpeg4_maxq;
+ video_minq = config.video_mpeg4_minq;
if(video_maxq < video_minq) {
int n = video_maxq;
video_maxq = video_minq;
combo_video_bitrate->addItem(QString::fromUtf8("20000Kbps"), 20000);
for(int i = 0; i < combo_video_bitrate->count(); i++) {
int br = combo_video_bitrate->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_mpeg4_bitrate) {
+ if(br == config.video_mpeg4_bitrate) {
combo_video_bitrate->setCurrentIndex(i);
}
}
connect(combo_video_bitrate, SIGNAL(activated(int)), this, SLOT(do_set_video_bitrate(int)));
- video_bitrate = using_flags->get_config_ptr()->video_mpeg4_bitrate;
+ video_bitrate = config.video_mpeg4_bitrate;
// Video bframes
combo_video_bframes->addItem(QString::fromUtf8("1"), 1);
combo_video_bframes->addItem(QString::fromUtf8("8"), 8);
for(int i = 0; i < combo_video_bframes->count(); i++) {
int br = combo_video_bframes->itemData(i).toInt();
- if(br == using_flags->get_config_ptr()->video_mpeg4_bframes) {
+ if(br == config.video_mpeg4_bframes) {
combo_video_bframes->setCurrentIndex(i);
}
}
- video_bframes = using_flags->get_config_ptr()->video_mpeg4_bframes;
+ video_bframes = config.video_mpeg4_bframes;
connect(combo_video_bframes, SIGNAL(activated(int)), this, SLOT(do_set_bframes(int)));
slider_qmin = new QSlider(Qt::Horizontal, this);
slider_qmin->setMinimum(1);
slider_qmin->setMaximum(31);
- slider_qmin->setValue(using_flags->get_config_ptr()->video_mpeg4_minq);
+ slider_qmin->setValue(config.video_mpeg4_minq);
label_qmin_val = new QLabel(this);
- tmps.setNum(using_flags->get_config_ptr()->video_mpeg4_minq);
+ tmps.setNum(config.video_mpeg4_minq);
label_qmin_val->setText(tmps);
label_qmin_name = new QLabel(QString::fromUtf8("QP Min"), this);
- video_minq = using_flags->get_config_ptr()->video_mpeg4_minq;
+ video_minq = config.video_mpeg4_minq;
connect(slider_qmin, SIGNAL(valueChanged(int)), this, SLOT(do_set_qmin(int)));
slider_qmax = new QSlider(Qt::Horizontal, this);
slider_qmax->setMinimum(1);
slider_qmax->setMaximum(31);
- slider_qmax->setValue(using_flags->get_config_ptr()->video_mpeg4_maxq);
+ slider_qmax->setValue(config.video_mpeg4_maxq);
label_qmax_val = new QLabel(this);
- tmps.setNum(using_flags->get_config_ptr()->video_mpeg4_maxq);
+ tmps.setNum(config.video_mpeg4_maxq);
label_qmax_val->setText(tmps);
label_qmax_name = new QLabel(QString::fromUtf8("QP Max"), this);
connect(slider_qmax, SIGNAL(valueChanged(int)), this, SLOT(do_set_qmax(int)));
- video_maxq = using_flags->get_config_ptr()->video_mpeg4_maxq;
+ video_maxq = config.video_mpeg4_maxq;
label_title = new QLabel(QApplication::translate("MovieTabMPEG4", "Set MPEG4v1 parameter.", 0), this);
grid_layout = new QGridLayout(this);
QString value;
// See:
// https://libav.org/avconv.html#Video-Options
- using_flags->get_config_ptr()->video_mpeg4_bitrate = video_bitrate;
+ config.video_mpeg4_bitrate = video_bitrate;
- using_flags->get_config_ptr()->video_mpeg4_maxq = video_maxq;
- using_flags->get_config_ptr()->video_mpeg4_minq = video_minq;
- using_flags->get_config_ptr()->video_mpeg4_bframes = video_bframes;
+ config.video_mpeg4_maxq = video_maxq;
+ config.video_mpeg4_minq = video_minq;
+ config.video_mpeg4_bframes = video_bframes;
}
void CSP_TabMovieMPEG4::do_set_qmin(int n)
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_binary_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_binary_path[drv], listBINs[drv]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ s_path = QString::fromLocal8Bit(config.recent_binary_path[drv][num]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_binary_path[drv], listBINs[drv]);
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
- strcpy(using_flags->get_config_ptr()->initial_binary_dir, get_parent_dir(path_shadow));
- //strncpy(path_shadow, s_path.toUtf8().constData(), PATH_MAX);
+ strcpy(config.initial_binary_dir, get_parent_dir(path_shadow));
+ //strncpy(path_shadow, s_path.toUtf8().constData(), PATH_MAX - 1);
emit sig_load_binary(drv, s_path);
menu_BINs[drv]->do_update_histories(listBINs[drv]);
- menu_BINs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_binary_dir);
+ menu_BINs[drv]->do_set_initialize_directory(config.initial_binary_dir);
return 0;
}
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_binary_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_binary_path[drv], listBINs[drv]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ s_path = QString::fromLocal8Bit(config.recent_binary_path[drv][num]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
- strcpy(using_flags->get_config_ptr()->initial_binary_dir, get_parent_dir(path_shadow));
- //strncpy(path_shadow, s_path.toUtf8().constData(), PATH_MAX);
+ UPDATE_HISTORY(path_shadow, config.recent_binary_path[drv], listBINs[drv]);
+
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+
+ strcpy(config.initial_binary_dir, get_parent_dir(path_shadow));
+ //strncpy(path_shadow, s_path.toUtf8().constData(), PATH_MAX - 1);
emit sig_save_binary(drv, s_path);
menu_BINs[drv]->do_update_histories(listBINs[drv]);
- menu_BINs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_binary_dir);
+ menu_BINs[drv]->do_set_initialize_directory(config.initial_binary_dir);
return 0;
}
if(fname.length() <= 0) return;
drv = drv & 7;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_binary_path[drv], listBINs[drv]);
- strcpy(using_flags->get_config_ptr()->initial_binary_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_binary_path[drv], listBINs[drv]);
+ strcpy(config.initial_binary_dir, get_parent_dir(path_shadow));
// Update List
emit sig_load_binary(drv, fname);
menu_BINs[drv]->do_update_histories(listBINs[drv]);
- menu_BINs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_binary_dir);
+ menu_BINs[drv]->do_set_initialize_directory(config.initial_binary_dir);
}
void Ui_MainWindowBase::_open_binary_save(int drv, const QString fname)
if(fname.length() <= 0) return;
drv = drv & 7;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_binary_path[drv], listBINs[drv]);
- strcpy(using_flags->get_config_ptr()->initial_binary_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_binary_path[drv], listBINs[drv]);
+ strcpy(config.initial_binary_dir, get_parent_dir(path_shadow));
// Update List
emit sig_save_binary(drv, fname);
menu_BINs[drv]->do_update_histories(listBINs[drv]);
- menu_BINs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_binary_dir);
+ menu_BINs[drv]->do_set_initialize_directory(config.initial_binary_dir);
}
menu_BINs[drv]->do_clear_inner_media();
menu_BINs[drv]->do_add_media_extension(ext, desc1);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_binary_path[drv], listBINs[drv]);
+ SETUP_HISTORY(config.recent_binary_path[drv], listBINs[drv]);
menu_BINs[drv]->do_update_histories(listBINs[drv]);
- menu_BINs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_binary_dir);
+ menu_BINs[drv]->do_set_initialize_directory(config.initial_binary_dir);
listBINs[drv].clear();
QString name = QString::fromUtf8("Binary");
menu_bubbles[drv]->do_clear_inner_media();
menu_bubbles[drv]->do_add_media_extension(ext, desc1);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_bubble_casette_path[drv], listBubbles[drv]);
+ SETUP_HISTORY(config.recent_bubble_casette_path[drv], listBubbles[drv]);
menu_bubbles[drv]->do_update_histories(listBubbles[drv]);
- menu_bubbles[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_bubble_casette_dir);
+ menu_bubbles[drv]->do_set_initialize_directory(config.initial_bubble_casette_dir);
listB77[drv].clear();
QString name = QString::fromUtf8("BUBBLE");
char path_shadow[PATH_MAX];
if(fname.length() <= 0) return;
- strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_cart_path[drv], listCARTs[drv]);
- strcpy(using_flags->get_config_ptr()->initial_cart_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_cart_path[drv], listCARTs[drv]);
+ strcpy(config.initial_cart_dir, get_parent_dir(path_shadow));
menu_Cart[drv]->do_update_histories(listCARTs[drv]);
- menu_Cart[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_cart_dir);
+ menu_Cart[drv]->do_set_initialize_directory(config.initial_cart_dir);
emit sig_close_cart(drv);
emit sig_open_cart(drv, fname);
if((num < 0) || (num >= MAX_HISTORY)) return;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_cart_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_cart_path[drv], listCARTs[drv]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ s_path = QString::fromLocal8Bit(config.recent_cart_path[drv][num]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_cart_path[drv], listCARTs[drv]);
+
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
- strcpy(using_flags->get_config_ptr()->initial_cart_dir, get_parent_dir(path_shadow));
+ strcpy(config.initial_cart_dir, get_parent_dir(path_shadow));
menu_Cart[drv]->do_update_histories(listCARTs[drv]);
- menu_Cart[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_cart_dir);
+ menu_Cart[drv]->do_set_initialize_directory(config.initial_cart_dir);
//eject_cart(drv);
emit sig_open_cart(drv, s_path);
menu_Cart[drv]->do_clear_inner_media();
menu_Cart[drv]->do_add_media_extension(ext, desc);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_cart_path[drv], listCARTs[drv]);
+ SETUP_HISTORY(config.recent_cart_path[drv], listCARTs[drv]);
menu_Cart[drv]->do_update_histories(listCARTs[drv]);
- menu_Cart[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_cart_dir);
+ menu_Cart[drv]->do_set_initialize_directory(config.initial_cart_dir);
QString name = QString::fromUtf8("Cart");
QString tmpv;
menu_CDROM[drv]->create_pulldown_menu();
// Translate Menu
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_compact_disc_path[drv], listCDROM[drv]);
+ SETUP_HISTORY(config.recent_compact_disc_path[drv], listCDROM[drv]);
menu_CDROM[drv]->do_update_histories(listCDROM[drv]);
- menu_CDROM[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_compact_disc_dir);
+ menu_CDROM[drv]->do_set_initialize_directory(config.initial_compact_disc_dir);
ext_play = "*.ccd *.cue *.gz";
desc_play = "Compact Disc";
char path_shadow[PATH_MAX];
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_compact_disc_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_compact_disc_path[drv], listCDROM[drv]);
+ s_path = QString::fromLocal8Bit(config.recent_compact_disc_path[drv][num]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_compact_disc_path[drv], listCDROM[drv]);
- strcpy(using_flags->get_config_ptr()->initial_compact_disc_dir, get_parent_dir(path_shadow));
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strcpy(config.initial_compact_disc_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_cdrom(drv);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_COMPACTDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_cdrom(drv, s_path);
menu_CDROM[drv]->do_update_histories(listCDROM[drv]);
- menu_CDROM[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_compact_disc_dir);
+ menu_CDROM[drv]->do_set_initialize_directory(config.initial_compact_disc_dir);
return 0;
}
{
char path_shadow[PATH_MAX];
if(path.length() <= 0) return;
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_compact_disc_path[drv], listCDROM[drv]);
- strcpy(using_flags->get_config_ptr()->initial_compact_disc_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_compact_disc_path[drv], listCDROM[drv]);
+ strcpy(config.initial_compact_disc_dir, get_parent_dir(path_shadow));
// Copy filename again.
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_cdrom(drv);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_COMPACTDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_cdrom(drv, path);
menu_CDROM[drv]->do_update_histories(listCDROM[drv]);
- menu_CDROM[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_compact_disc_dir);
+ menu_CDROM[drv]->do_set_initialize_directory(config.initial_compact_disc_dir);
}
void Ui_MainWindowBase::retranslateCDROMMenu(void)
menu_CMT[drive]->create_pulldown_menu();
// Translate Menu
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_tape_path[drive], listCMT[drive]);
+ SETUP_HISTORY(config.recent_tape_path[drive], listCMT[drive]);
menu_CMT[drive]->do_set_write_protect(false);
menu_CMT[drive]->do_update_histories(listCMT[drive]);
- menu_CMT[drive]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_tape_dir);
+ menu_CMT[drive]->do_set_initialize_directory(config.initial_tape_dir);
if(using_flags->is_machine_pc6001()) {
ext_play = "*.wav *.p6 *.cas *.gz";
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_tape_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_tape_path[drv], listCMT[drv]);
+ s_path = QString::fromLocal8Bit(config.recent_tape_path[drv][num]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_tape_path[drv], listCMT[drv]);
- strcpy(using_flags->get_config_ptr()->initial_tape_dir, get_parent_dir(path_shadow));
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strcpy(config.initial_tape_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_VFILE_CMT + 0, "Open READ (from history) : filename = %s", s_path.toLocal8Bit().constData());
emit sig_close_tape(drv);
emit sig_play_tape(drv, s_path);
menu_CMT[drv]->do_update_histories(listCMT[drv]);
- menu_CMT[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_tape_dir);
+ menu_CMT[drv]->do_set_initialize_directory(config.initial_tape_dir);
return 0;
}
void Ui_MainWindowBase::set_wave_shaper(int drive, bool f)
{
if(f) {
- using_flags->get_config_ptr()->wave_shaper[drive] = 1;
+ config.wave_shaper[drive] = 1;
} else {
- using_flags->get_config_ptr()->wave_shaper[drive] = 0;
+ config.wave_shaper[drive] = 0;
}
}
bool Ui_MainWindowBase::get_wave_shaper(int drive)
{
- if(using_flags->get_config_ptr()->wave_shaper[drive] == 0) return false;
+ if(config.wave_shaper[drive] == 0) return false;
return true;
}
void Ui_MainWindowBase::set_direct_load_from_mzt(int drive, bool f)
{
if(f) {
- using_flags->get_config_ptr()->direct_load_mzt[drive] = 1;
+ config.direct_load_mzt[drive] = 1;
} else {
- using_flags->get_config_ptr()->direct_load_mzt[drive] = 0;
+ config.direct_load_mzt[drive] = 0;
}
}
bool Ui_MainWindowBase::get_direct_load_mzt(int drive)
{
- if(using_flags->get_config_ptr()->direct_load_mzt[drive] == 0) return false;
+ if(config.direct_load_mzt[drive] == 0) return false;
return true;
}
char path_shadow[PATH_MAX];
if(path.length() <= 0) return;
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_tape_path[drive], listCMT[drive]);
- strcpy(using_flags->get_config_ptr()->initial_tape_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_tape_path[drive], listCMT[drive]);
+ strcpy(config.initial_tape_dir, get_parent_dir(path_shadow));
// Copy filename again.
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_tape(drive);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_CMT + 0, "Open READ : filename = %s", path_shadow);
emit sig_play_tape(drive, path);
menu_CMT[drive]->do_update_histories(listCMT[drive]);
- menu_CMT[drive]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_tape_dir);
+ menu_CMT[drive]->do_set_initialize_directory(config.initial_tape_dir);
}
void Ui_MainWindowBase::do_open_write_cmt(int drive, QString path)
char path_shadow[PATH_MAX];
if(path.length() <= 0) return;
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_tape_path[drive], listCMT[drive]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_tape_path[drive], listCMT[drive]);
get_parent_dir(path_shadow);
- strcpy(using_flags->get_config_ptr()->initial_tape_dir, get_parent_dir(path_shadow));
+ strcpy(config.initial_tape_dir, get_parent_dir(path_shadow));
// Copy filename again.
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_tape(drive);
if(menu_CMT[drive]->getWriteProtect() != false) {
emit sig_rec_tape(drive, path);
}
menu_CMT[drive]->do_update_histories(listCMT[drive]);
- menu_CMT[drive]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_tape_dir);
+ menu_CMT[drive]->do_set_initialize_directory(config.initial_tape_dir);
}
void Object_Menu_Control::do_set_ignore_crc_error(bool flag)
{
- using_flags->get_config_ptr()->ignore_disk_crc[drive] = flag;
+ config.ignore_disk_crc[drive] = flag;
emit sig_emu_update_config();
}
void Object_Menu_Control::do_set_correct_disk_timing(bool flag)
{
- using_flags->get_config_ptr()->correct_disk_timing[drive] = flag;
+ config.correct_disk_timing[drive] = flag;
emit sig_emu_update_config();
}
void Object_Menu_Control::do_set_disk_count_immediate(bool flag)
{
- using_flags->get_config_ptr()->disk_count_immediate[drive] = flag;
+ config.disk_count_immediate[drive] = flag;
emit sig_emu_update_config();
}
menu_fds[drv]->do_clear_inner_media();
menu_fds[drv]->do_add_media_extension(ext, desc1);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_floppy_disk_path[drv], listFDs[drv]);
+ SETUP_HISTORY(config.recent_floppy_disk_path[drv], listFDs[drv]);
menu_fds[drv]->do_update_histories(listFDs[drv]);
- menu_fds[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_floppy_disk_dir);
+ menu_fds[drv]->do_set_initialize_directory(config.initial_floppy_disk_dir);
listD88[drv].clear();
}
}
menu_hdds[drv]->do_clear_inner_media();
menu_hdds[drv]->do_add_media_extension(ext, desc1);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_hard_disk_path[drv], listHDDs[drv]);
+ SETUP_HISTORY(config.recent_hard_disk_path[drv], listHDDs[drv]);
menu_hdds[drv]->do_update_histories(listHDDs[drv]);
- menu_hdds[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_hard_disk_dir);
+ menu_hdds[drv]->do_set_initialize_directory(config.initial_hard_disk_dir);
}
}
menu_Laserdisc[drv]->create_pulldown_menu();
// Translate Menu
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_laser_disc_path[drv], listLaserdisc[drv]);
+ SETUP_HISTORY(config.recent_laser_disc_path[drv], listLaserdisc[drv]);
menu_Laserdisc[drv]->do_update_histories(listLaserdisc[drv]);
- menu_Laserdisc[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_laser_disc_dir);
+ menu_Laserdisc[drv]->do_set_initialize_directory(config.initial_laser_disc_dir);
ext_play = "*.ogv *.mp4 *.avi *.mkv";
desc_play = "Laserisc";
char path_shadow[PATH_MAX];
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_laser_disc_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_laser_disc_path[drv], listLaserdisc[drv]);
+ s_path = QString::fromLocal8Bit(config.recent_laser_disc_path[drv][num]);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_laser_disc_path[drv], listLaserdisc[drv]);
- strcpy(using_flags->get_config_ptr()->initial_laser_disc_dir, get_parent_dir(path_shadow));
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX);
+ strcpy(config.initial_laser_disc_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_laserdisc(drv);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_LASERDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_laserdisc(drv, s_path);
menu_Laserdisc[drv]->do_update_histories(listLaserdisc[drv]);
- menu_Laserdisc[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_laser_disc_dir);
+ menu_Laserdisc[drv]->do_set_initialize_directory(config.initial_laser_disc_dir);
return 0;
}
char path_shadow[PATH_MAX];
if(path.length() <= 0) return;
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_laser_disc_path[drv], listLaserdisc[drv]);
- strcpy(using_flags->get_config_ptr()->initial_laser_disc_dir, get_parent_dir(path_shadow));
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_laser_disc_path[drv], listLaserdisc[drv]);
+ strcpy(config.initial_laser_disc_dir, get_parent_dir(path_shadow));
// Copy filename again.
- strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX);
+ memset(path_shadow, 0x00, PATH_MAX * sizeof(char));
+ strncpy(path_shadow, path.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_laserdisc(drv);
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_VFILE_LASERDISC + 0, "Open : filename = %s", path_shadow);
emit sig_open_laserdisc(drv, path);
menu_Laserdisc[drv]->do_update_histories(listLaserdisc[drv]);
- menu_Laserdisc[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_laser_disc_dir);
+ menu_Laserdisc[drv]->do_set_initialize_directory(config.initial_laser_disc_dir);
}
void Ui_MainWindowBase::retranslateLaserdiscMenu(void)
desc2 = desc1 + " (" + ext.toLower() + " " + ext.toUpper() + ")";
//desc2 = desc1 + " (" + ext.toLower() + ")";
//desc1 = desc1 + " (" + ext.toUpper() + ")";
- if(using_flags->get_config_ptr()->initial_quick_disk_dir != NULL) {
- dirname = using_flags->get_config_ptr()->initial_quick_disk_dir;
+ if(config.initial_quick_disk_dir != NULL) {
+ dirname = config.initial_quick_disk_dir;
} else {
char app[_MAX_PATH];
QDir df;
dirname = df.currentPath();
- strncpy(app, dirname.toLocal8Bit().constData(), _MAX_PATH);
+ memset(app, 0x00, _MAX_PATH * sizeof(char));
+ strncpy(app, dirname.toLocal8Bit().constData(), _MAX_PATH - 1);
dirname = get_parent_dir(app);
}
QStringList filter;
QString s_path;
char path_shadow[_MAX_PATH];
if((num < 0) || (num >= MAX_HISTORY)) return -1;
- s_path = QString::fromLocal8Bit(using_flags->get_config_ptr()->recent_quick_disk_path[drv][num]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), _MAX_PATH);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_quick_disk_path[drv], listQDs[drv]);
+ s_path = QString::fromLocal8Bit(config.recent_quick_disk_path[drv][num]);
+ memset(path_shadow, 0x00, _MAX_PATH * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), _MAX_PATH - 1);
+ UPDATE_HISTORY(path_shadow, config.recent_quick_disk_path[drv], listQDs[drv]);
- strncpy(path_shadow, s_path.toLocal8Bit().constData(), _MAX_PATH);
- strncpy(using_flags->get_config_ptr()->initial_quick_disk_dir, get_parent_dir(path_shadow), _MAX_PATH);
+ memset(path_shadow, 0x00, _MAX_PATH * sizeof(char));
+ strncpy(path_shadow, s_path.toLocal8Bit().constData(), _MAX_PATH - 1);
+ strncpy(config.initial_quick_disk_dir, get_parent_dir(path_shadow), _MAX_PATH - 1);
emit sig_close_quickdisk(drv);
emit sig_open_quickdisk(drv, s_path);
menu_QDs[drv]->do_update_histories(listQDs[drv]);
- menu_QDs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_quick_disk_dir);
+ menu_QDs[drv]->do_set_initialize_directory(config.initial_quick_disk_dir);
//if(emu->get_quickdisk_protected(drv)) {
// menu_QDs[drv]->do_write_protect_media();
//} else {
QString s_name = fname;
if(fname.length() <= 0) return;
- strncpy(path_shadow, s_name.toLocal8Bit().constData(), _MAX_PATH);
+ memset(path_shadow, 0x00, _MAX_PATH * sizeof(char));
+ strncpy(path_shadow, s_name.toLocal8Bit().constData(), _MAX_PATH - 1);
- UPDATE_HISTORY(path_shadow, using_flags->get_config_ptr()->recent_quick_disk_path[drv], listQDs[drv]);
-
- strncpy(path_shadow, s_name.toLocal8Bit().constData(), _MAX_PATH);
- strncpy(using_flags->get_config_ptr()->initial_quick_disk_dir, get_parent_dir(path_shadow), _MAX_PATH);
+ UPDATE_HISTORY(path_shadow, config.recent_quick_disk_path[drv], listQDs[drv]);
+
+ memset(path_shadow, 0x00, _MAX_PATH * sizeof(char));
+ strncpy(path_shadow, s_name.toLocal8Bit().constData(), _MAX_PATH - 1);
+ strncpy(config.initial_quick_disk_dir, get_parent_dir(path_shadow), _MAX_PATH - 1);
emit sig_close_quickdisk(drv);
emit sig_open_quickdisk(drv, s_name);
menu_QDs[drv]->do_update_histories(listQDs[drv]);
- menu_QDs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_quick_disk_dir);
+ menu_QDs[drv]->do_set_initialize_directory(config.initial_quick_disk_dir);
//if(emu->get_quickdisk_protected(drv)) {
// menu_QDs[drv]->do_write_protect_media();
//} else {
menu_QDs[drv]->do_clear_inner_media();
menu_QDs[drv]->do_add_media_extension(ext, desc1);
- SETUP_HISTORY(using_flags->get_config_ptr()->recent_quick_disk_path[drv], listQDs[drv]);
+ SETUP_HISTORY(config.recent_quick_disk_path[drv], listQDs[drv]);
menu_QDs[drv]->do_update_histories(listQDs[drv]);
- menu_QDs[drv]->do_set_initialize_directory(using_flags->get_config_ptr()->initial_quick_disk_dir);
+ menu_QDs[drv]->do_set_initialize_directory(config.initial_quick_disk_dir);
}
}
#include "qt_gldraw.h"
#include "osd.h"
+#include "config.h"
OSD::OSD(USING_FLAGS *p, CSP_Logger *logger) : OSD_BASE(p, logger)
{
- p_config = using_flags->get_config_ptr();
+ //p_config = using_flags->get_config_ptr();
+ p_config = &config;
set_features();
}
tmp_path = tmp_path + QString::fromStdString(my_procname);
tmp_path = tmp_path + QString::fromUtf8(delim);
memset(app_path, 0x00, sizeof(app_path));
- strncpy(app_path, tmp_path.toUtf8().constData(), _MAX_PATH);
+ strncpy(app_path, tmp_path.toUtf8().constData(), _MAX_PATH - 1);
console_cmd_str.clear();
osd_console_opened = false;
if((jsnum < 0) || (jsnum >= 4)) return;
if((axis_idx < 0) || (axis_idx >= 16)) return;
if((assigned_value < -256) || (assigned_value >= 0x10000)) return;
- p_config->joy_buttons[jsnum][axis_idx] = assigned_value;
+ config.joy_buttons[jsnum][axis_idx] = assigned_value;
}
void OSD_BASE::update_input()
{
if((code >= 256) || (code < 0)) return; // WORKAROUND
//#ifdef USE_AUTO_KEY
- if(!__USE_AUTO_KEY || (!now_auto_key && !p_config->romaji_to_kana)) {
+ if(!__USE_AUTO_KEY || (!now_auto_key && !config.romaji_to_kana)) {
//#endif
//csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_OSD, "KEY DOWN %d", code);
//if(!dinput_key_available) {
}
}
- switch(p_config->cursor_as_ten_key) {
+ switch(config.cursor_as_ten_key) {
case CONFIG_CURSOR_AS_2468:
if(code == VK_RIGHT) {
code = VK_NUMPAD6;
{
if((code >= 256) || (code < 0)) return; // WORKAROUND
//#ifdef USE_AUTO_KEY
- if(!__USE_AUTO_KEY || (!now_auto_key && !p_config->romaji_to_kana)) {
+ if(!__USE_AUTO_KEY || (!now_auto_key && !config.romaji_to_kana)) {
//#endif
//csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_OSD, "KEY UP %d", code);
//if(!dinput_key_available) {
return;
}
}
- switch(p_config->cursor_as_ten_key) {
+ switch(config.cursor_as_ten_key) {
case CONFIG_CURSOR_AS_2468:
if(code == VK_RIGHT) {
code = VK_NUMPAD6;
snddata.snd_total_volume = &snd_total_volume;
snddata.sound_exit = &sound_exit;
snddata.sound_debug = &sound_debug;
- snddata.p_config = p_config;
+ snddata.p_config = &config;
snd_spec_req.format = AUDIO_S16SYS;
snd_spec_req.channels = 2;
tmps = tmps + QString::fromUtf8("_");
tmps = tmps + nowTime.toString(QString::fromUtf8("yyyy-MM-dd_hh-mm-ss.zzz"));
tmps = tmps + QString::fromUtf8(".wav");
- strncpy((char *)sound_file_name, tmps.toLocal8Bit().constData(), sizeof(sound_file_name));
+ strncpy((char *)sound_file_name, tmps.toLocal8Bit().constData(), sizeof(sound_file_name) - 1);
// create wave file
rec_sound_fio = new FILEIO();
if(rec_sound_fio->Fopen(bios_path(sound_file_name), FILEIO_WRITE_BINARY)) {
int OSD::get_window_mode_width(int mode)
{
if(get_use_screen_rotate()) {
- if(p_config->rotate_type == 1 || p_config->rotate_type == 3) {
- return (p_config->window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
+ if(config.rotate_type == 1 || config.rotate_type == 3) {
+ return (config.window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
}
}
- return (p_config->window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
+ return (config.window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
}
int OSD::get_window_mode_height(int mode)
{
if(get_use_screen_rotate()) {
- if(p_config->rotate_type == 1 || p_config->rotate_type == 3) {
- return (p_config->window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
+ if(config.rotate_type == 1 || config.rotate_type == 3) {
+ return (config.window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
}
}
- return (p_config->window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
+ return (config.window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
}
void OSD::initialize_video()
message("* vm/common_vm")
-SET(THIS_LIB_VERSION 1.3.0)
+SET(THIS_LIB_VERSION 1.3.1)
#include(cotire)
set(s_vm_common_vm_srcs
OSDN Git Service
