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; } }