931 lines
25 KiB
C++
931 lines
25 KiB
C++
/* FCE Ultra - NES/Famicom Emulator
|
|
*
|
|
* Copyright notice for this file:
|
|
* Copyright (C) 2020 mjbudd77
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
// ConsoleVideoConf.cpp
|
|
//
|
|
#include <QCloseEvent>
|
|
|
|
#include "../../fceu.h"
|
|
#include "Qt/main.h"
|
|
#include "Qt/dface.h"
|
|
#include "Qt/config.h"
|
|
#include "Qt/fceuWrapper.h"
|
|
#include "Qt/ConsoleWindow.h"
|
|
#include "Qt/ConsoleUtilities.h"
|
|
#include "Qt/ConsoleVideoConf.h"
|
|
#include "Qt/nes_shm.h"
|
|
|
|
//----------------------------------------------------
|
|
ConsoleVideoConfDialog_t::ConsoleVideoConfDialog_t(QWidget *parent)
|
|
: QDialog( parent )
|
|
{
|
|
QVBoxLayout *main_vbox, *vbox1, *vbox2;
|
|
QHBoxLayout *main_hbox, *hbox1;
|
|
QLabel *lbl;
|
|
QPushButton *button;
|
|
QStyle *style;
|
|
QGroupBox *gbox;
|
|
QGridLayout *grid;
|
|
fceuDecIntValidtor *validator;
|
|
QFont font;
|
|
int opt, fontCharWidth;
|
|
char stmp[128];
|
|
|
|
font.setFamily("Courier New");
|
|
font.setStyle( QFont::StyleNormal );
|
|
font.setStyleHint( QFont::Monospace );
|
|
QFontMetrics fm(font);
|
|
|
|
#if QT_VERSION > QT_VERSION_CHECK(5, 11, 0)
|
|
fontCharWidth = fm.horizontalAdvance(QLatin1Char('2'));
|
|
#else
|
|
fontCharWidth = fm.width(QLatin1Char('2'));
|
|
#endif
|
|
|
|
style = this->style();
|
|
|
|
setWindowTitle( tr("Video Config") );
|
|
|
|
main_vbox = new QVBoxLayout();
|
|
main_hbox = new QHBoxLayout();
|
|
vbox1 = new QVBoxLayout();
|
|
|
|
main_vbox->addLayout( main_hbox );
|
|
main_hbox->addLayout( vbox1 );
|
|
|
|
// Video Driver Select
|
|
lbl = new QLabel( tr("Driver:") );
|
|
|
|
driverSelect = new QComboBox();
|
|
|
|
driverSelect->addItem( tr("OpenGL"), 0 );
|
|
driverSelect->addItem( tr("SDL"), 1 );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
|
|
hbox1->addWidget( lbl );
|
|
hbox1->addWidget( driverSelect );
|
|
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
// Video Driver Select
|
|
lbl = new QLabel( tr("Scaler:") );
|
|
|
|
scalerSelect = new QComboBox();
|
|
|
|
scalerSelect->addItem( tr("None"), 0 );
|
|
scalerSelect->addItem( tr("hq2x"), 1 );
|
|
scalerSelect->addItem( tr("scale2x"), 2 );
|
|
scalerSelect->addItem( tr("NTSC 2x"), 3 );
|
|
scalerSelect->addItem( tr("hq3x"), 4 );
|
|
scalerSelect->addItem( tr("scale3x"), 5 );
|
|
scalerSelect->addItem( tr("Prescale 2x"), 6 );
|
|
scalerSelect->addItem( tr("Prescale 3x"), 7 );
|
|
scalerSelect->addItem( tr("Prescale 4x"), 8 );
|
|
scalerSelect->addItem( tr("PAL"), 9 );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
|
|
hbox1->addWidget( lbl );
|
|
hbox1->addWidget( scalerSelect );
|
|
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
// Enable OpenGL Linear Filter Checkbox
|
|
gl_LF_chkBox = new QCheckBox( tr("Enable OpenGL Linear Filter") );
|
|
|
|
setCheckBoxFromProperty( gl_LF_chkBox , "SDL.OpenGLip");
|
|
|
|
connect(gl_LF_chkBox , SIGNAL(stateChanged(int)), this, SLOT(openGL_linearFilterChanged(int)) );
|
|
|
|
vbox1->addWidget( gl_LF_chkBox );
|
|
|
|
// Region Select
|
|
lbl = new QLabel( tr("Region:") );
|
|
|
|
regionSelect = new QComboBox();
|
|
|
|
regionSelect->addItem( tr("NTSC") , 0 );
|
|
regionSelect->addItem( tr("PAL") , 1 );
|
|
regionSelect->addItem( tr("Dendy"), 2 );
|
|
|
|
setComboBoxFromProperty( regionSelect, "SDL.PAL");
|
|
setComboBoxFromProperty( driverSelect, "SDL.VideoDriver");
|
|
setComboBoxFromProperty( scalerSelect, "SDL.SpecialFilter");
|
|
|
|
connect(regionSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(regionChanged(int)) );
|
|
connect(driverSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(driverChanged(int)) );
|
|
connect(scalerSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(scalerChanged(int)) );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
|
|
hbox1->addWidget( lbl );
|
|
hbox1->addWidget( regionSelect );
|
|
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
// Enable Region Auto Detection Logic
|
|
autoRegion = new QCheckBox( tr("Region Auto Detect") );
|
|
|
|
// Enable New PPU Checkbox
|
|
new_PPU_ena = new QCheckBox( tr("Enable New PPU") );
|
|
|
|
// Enable New PPU Checkbox
|
|
frmskipcbx = new QCheckBox( tr("Enable Frameskip") );
|
|
|
|
// Disable Sprite Limit Checkbox
|
|
sprtLimCbx = new QCheckBox( tr("Disable Sprite Limit") );
|
|
|
|
// Clip Sides Checkbox
|
|
clipSidesCbx = new QCheckBox( tr("Clip Left/Right Sides (8 px on each)") );
|
|
|
|
// Show FPS Checkbox
|
|
showFPS_cbx = new QCheckBox( tr("Show FPS") );
|
|
|
|
// Auto Scale on Resize
|
|
autoScaleCbx = new QCheckBox( tr("Auto Scale on Resize") );
|
|
|
|
// Force Aspect Ratio
|
|
aspectCbx = new QCheckBox( tr("Force Aspect Ratio") );
|
|
|
|
setCheckBoxFromProperty( autoRegion , "SDL.AutoDetectPAL");
|
|
setCheckBoxFromProperty( new_PPU_ena , "SDL.NewPPU");
|
|
setCheckBoxFromProperty( frmskipcbx , "SDL.Frameskip");
|
|
setCheckBoxFromProperty( sprtLimCbx , "SDL.DisableSpriteLimit");
|
|
setCheckBoxFromProperty( clipSidesCbx , "SDL.ClipSides");
|
|
setCheckBoxFromProperty( showFPS_cbx , "SDL.ShowFPS");
|
|
|
|
if ( consoleWindow )
|
|
{
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
autoScaleCbx->setChecked( consoleWindow->viewport_GL->getAutoScaleOpt() );
|
|
aspectCbx->setChecked( consoleWindow->viewport_GL->getForceAspectOpt() );
|
|
}
|
|
else if ( consoleWindow->viewport_SDL )
|
|
{
|
|
autoScaleCbx->setChecked( consoleWindow->viewport_SDL->getAutoScaleOpt() );
|
|
aspectCbx->setChecked( consoleWindow->viewport_SDL->getForceAspectOpt() );
|
|
}
|
|
}
|
|
|
|
connect(autoRegion , SIGNAL(stateChanged(int)), this, SLOT(autoRegionChanged(int)) );
|
|
connect(new_PPU_ena , SIGNAL(stateChanged(int)), this, SLOT(use_new_PPU_changed(int)) );
|
|
connect(frmskipcbx , SIGNAL(stateChanged(int)), this, SLOT(frameskip_changed(int)) );
|
|
connect(sprtLimCbx , SIGNAL(stateChanged(int)), this, SLOT(useSpriteLimitChanged(int)) );
|
|
connect(clipSidesCbx, SIGNAL(stateChanged(int)), this, SLOT(clipSidesChanged(int)) );
|
|
connect(showFPS_cbx , SIGNAL(stateChanged(int)), this, SLOT(showFPSChanged(int)) );
|
|
connect(aspectCbx , SIGNAL(stateChanged(int)), this, SLOT(aspectEnableChanged(int)) );
|
|
connect(autoScaleCbx, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)) );
|
|
|
|
vbox1->addWidget( autoRegion );
|
|
vbox1->addWidget( new_PPU_ena );
|
|
vbox1->addWidget( frmskipcbx );
|
|
vbox1->addWidget( sprtLimCbx );
|
|
//vbox1->addWidget( clipSidesCbx);
|
|
vbox1->addWidget( showFPS_cbx );
|
|
vbox1->addWidget( autoScaleCbx);
|
|
vbox1->addWidget( aspectCbx );
|
|
|
|
aspectSelect = new QComboBox();
|
|
|
|
aspectSelect->addItem( tr("Default (1:1)"), 0 );
|
|
aspectSelect->addItem( tr("NTSC (8:7)"), 1 );
|
|
aspectSelect->addItem( tr("PAL (11:8)"), 2 );
|
|
aspectSelect->addItem( tr("Standard (4:3)"), 3 );
|
|
aspectSelect->addItem( tr("Widescreen (16:9)"), 4 );
|
|
//aspectSelect->addItem( tr("Custom"), 5 ); TODO
|
|
|
|
setComboBoxFromProperty( aspectSelect, "SDL.AspectSelect");
|
|
|
|
connect(aspectSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(aspectChanged(int)) );
|
|
|
|
aspectSelectLabel = new QLabel( tr("Aspect:") );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
hbox1->addWidget( aspectSelectLabel );
|
|
hbox1->addWidget( aspectSelect );
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
xScaleBox = new QDoubleSpinBox(this);
|
|
yScaleBox = new QDoubleSpinBox(this);
|
|
|
|
xScaleBox->setRange( 1.0, 16.0 );
|
|
yScaleBox->setRange( 1.0, 16.0 );
|
|
|
|
xScaleBox->setSingleStep( 0.10 );
|
|
yScaleBox->setSingleStep( 0.10 );
|
|
|
|
if ( consoleWindow )
|
|
{
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
xScaleBox->setValue( consoleWindow->viewport_GL->getScaleX() );
|
|
yScaleBox->setValue( consoleWindow->viewport_GL->getScaleY() );
|
|
}
|
|
else if ( consoleWindow->viewport_SDL )
|
|
{
|
|
xScaleBox->setValue( consoleWindow->viewport_SDL->getScaleX() );
|
|
yScaleBox->setValue( consoleWindow->viewport_SDL->getScaleY() );
|
|
}
|
|
}
|
|
|
|
if ( aspectCbx->isChecked() )
|
|
{
|
|
xScaleLabel = new QLabel( tr("Scale:") );
|
|
}
|
|
else
|
|
{
|
|
xScaleLabel = new QLabel( tr("X Scale:") );
|
|
}
|
|
yScaleLabel = new QLabel( tr("Y Scale:") );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
hbox1->addWidget( xScaleLabel );
|
|
hbox1->addWidget( xScaleBox );
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
hbox1->addWidget( yScaleLabel );
|
|
hbox1->addWidget( yScaleBox );
|
|
vbox1->addLayout( hbox1 );
|
|
|
|
if ( aspectCbx->isChecked() )
|
|
{
|
|
yScaleLabel->hide();
|
|
yScaleBox->hide();
|
|
}
|
|
else
|
|
{
|
|
aspectSelectLabel->hide();
|
|
aspectSelect->hide();
|
|
}
|
|
|
|
hbox1 = new QHBoxLayout();
|
|
|
|
button = new QPushButton( tr("Apply") );
|
|
hbox1->addWidget( button );
|
|
connect(button, SIGNAL(clicked()), this, SLOT(applyChanges(void)) );
|
|
button->setIcon( style->standardIcon( QStyle::SP_DialogApplyButton ) );
|
|
|
|
button = new QPushButton( tr("Close") );
|
|
hbox1->addWidget( button );
|
|
button->setIcon( style->standardIcon( QStyle::SP_DialogCloseButton ) );
|
|
connect(button, SIGNAL(clicked()), this, SLOT(closeWindow(void)) );
|
|
|
|
main_vbox->addLayout( hbox1 );
|
|
|
|
gbox = new QGroupBox( tr("Drawing Area") );
|
|
vbox2 = new QVBoxLayout();
|
|
grid = new QGridLayout();
|
|
|
|
main_hbox->addLayout( vbox2 );
|
|
vbox2->addWidget( gbox, 1 );
|
|
gbox->setLayout(grid);
|
|
|
|
ntsc_start = new QLineEdit();
|
|
ntsc_end = new QLineEdit();
|
|
pal_start = new QLineEdit();
|
|
pal_end = new QLineEdit();
|
|
|
|
validator = new fceuDecIntValidtor( 0, 239, this );
|
|
ntsc_start->setFont( font );
|
|
ntsc_start->setMaxLength( 3 );
|
|
ntsc_start->setValidator( validator );
|
|
ntsc_start->setAlignment(Qt::AlignCenter);
|
|
ntsc_start->setMaximumWidth( 8 * fontCharWidth );
|
|
ntsc_start->setCursorPosition(0);
|
|
|
|
validator = new fceuDecIntValidtor( 0, 239, this );
|
|
ntsc_end->setFont( font );
|
|
ntsc_end->setMaxLength( 3 );
|
|
ntsc_end->setValidator( validator );
|
|
ntsc_end->setAlignment(Qt::AlignCenter);
|
|
ntsc_end->setMaximumWidth( 8 * fontCharWidth );
|
|
ntsc_end->setCursorPosition(0);
|
|
|
|
validator = new fceuDecIntValidtor( 0, 239, this );
|
|
pal_start->setFont( font );
|
|
pal_start->setMaxLength( 3 );
|
|
pal_start->setValidator( validator );
|
|
pal_start->setAlignment(Qt::AlignCenter);
|
|
pal_start->setMaximumWidth( 8 * fontCharWidth );
|
|
pal_start->setCursorPosition(0);
|
|
|
|
validator = new fceuDecIntValidtor( 0, 239, this );
|
|
pal_end->setFont( font );
|
|
pal_end->setMaxLength( 3 );
|
|
pal_end->setValidator( validator );
|
|
pal_end->setAlignment(Qt::AlignCenter);
|
|
pal_end->setMaximumWidth( 8 * fontCharWidth );
|
|
pal_end->setCursorPosition(0);
|
|
|
|
g_config->getOption("SDL.ScanLineStartNTSC", &opt);
|
|
sprintf( stmp, "%i", opt );
|
|
ntsc_start->setText( tr(stmp) );
|
|
|
|
g_config->getOption("SDL.ScanLineEndNTSC", &opt);
|
|
sprintf( stmp, "%i", opt );
|
|
ntsc_end->setText( tr(stmp) );
|
|
|
|
g_config->getOption("SDL.ScanLineStartPAL", &opt);
|
|
sprintf( stmp, "%i", opt );
|
|
pal_start->setText( tr(stmp) );
|
|
|
|
g_config->getOption("SDL.ScanLineEndPAL", &opt);
|
|
sprintf( stmp, "%i", opt );
|
|
pal_end->setText( tr(stmp) );
|
|
|
|
connect( ntsc_start, SIGNAL(textEdited(const QString &)), this, SLOT(ntscStartScanLineChanged(const QString &)));
|
|
connect( ntsc_end , SIGNAL(textEdited(const QString &)), this, SLOT(ntscEndScanLineChanged(const QString &)));
|
|
connect( pal_start , SIGNAL(textEdited(const QString &)), this, SLOT(palStartScanLineChanged(const QString &)));
|
|
connect( pal_end , SIGNAL(textEdited(const QString &)), this, SLOT(palEndScanLineChanged(const QString &)));
|
|
|
|
grid->addWidget( new QLabel( tr("NTSC") ) , 0, 1, Qt::AlignLeft);
|
|
grid->addWidget( new QLabel( tr("PAL/Dendy") ) , 0, 2, Qt::AlignLeft);
|
|
grid->addWidget( new QLabel( tr("First Line:") ), 1, 0, Qt::AlignLeft);
|
|
grid->addWidget( new QLabel( tr("Last Line:") ), 2, 0, Qt::AlignLeft);
|
|
grid->addWidget( ntsc_start, 1, 1, Qt::AlignLeft);
|
|
grid->addWidget( pal_start , 1, 2, Qt::AlignLeft);
|
|
grid->addWidget( ntsc_end , 2, 1, Qt::AlignLeft);
|
|
grid->addWidget( pal_end , 2, 2, Qt::AlignLeft);
|
|
grid->addWidget( clipSidesCbx, 3, 0, 1, 3);
|
|
|
|
gbox = new QGroupBox( tr("Current Dimensions") );
|
|
grid = new QGridLayout();
|
|
|
|
vbox2->addWidget( gbox, 1 );
|
|
gbox->setLayout(grid);
|
|
|
|
winSizeReadout = new QLineEdit();
|
|
winSizeReadout->setFont( font );
|
|
winSizeReadout->setReadOnly(true);
|
|
winSizeReadout->setAlignment(Qt::AlignCenter);
|
|
|
|
vpSizeReadout = new QLineEdit();
|
|
vpSizeReadout->setFont( font );
|
|
vpSizeReadout->setReadOnly(true);
|
|
vpSizeReadout->setAlignment(Qt::AlignCenter);
|
|
|
|
grid->addWidget( new QLabel( tr("Window:") ), 0, 0, Qt::AlignLeft);
|
|
grid->addWidget( new QLabel( tr("Viewport:") ), 1, 0, Qt::AlignLeft);
|
|
grid->addWidget( winSizeReadout, 0, 1, Qt::AlignLeft);
|
|
grid->addWidget( vpSizeReadout, 1, 1, Qt::AlignLeft);
|
|
|
|
gbox = new QGroupBox( tr("Viewport Cursor") );
|
|
grid = new QGridLayout();
|
|
cursorSelect = new QComboBox();
|
|
|
|
cursorSelect->addItem( tr("Arrow") , 0 );
|
|
cursorSelect->addItem( tr("Cross") , 1 );
|
|
cursorSelect->addItem( tr("Blank") , 2 );
|
|
cursorSelect->addItem( tr("Reticle 1x"), 3 );
|
|
cursorSelect->addItem( tr("Reticle 2x"), 4 );
|
|
|
|
setComboBoxFromProperty( cursorSelect, "SDL.CursorType" );
|
|
|
|
connect(cursorSelect, SIGNAL(currentIndexChanged(int)), this, SLOT(cursorShapeChanged(int)) );
|
|
|
|
vbox2->addWidget( gbox, 1 );
|
|
gbox->setLayout(grid);
|
|
|
|
grid->addWidget( new QLabel( tr("Shape:") ), 0, 0, Qt::AlignLeft);
|
|
grid->addWidget( cursorSelect, 0, 1, Qt::AlignLeft);
|
|
|
|
cursorVisCbx = new QCheckBox( tr("Visible") );
|
|
setCheckBoxFromProperty( cursorVisCbx, "SDL.CursorVis" );
|
|
grid->addWidget( cursorVisCbx, 1, 0, 2, 1, Qt::AlignLeft);
|
|
|
|
connect(cursorVisCbx, SIGNAL(stateChanged(int)), this, SLOT(cursorVisChanged(int)) );
|
|
|
|
vbox2->addStretch( 5 );
|
|
|
|
setLayout( main_vbox );
|
|
|
|
updateReadouts();
|
|
|
|
updateTimer = new QTimer( this );
|
|
|
|
connect( updateTimer, &QTimer::timeout, this, &ConsoleVideoConfDialog_t::periodicUpdate );
|
|
|
|
updateTimer->start( 500 ); // 2Hz
|
|
}
|
|
//----------------------------------------------------
|
|
ConsoleVideoConfDialog_t::~ConsoleVideoConfDialog_t(void)
|
|
{
|
|
printf("Destroy Video Config Window\n");
|
|
|
|
updateTimer->stop();
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::closeEvent(QCloseEvent *event)
|
|
{
|
|
printf("Video Config Close Window Event\n");
|
|
done(0);
|
|
deleteLater();
|
|
event->accept();
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::periodicUpdate(void)
|
|
{
|
|
int actRegion, selRegion;
|
|
|
|
// Keep region menu selection sync'd to actual state
|
|
actRegion = FCEUI_GetRegion();
|
|
selRegion = regionSelect->currentIndex();
|
|
|
|
if ( actRegion != selRegion )
|
|
{
|
|
regionSelect->setCurrentIndex(actRegion);
|
|
}
|
|
|
|
// Update Window Size Readouts
|
|
updateReadouts();
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::closeWindow(void)
|
|
{
|
|
//printf("Video Config Close Window\n");
|
|
done(0);
|
|
deleteLater();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::resetVideo(void)
|
|
{
|
|
fceuWrapperLock();
|
|
KillVideo ();
|
|
InitVideo (GameInfo);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::updateReadouts(void)
|
|
{
|
|
if ( consoleWindow )
|
|
{
|
|
QSize w, v;
|
|
char stmp[128];
|
|
|
|
w = consoleWindow->size();
|
|
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
v = consoleWindow->viewport_GL->size();
|
|
}
|
|
else if ( consoleWindow->viewport_SDL )
|
|
{
|
|
v = consoleWindow->viewport_SDL->size();
|
|
}
|
|
|
|
sprintf( stmp, "%i x %i ", w.width(), w.height() );
|
|
|
|
winSizeReadout->setText( tr(stmp) );
|
|
|
|
sprintf( stmp, "%i x %i ", v.width(), v.height() );
|
|
|
|
vpSizeReadout->setText( tr(stmp) );
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::ntscStartScanLineChanged(const QString &txt)
|
|
{
|
|
int opt, opt2;
|
|
std::string s;
|
|
|
|
s = txt.toStdString();
|
|
|
|
if ( s.size() > 0 )
|
|
{
|
|
opt = strtoul( s.c_str(), NULL, 10 );
|
|
|
|
g_config->getOption("SDL.ScanLineEndNTSC", &opt2);
|
|
|
|
if ( opt > opt2 )
|
|
{
|
|
opt = opt2;
|
|
}
|
|
g_config->setOption("SDL.ScanLineStartNTSC", opt);
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::ntscEndScanLineChanged(const QString &txt)
|
|
{
|
|
int opt, opt2;
|
|
std::string s;
|
|
|
|
s = txt.toStdString();
|
|
|
|
if ( s.size() > 0 )
|
|
{
|
|
opt = strtoul( s.c_str(), NULL, 10 );
|
|
|
|
g_config->getOption("SDL.ScanLineStartNTSC", &opt2);
|
|
|
|
if ( opt < opt2 )
|
|
{
|
|
opt = opt2;
|
|
}
|
|
g_config->setOption("SDL.ScanLineEndNTSC", opt);
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::palStartScanLineChanged(const QString &txt)
|
|
{
|
|
int opt, opt2;
|
|
std::string s;
|
|
|
|
s = txt.toStdString();
|
|
|
|
if ( s.size() > 0 )
|
|
{
|
|
opt = strtoul( s.c_str(), NULL, 10 );
|
|
|
|
g_config->getOption("SDL.ScanLineEndPAL", &opt2);
|
|
|
|
if ( opt > opt2 )
|
|
{
|
|
opt = opt2;
|
|
}
|
|
g_config->setOption("SDL.ScanLineStartPAL", opt);
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::palEndScanLineChanged(const QString &txt)
|
|
{
|
|
int opt, opt2;
|
|
std::string s;
|
|
|
|
s = txt.toStdString();
|
|
|
|
if ( s.size() > 0 )
|
|
{
|
|
opt = strtoul( s.c_str(), NULL, 10 );
|
|
|
|
g_config->getOption("SDL.ScanLineStartPAL", &opt2);
|
|
|
|
if ( opt < opt2 )
|
|
{
|
|
opt = opt2;
|
|
}
|
|
g_config->setOption("SDL.ScanLineEndPAL", opt);
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::setCheckBoxFromProperty( QCheckBox *cbx, const char *property )
|
|
{
|
|
int pval;
|
|
g_config->getOption (property, &pval);
|
|
|
|
cbx->setCheckState( pval ? Qt::Checked : Qt::Unchecked );
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::setComboBoxFromProperty( QComboBox *cbx, const char *property )
|
|
{
|
|
int i, pval;
|
|
g_config->getOption (property, &pval);
|
|
|
|
for (i=0; i<cbx->count(); i++)
|
|
{
|
|
if ( pval == cbx->itemData(i).toInt() )
|
|
{
|
|
cbx->setCurrentIndex(i); break;
|
|
}
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::openGL_linearFilterChanged( int value )
|
|
{
|
|
bool opt = (value != Qt::Unchecked);
|
|
g_config->setOption("SDL.OpenGLip", opt );
|
|
g_config->save ();
|
|
|
|
if ( consoleWindow != NULL )
|
|
{
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
consoleWindow->viewport_GL->setLinearFilterEnable( opt );
|
|
}
|
|
if ( consoleWindow->viewport_SDL )
|
|
{
|
|
consoleWindow->viewport_SDL->setLinearFilterEnable( opt );
|
|
}
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::autoScaleChanged( int value )
|
|
{
|
|
bool opt = (value != Qt::Unchecked);
|
|
g_config->setOption("SDL.AutoScale", opt );
|
|
g_config->save ();
|
|
|
|
if ( consoleWindow != NULL )
|
|
{
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
consoleWindow->viewport_GL->setAutoScaleOpt( opt );
|
|
}
|
|
if ( consoleWindow->viewport_SDL )
|
|
{
|
|
consoleWindow->viewport_SDL->setAutoScaleOpt( opt );
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::autoRegionChanged( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.AutoDetectPAL", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::use_new_PPU_changed( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.NewPPU", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
|
|
fceuWrapperLock();
|
|
UpdateEMUCore (g_config);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::frameskip_changed( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.Frameskip", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
|
|
fceuWrapperLock();
|
|
UpdateEMUCore (g_config);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::useSpriteLimitChanged( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.DisableSpriteLimit", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
|
|
fceuWrapperLock();
|
|
UpdateEMUCore (g_config);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::clipSidesChanged( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.ClipSides", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
|
|
fceuWrapperLock();
|
|
UpdateEMUCore (g_config);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::showFPSChanged( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.ShowFPS", (value == Qt::Checked) );
|
|
g_config->save ();
|
|
|
|
fceuWrapperLock();
|
|
UpdateEMUCore (g_config);
|
|
fceuWrapperUnLock();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::aspectEnableChanged( int value )
|
|
{
|
|
//printf("Value:%i \n", value );
|
|
int forceAspect = (value != Qt::Unchecked);
|
|
|
|
if ( forceAspect )
|
|
{
|
|
xScaleLabel->setText( tr("Scale:") );
|
|
yScaleLabel->hide();
|
|
yScaleBox->hide();
|
|
|
|
aspectSelectLabel->show();
|
|
aspectSelect->show();
|
|
}
|
|
else
|
|
{
|
|
xScaleLabel->setText( tr("X Scale:") );
|
|
yScaleLabel->show();
|
|
yScaleBox->show();
|
|
|
|
aspectSelectLabel->hide();
|
|
aspectSelect->hide();
|
|
}
|
|
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::driverChanged(int index)
|
|
{
|
|
int driver;
|
|
//printf("Driver: %i : %i \n", index, driverSelect->itemData(index).toInt() );
|
|
|
|
driver = driverSelect->itemData(index).toInt();
|
|
|
|
g_config->setOption ("SDL.VideoDriver", driver);
|
|
|
|
g_config->save ();
|
|
|
|
printf("Note: A restart of the application is needed for video driver change to take effect...\n");
|
|
|
|
if ( consoleWindow )
|
|
{
|
|
consoleWindow->loadVideoDriver( driver );
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::scalerChanged(int index)
|
|
{
|
|
int scaler;
|
|
//printf("Scaler: %i : %i \n", index, scalerSelect->itemData(index).toInt() );
|
|
|
|
scaler = scalerSelect->itemData(index).toInt();
|
|
|
|
g_config->setOption ("SDL.SpecialFilter", scaler);
|
|
|
|
g_config->save ();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::regionChanged(int index)
|
|
{
|
|
int region;
|
|
int actRegion = FCEUI_GetRegion();
|
|
//printf("Region: %i : %i \n", index, regionSelect->itemData(index).toInt() );
|
|
|
|
region = regionSelect->itemData(index).toInt();
|
|
|
|
g_config->setOption ("SDL.PAL", region);
|
|
g_config->save ();
|
|
|
|
// reset sound subsystem for changes to take effect
|
|
if ( actRegion != region )
|
|
{
|
|
fceuWrapperLock();
|
|
FCEUI_SetRegion (region, true);
|
|
fceuWrapperUnLock();
|
|
}
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::aspectChanged(int index)
|
|
{
|
|
int aspectID;
|
|
|
|
aspectID = aspectSelect->itemData(index).toInt();
|
|
|
|
g_config->setOption ("SDL.AspectSelect", aspectID);
|
|
g_config->save ();
|
|
|
|
consoleWindow->setViewportAspect();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::cursorShapeChanged(int index)
|
|
{
|
|
int cursorSel;
|
|
//printf("Scaler: %i : %i \n", index, scalerSelect->itemData(index).toInt() );
|
|
|
|
cursorSel = cursorSelect->itemData(index).toInt();
|
|
|
|
g_config->setOption ("SDL.CursorType", cursorSel);
|
|
|
|
g_config->save ();
|
|
|
|
consoleWindow->loadCursor();
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::cursorVisChanged( int value )
|
|
{
|
|
int vis;
|
|
|
|
vis = (value != Qt::Unchecked);
|
|
|
|
//printf("Value:%i \n", value );
|
|
g_config->setOption("SDL.CursorVis", vis );
|
|
g_config->save ();
|
|
|
|
consoleWindow->loadCursor();
|
|
}
|
|
//----------------------------------------------------
|
|
QSize ConsoleVideoConfDialog_t::calcNewScreenSize(void)
|
|
{
|
|
QSize out( GL_NES_WIDTH, GL_NES_HEIGHT );
|
|
|
|
if ( consoleWindow )
|
|
{
|
|
QSize w, v;
|
|
double xscale = 1.0, yscale = 1.0, aspectRatio = 1.0;
|
|
int texture_width = nes_shm->video.ncol;
|
|
int texture_height = nes_shm->video.nrow;
|
|
int l=0, r=texture_width;
|
|
int t=0, b=texture_height;
|
|
int dw=0, dh=0, rw, rh;
|
|
|
|
w = consoleWindow->size();
|
|
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
v = consoleWindow->viewport_GL->size();
|
|
aspectRatio = consoleWindow->viewport_GL->getAspectRatio();
|
|
}
|
|
else if ( consoleWindow->viewport_SDL )
|
|
{
|
|
v = consoleWindow->viewport_SDL->size();
|
|
aspectRatio = consoleWindow->viewport_SDL->getAspectRatio();
|
|
}
|
|
|
|
dw = w.width() - v.width();
|
|
dh = w.height() - v.height();
|
|
|
|
if ( aspectCbx->isChecked() )
|
|
{
|
|
xscale = xScaleBox->value();
|
|
yscale = xscale * (double)nes_shm->video.xyRatio;
|
|
}
|
|
else
|
|
{
|
|
xscale = xScaleBox->value();
|
|
yscale = yScaleBox->value();
|
|
}
|
|
rw=(int)((r-l)*xscale);
|
|
rh=(int)((b-t)*yscale);
|
|
|
|
if ( aspectCbx->isChecked() )
|
|
{
|
|
double rr;
|
|
|
|
rr = (double)rh / (double)rw;
|
|
|
|
if ( rr > aspectRatio )
|
|
{
|
|
rw = (int)( (((double)rh) / aspectRatio) + 0.50);
|
|
}
|
|
else
|
|
{
|
|
rh = (int)( (((double)rw) * aspectRatio) + 0.50);
|
|
}
|
|
}
|
|
out.setWidth( rw + dw );
|
|
out.setHeight( rh + dh );
|
|
}
|
|
return out;
|
|
}
|
|
//----------------------------------------------------
|
|
void ConsoleVideoConfDialog_t::applyChanges( void )
|
|
{
|
|
resetVideo();
|
|
|
|
if ( consoleWindow )
|
|
{
|
|
float xscale, yscale;
|
|
QSize s = calcNewScreenSize();
|
|
|
|
if ( aspectCbx->isChecked() )
|
|
{
|
|
yscale = xscale = xScaleBox->value();
|
|
}
|
|
else
|
|
{
|
|
xscale = xScaleBox->value();
|
|
yscale = yScaleBox->value();
|
|
}
|
|
|
|
if ( consoleWindow->viewport_GL )
|
|
{
|
|
consoleWindow->viewport_GL->setForceAspectOpt( aspectCbx->isChecked() );
|
|
consoleWindow->viewport_GL->setAutoScaleOpt( autoScaleCbx->isChecked() );
|
|
consoleWindow->viewport_GL->setScaleXY( xscale, yscale );
|
|
}
|
|
if ( consoleWindow->viewport_SDL )
|
|
{
|
|
consoleWindow->viewport_SDL->setForceAspectOpt( aspectCbx->isChecked() );
|
|
consoleWindow->viewport_SDL->setAutoScaleOpt( autoScaleCbx->isChecked() );
|
|
consoleWindow->viewport_SDL->setScaleXY( xscale, yscale );
|
|
}
|
|
|
|
consoleWindow->resize( s );
|
|
|
|
updateReadouts();
|
|
}
|
|
|
|
}
|
|
//----------------------------------------------------
|