void MainWindow::createWidgets()
{
QFrame* frame = new QFrame();
frame->setStyleSheet(PSS("QWidget { background: kColour1; border-color: kColour2; }"));
frame->setFrameStyle(QFrame::Box);
QVBoxLayout *layout = new TightVBoxLayout;
frame->setLayout(layout);
layout->addWidget(new WindowHeader);
QWidget* blackSep = new QWidget();
blackSep->setFixedHeight(1);
blackSep->setStyleSheet(PSS("QWidget { background: kColour2; }"));
layout->addWidget(blackSep);
layout->addSpacing(50);
{
QLabel* deviceImage = new QLabel();
deviceImage->setFixedSize(600, 136);
deviceImage->setStyleSheet(QString("QWidget { background-image: url(:/Device); }"));
layout->addWidget(deviceImage, 0, Qt::AlignHCenter);
}
layout->addSpacing(50);
m_controlsWidget = new ControlsWidget();
layout->addWidget(m_controlsWidget, 0, Qt::AlignHCenter);
layout->addStretch();
setCentralWidget(frame);
}
void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE force_scale,
BYTE force_palette) {
BYTE set_mode;
WORD width, height, w_for_pr, h_for_pr;
gfx_set_screen_start:
set_mode = FALSE;
width = 0, height = 0;
w_for_pr = 0, h_for_pr = 0;
/*
* l'ordine dei vari controlli non deve essere cambiato:
* 0) overscan
* 1) filtro
* 2) fullscreen
* 3) fattore di scala
* 4) tipo di paletta (IMPORTANTE: dopo il SDL_SetVideoMode)
*/
/* overscan */
{
overscan.enabled = cfg->oscan;
gfx.rows = SCR_ROWS;
gfx.lines = SCR_LINES;
if (overscan.enabled == OSCAN_DEFAULT) {
overscan.enabled = cfg->oscan_default;
}
if (overscan.enabled) {
gfx.rows -= (overscan.borders->left + overscan.borders->right);
gfx.lines -= (overscan.borders->up + overscan.borders->down);
}
}
/* filtro */
if (filter == NO_CHANGE) {
filter = cfg->filter;
}
if ((filter != cfg->filter) || info.on_cfg || force_scale) {
switch (filter) {
case PHOSPHOR:
case SCANLINE:
case NO_FILTER:
case DBL:
case CRT_CURVE:
case CRT_NO_CURVE:
case PHOSPHOR2:
case DARK_ROOM:
gfx.filter = scale_surface;
/*
* se sto passando dal filtro ntsc ad un'altro, devo
* ricalcolare la larghezza del video mode quindi
* forzo il controllo del fattore di scala.
*/
if (cfg->filter == NTSC_FILTER) {
/* devo reimpostare la larghezza del video mode */
scale = cfg->scale;
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
break;
case SCALE2X:
case SCALE3X:
case SCALE4X:
case HQ2X:
case HQ3X:
case HQ4X:
case XBRZ2X:
case XBRZ3X:
case XBRZ4X:
if ((filter >= SCALE2X) && (filter <= SCALE4X)) {
gfx.filter = scaleNx;
} else if ((filter >= HQ2X) && (filter <= HQ4X)) {
gfx.filter = hqNx;
} else if ((filter >= XBRZ2X) && (filter <= XBRZ4X)) {
gfx.filter = xBRZ;
}
/*
* se sto passando dal filtro ntsc ad un'altro, devo
* ricalcolare la larghezza del video mode quindi
* forzo il controllo del fattore di scala.
*/
if (cfg->filter == NTSC_FILTER) {
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
break;
case NTSC_FILTER:
gfx.filter = ntsc_surface;
/*
* il fattore di scala deve essere gia' stato
* inizializzato almeno una volta.
*/
if (cfg->scale != NO_CHANGE) {
/* devo reimpostare la larghezza del video mode */
scale = cfg->scale;
} else if (scale == NO_CHANGE) {
/*
* se scale e new_scale sono uguali a NO_CHANGE,
* imposto un default.
*/
scale = X2;
}
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
break;
}
}
/* fullscreen */
if (fullscreen == NO_CHANGE) {
fullscreen = cfg->fullscreen;
}
if ((fullscreen != cfg->fullscreen) || info.on_cfg) {
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
/* fattore di scala */
if (scale == NO_CHANGE) {
scale = cfg->scale;
}
if ((scale != cfg->scale) || info.on_cfg || force_scale) {
#define ctrl_filter_scale(scalexf, hqxf, xbrzxf)\
if ((filter >= SCALE2X) && (filter <= SCALE4X)) {\
filter = scalexf;\
} else if ((filter >= HQ2X) && (filter <= HQ4X)) {\
filter = hqxf;\
} else if ((filter >= XBRZ2X) && (filter <= XBRZ4X)) {\
filter = xbrzxf;\
}
switch (scale) {
case X1:
/*
* il fattore di scala a 1 e' possibile
* solo senza filtro.
*/
if (filter != NO_FILTER) {
/*
* con un fattore di scala X1 effect deve essere
* sempre impostato su scale_surface.
*/
gfx.filter = scale_surface;
return;
}
set_mode = TRUE;
break;
case X2:
ctrl_filter_scale(SCALE2X, HQ2X, XBRZ2X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
case X3:
ctrl_filter_scale(SCALE3X, HQ3X, XBRZ3X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
case X4:
ctrl_filter_scale(SCALE4X, HQ4X, XBRZ4X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
}
if (!width) {
width = gfx.rows * scale;
gfx.w[CURRENT] = width;
gfx.w[NO_OVERSCAN] = SCR_ROWS * scale;
}
height = gfx.lines * scale;
gfx.h[CURRENT] = height;
gfx.h[NO_OVERSCAN] = SCR_LINES * scale;
}
/*
* cfg->scale e cfg->filter posso aggiornarli prima
* del set_mode, mentre cfg->fullscreen e cfg->palette
* devo farlo necessariamente dopo.
*/
/* salvo il nuovo fattore di scala */
cfg->scale = scale;
/* salvo ill nuovo filtro */
cfg->filter = filter;
/* devo eseguire un SDL_SetVideoMode? */
if (set_mode) {
uint32_t flags = software_flags;
gfx.w[VIDEO_MODE] = width;
gfx.h[VIDEO_MODE] = height;
gfx.pixel_aspect_ratio = 1.0f;
if (gfx.opengl) {
flags = opengl.flags;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
//SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
/* abilito il doublebuffering */
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, TRUE);
/* abilito il vsync se e' necessario */
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, cfg->vsync);
if (fullscreen) {
gfx.w[VIDEO_MODE] = gfx.w[MONITOR];
gfx.h[VIDEO_MODE] = gfx.h[MONITOR];
}
/* Pixel Aspect Ratio */
{
if (cfg->filter == NTSC_FILTER) {
gfx.pixel_aspect_ratio = 1.0f;
} else {
switch (cfg->pixel_aspect_ratio) {
case PAR11:
gfx.pixel_aspect_ratio = 1.0f;
break;
case PAR54:
gfx.pixel_aspect_ratio = 5.0f / 4.0f;
break;
case PAR87:
gfx.pixel_aspect_ratio = 8.0f / 7.0f;
break;
}
}
if ((gfx.pixel_aspect_ratio != 1.0f) && !fullscreen) {
float brd = 0;
gfx.w[VIDEO_MODE] = (gfx.w[NO_OVERSCAN] * gfx.pixel_aspect_ratio);
if (overscan.enabled) {
brd = (float) gfx.w[VIDEO_MODE] / (float) SCR_ROWS;
brd *= (overscan.borders->right + overscan.borders->left);
}
gfx.w[VIDEO_MODE] -= brd;
}
}
}
/* faccio quello che serve prima del setvideo */
gui_set_video_mode();
/*
* nella versione a 32 bit (GTK) dopo un gfx_reset_video,
* se non lo faccio anche qui, crasha tutto.
*/
//sdl_wid();
/* inizializzo la superfice video */
surface_sdl = SDL_SetVideoMode(gfx.w[VIDEO_MODE], gfx.h[VIDEO_MODE], 0, flags);
gui_after_set_video_mode();
/* in caso di errore */
if (!surface_sdl) {
fprintf(stderr, "SDL_SetVideoMode failed : %s\n", SDL_GetError());
return;
}
gfx.bit_per_pixel = surface_sdl->format->BitsPerPixel;
}
/* interpolation */
if (gfx.opengl && cfg->interpolation) {
opengl.interpolation = TRUE;
} else {
opengl.interpolation = FALSE;
}
/* paletta */
if (palette == NO_CHANGE) {
palette = cfg->palette;
}
if ((palette != cfg->palette) || info.on_cfg || force_palette) {
if (palette == PALETTE_FILE) {
if (strlen(cfg->palette_file) != 0) {
if (palette_load_from_file(cfg->palette_file) == EXIT_ERROR) {
memset(cfg->palette_file, 0x00, sizeof(cfg->palette_file));
text_add_line_info(1, "[red]error on palette file");
if (cfg->palette != PALETTE_FILE) {
palette = cfg->palette;
} else if (machine.type == NTSC) {
palette = PALETTE_NTSC;
} else {
palette = PALETTE_SONY;
}
} else {
ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_file, 0,
(BYTE *) palette_RGB);
}
}
}
switch (palette) {
case PALETTE_PAL:
ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_pal, 0,
(BYTE *) palette_RGB);
break;
case PALETTE_NTSC:
ntsc_set(cfg->ntsc_format, FALSE, 0, 0, (BYTE *) palette_RGB);
break;
case PALETTE_GREEN:
rgb_modifier(-0x20, 0x20, -0x20);
break;
case PALETTE_FILE:
break;
default:
ntsc_set(cfg->ntsc_format, palette, 0, 0, (BYTE *) palette_RGB);
break;
}
/* inizializzo in ogni caso la tabella YUV dell'hqx */
hqx_init();
/*
* memorizzo i colori della paletta nel
* formato di visualizzazione.
*/
{
WORD i;
for (i = 0; i < NUM_COLORS; i++) {
palette_win[i] = SDL_MapRGBA(surface_sdl->format, palette_RGB[i].r,
palette_RGB[i].g, palette_RGB[i].b, 255);
}
}
}
/* salvo il nuovo stato del fullscreen */
cfg->fullscreen = fullscreen;
/* salvo il nuovo tipo di paletta */
cfg->palette = palette;
/* software rendering */
framebuffer = surface_sdl;
flip = SDL_Flip;
text.surface = surface_sdl;
text_clear = gfx_text_clear;
text_blit = gfx_text_blit;
text.w = surface_sdl->w;
text.h = surface_sdl->h;
w_for_pr = gfx.w[VIDEO_MODE];
h_for_pr = gfx.h[VIDEO_MODE];
if (gfx.opengl) {
opengl.scale_force = FALSE;
opengl.scale = cfg->scale;
opengl.factor = X1;
opengl.PSS = FALSE;
opengl.glsl.shader_used = FALSE;
shader.id = SHADER_NONE;
opengl.glsl.param = 0;
if ((opengl.glsl.compliant == TRUE) && (opengl.glsl.enabled == TRUE)) {
#define PSS()\
opengl.PSS = ((gfx.pixel_aspect_ratio != 1.0f) && (cfg->PAR_soft_stretch == TRUE)) ? TRUE : FALSE
#define glsl_up(e, s, p)\
opengl.glsl.shader_used = TRUE;\
shader.id = s;\
opengl.scale_force = TRUE;\
opengl.scale = X1;\
opengl.factor = cfg->scale;\
PSS();\
opengl.glsl.param = p;\
gfx.filter = e
glsl_delete_shaders(&shader);
switch (cfg->filter) {
case NO_FILTER:
glsl_up(scale_surface, SHADER_NO_FILTER, 0);
break;
case PHOSPHOR:
glsl_up(scale_surface, SHADER_PHOSPHOR, 0);
break;
case PHOSPHOR2:
glsl_up(scale_surface, SHADER_PHOSPHOR, 1);
break;
case SCANLINE:
glsl_up(scale_surface, SHADER_SCANLINE, 0);
break;
case DBL:
glsl_up(scale_surface, SHADER_DONTBLOOM, 0);
break;
case DARK_ROOM:
glsl_up(scale_surface, SHADER_DONTBLOOM, 1);
break;
case CRT_CURVE:
glsl_up(scale_surface, SHADER_CRT, 0);
/* niente interpolazione perche' gia fatta dallo shader stesso */
opengl.interpolation = opengl.PSS = FALSE;
break;
case CRT_NO_CURVE:
glsl_up(scale_surface, SHADER_CRT, 1);
/* niente interpolazione perche' gia fatta dallo shader stesso */
opengl.interpolation = opengl.PSS = FALSE;
break;
case SCALE2X:
case SCALE3X:
case SCALE4X:
case HQ2X:
case HQ3X:
case HQ4X:
case XBRZ2X:
case XBRZ3X:
case XBRZ4X:
case NTSC_FILTER:
PSS();
break;
}
/*
if (cfg->fullscreen) {
if ((cfg->filter >= SCALE2X) && (cfg->filter <= SCALE4X)) {
glsl_up(scaleNx, SHADER_NO_FILTER);
opengl.scale = X2;
opengl.factor = (float) cfg->scale / 2.0f;
} else if ((cfg->filter >= HQ2X) && (cfg->filter <= HQ4X)) {
glsl_up(hqNx, SHADER_NO_FILTER);
opengl.scale = X2;
opengl.factor = (float) cfg->scale / 2.0f;
}
}
*/
}
/* creo la superficie che utilizzero' come texture */
sdl_create_surface_gl(surface_sdl, gfx.w[CURRENT], gfx.h[CURRENT], cfg->fullscreen);
/* opengl rendering */
framebuffer = opengl.surface_gl;
flip = opengl_flip;
text.surface = surface_sdl;
text_clear = opengl_text_clear;
text_blit = opengl_text_blit;
text.w = gfx.w[CURRENT];
text.h = gfx.h[CURRENT];
{
WORD r = (WORD) opengl.quadcoords.r;
WORD l = (WORD) opengl.quadcoords.l;
WORD t = (WORD) opengl.quadcoords.t;
WORD b = (WORD) opengl.quadcoords.b;
w_for_pr = r - l;
h_for_pr = t - b;
}
}
/* questo controllo devo farlo necessariamente dopo il glew_init() */
if ((opengl.glsl.compliant == FALSE) || (opengl.glsl.enabled == FALSE)) {
if ((filter >= PHOSPHOR) && (filter <= CRT_NO_CURVE)) {
filter = NO_FILTER;
goto gfx_set_screen_start;
}
}
gfx_text_reset();
/*
* calcolo le proporzioni tra il disegnato a video (overscan e schermo
* con le dimensioni per il filtro NTSC compresi) e quello che dovrebbe
* essere (256 x 240). Mi serve per calcolarmi la posizione del puntatore
* dello zapper.
*/
gfx.w_pr = ((float) w_for_pr / gfx.w[CURRENT]) * ((float) gfx.w[NO_OVERSCAN] / SCR_ROWS);
gfx.h_pr = ((float) h_for_pr / gfx.h[CURRENT]) * ((float) gfx.h[NO_OVERSCAN] / SCR_LINES);
/* setto il titolo della finestra */
gui_update();
if (info.on_cfg == TRUE) {
info.on_cfg = FALSE;
}
}
