void DirectFB_QuitModes(_THIS) { SDL_DisplayMode tmode; int i; for (i = 0; i < _this->num_displays; ++i) { SDL_VideoDisplay *display = &_this->displays[i]; DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; SDL_GetDesktopDisplayMode(i, &tmode); tmode.format = SDL_PIXELFORMAT_UNKNOWN; DirectFB_SetDisplayMode(_this, display, &tmode); SDL_GetDesktopDisplayMode(i, &tmode); DirectFB_SetDisplayMode(_this, display, &tmode); if (dispdata->layer) { SDL_DFB_CHECK(dispdata-> layer->SetCooperativeLevel(dispdata->layer, DLSCL_ADMINISTRATIVE)); SDL_DFB_CHECK(dispdata-> layer->SetCursorOpacity(dispdata->layer, 0x00)); SDL_DFB_CHECK(dispdata-> layer->SetCooperativeLevel(dispdata->layer, DLSCL_SHARED)); } SDL_DFB_RELEASE(dispdata->layer); SDL_DFB_RELEASE(dispdata->vidlayer); } }
/** * Constructeur qui ouvre une fenêtre avec la SDL et définit le contexte. * La fenêtre est destinée à être remplie par des visites, * puis mise à jour par un appel à render. */ OpenGLVisiteur::OpenGLVisiteur(bool fullscreen_): fullscreen(fullscreen_) { SDL_DisplayMode dm; SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER); if (SDL_GetDesktopDisplayMode(0, &dm) != 0) { SDL_Log("SDL_GetDesktopDisplayMode failed: %s", SDL_GetError()); exit(EXIT_FAILURE); } if(fullscreen){ screenWidth=dm.w; screenHeight=dm.h; }else{ screenWidth=800; screenHeight=600; } window=SDL_CreateWindow ("2eme affichage", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screenWidth, screenHeight, SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN| (fullscreen?SDL_WINDOW_FULLSCREEN_DESKTOP:0)); context= SDL_GL_CreateContext(window); draws=glGenLists(1); glNewList(1,GL_COMPILE); glColor3f(1,0,0); }
int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags) { int i, actual_bpp = 0; if (!SDL_GetVideoDevice()) { return 0; } if (!(flags & SDL_FULLSCREEN)) { SDL_DisplayMode mode; SDL_GetDesktopDisplayMode(GetVideoDisplay(), &mode); return SDL_BITSPERPIXEL(mode.format); } for (i = 0; i < SDL_GetNumDisplayModes(GetVideoDisplay()); ++i) { SDL_DisplayMode mode; SDL_GetDisplayMode(GetVideoDisplay(), i, &mode); if (!mode.w || !mode.h || (width == mode.w && height == mode.h)) { if (!mode.format) { return bpp; } if (SDL_BITSPERPIXEL(mode.format) >= (Uint32) bpp) { actual_bpp = SDL_BITSPERPIXEL(mode.format); } } } return actual_bpp; }
static int set_sdl_video_size(unsigned short int w, unsigned short int h) { if (window) SDL_DestroyWindow(window); if (!w || !h) { w = 640; h = 480; if (flags & SDL_WINDOW_FULLSCREEN) { SDL_DisplayMode mode; if (!SDL_GetDesktopDisplayMode(0, &mode)) { w = mode.w; h = mode.h; } else log_e("SDL_GetDesktopDisplayMode: %s", SDL_GetError()); } } log_i("%ux%u", w, h); window = SDL_CreateWindow("greedy", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags); if (!window) log_p("SDL_CreateWindow: %s", SDL_GetError()); SDL_Delay(50); return 0; }
/** * Returns the dimensions of the main display on this system. * \return The dimension of the main display. */ void GHOST_SystemSDL::getAllDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const { SDL_DisplayMode mode; SDL_GetDesktopDisplayMode(0, &mode); /* note, always 0 display */ width = mode.w; height = mode.h; }
void fs_ml_toggle_fullscreen() { fs_log("fs_ml_toggle_fullscreen\n"); #ifdef USE_SDL2 if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_WINDOW) { fs_emu_warning("Cannot toggle fullscreen with fullscreen-mode=window"); return; } int display_index = 0; SDL_DisplayMode mode; memset(&mode, 0, sizeof(SDL_DisplayMode)); if (SDL_GetDesktopDisplayMode(display_index, &mode) == 0) { SDL_SetWindowDisplayMode(g_fs_ml_window, &mode); } g_fs_emu_video_fullscreen = !g_fs_emu_video_fullscreen; int flags = 0; if (g_fs_emu_video_fullscreen) { if (g_fs_emu_video_fullscreen_mode == FULLSCREEN_DESKTOP) { flags = SDL_WINDOW_FULLSCREEN_DESKTOP; } else { flags = SDL_WINDOW_FULLSCREEN; } } SDL_SetWindowFullscreen(g_fs_ml_window, flags); #else g_fs_emu_video_fullscreen = !g_fs_emu_video_fullscreen; destroy_opengl_state(); set_video_mode(); recreate_opengl_state(); #endif }
QRect StreamingPreferences::getDesktopResolution(int displayIndex) { if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s", SDL_GetError()); return QRect(); } if (displayIndex >= SDL_GetNumVideoDisplays()) { SDL_QuitSubSystem(SDL_INIT_VIDEO); return QRect(); } SDL_DisplayMode mode; int err = SDL_GetDesktopDisplayMode(displayIndex, &mode); SDL_QuitSubSystem(SDL_INIT_VIDEO); if (err == 0) { return QRect(0, 0, mode.w, mode.h); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GetDesktopDisplayMode() failed: %s", SDL_GetError()); return QRect(); } }
static bool CreateWindow (int width, int height, int bpp, TLN_WindowFlags flags, char* file_overlay) { SDL_DisplayMode mode; SDL_Surface* surface = NULL; int factor; int rflags; char quality; Uint32 format = 0; if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_JOYSTICK) != 0) return false; /* obtiene tamaño escritorio y tamaño máximo de ventana*/ SDL_GetDesktopDisplayMode (0, &mode); if (!(flags & CWF_FULLSCREEN)) { factor = (flags >> 2) & 0x07; if (!factor) { factor = 1; while (width*(factor + 1) < mode.w && height*(factor + 1) < mode.h && factor < 3) factor++; } wnd_width = width*factor; wnd_height = height*factor; dstrect.x = 0; dstrect.y = 0; dstrect.w = wnd_width; dstrect.h = wnd_height; }
static void VID_SetupResolution(void) { SDL_DisplayMode display_mode; if (r_fullscreen.integer == 1) { if ((!vid_width.integer || !vid_height.integer)) { if (!SDL_GetDesktopDisplayMode(0, &display_mode)) { glConfig.vidWidth = display_mode.w; glConfig.vidHeight = display_mode.h; } else { glConfig.vidWidth = 1024; glConfig.vidHeight = 768; Cvar_LatchedSetValue(&vid_width, 1024); // Try some default if nothing is set and we failed Cvar_LatchedSetValue(&vid_height, 768); // to get desktop resolution Com_Printf("warning: failed to get desktop resolution, using 1024x768 failsafe\n"); } } else { glConfig.vidWidth = bound(320, vid_width.integer, vid_width.integer); glConfig.vidHeight = bound(200, vid_height.integer, vid_height.integer); } } else { if (!vid_win_width.integer || !vid_win_height.integer) { Cvar_LatchedSetValue(&vid_win_width, 640); Cvar_LatchedSetValue(&vid_win_height, 480); } glConfig.vidWidth = bound(320, vid_win_width.integer, vid_win_width.integer); glConfig.vidHeight = bound(200, vid_win_height.integer, vid_win_height.integer); } }
void SDL2Window::changeMode(DisplayMode mode, bool makeFullscreen) { if(!m_window) { m_size = mode.resolution; m_fullscreen = makeFullscreen; return; } if(m_fullscreen == makeFullscreen && m_size == mode.resolution) { return; } bool wasFullscreen = m_fullscreen; m_renderer->beforeResize(wasFullscreen || makeFullscreen); if(makeFullscreen) { if(mode.resolution != Vec2i_ZERO) { SDL_DisplayMode sdlmode; SDL_DisplayMode requested; requested.driverdata = NULL; requested.format = 0; requested.refresh_rate = 0; requested.w = mode.resolution.x; requested.h = mode.resolution.y; int display = SDL_GetWindowDisplayIndex(m_window); if(!SDL_GetClosestDisplayMode(display, &requested, &sdlmode)) { if(SDL_GetDesktopDisplayMode(display, &sdlmode)) { return; } } if(SDL_SetWindowDisplayMode(m_window, &sdlmode) < 0) { return; } } } Uint32 flags = getSDLFlagsForMode(mode.resolution, makeFullscreen); if(SDL_SetWindowFullscreen(m_window, flags) < 0) { return; } if(!makeFullscreen) { SDL_SetWindowSize(m_window, mode.resolution.x, mode.resolution.y); } if(wasFullscreen != makeFullscreen) { onToggleFullscreen(makeFullscreen); } if(makeFullscreen) { // SDL regrettably sends resize events when a fullscreen window is minimized. // Because of that we ignore all size change events when fullscreen. // Instead, handle the size change here. updateSize(); } tick(); }
QSize SDLInteraction::getCurrentResolution() { SDL_DisplayMode mode; SDL_GetDesktopDisplayMode(0, &mode); return QSize(mode.w, mode.h); }
VideoMode VideoMode::getDesktopMode() { SDL_DisplayMode dm; if (SDL_GetDesktopDisplayMode(0, &dm) != 0) return {}; return {(u32)dm.w, (u32)dm.h, SDL_BITSPERPIXEL(dm.format)}; }
bool Window::fullscreen() { SDL_DisplayMode dm; SDL_GetDesktopDisplayMode(0, &dm); SDL_SetWindowDisplayMode(window, &dm); SDL_SetWindowFullscreen(window, !(SDL_GetWindowFlags(window)&SDL_WINDOW_FULLSCREEN)); return true; }
bool CheckAvailableVideoModes() { // Get available fullscreen/hardware modes const int numDisplays = SDL_GetNumVideoDisplays(); SDL_DisplayMode ddm = {0, 0, 0, 0, nullptr}; SDL_DisplayMode cdm = {0, 0, 0, 0, nullptr}; // ddm is virtual, contains all displays in multi-monitor setups // for fullscreen windows with non-native resolutions, ddm holds // the original screen mode and cdm is the changed mode SDL_GetDesktopDisplayMode(0, &ddm); SDL_GetCurrentDisplayMode(0, &cdm); LOG( "[GL::%s] desktop={%ix%ix%ibpp@%iHz} current={%ix%ix%ibpp@%iHz}", __func__, ddm.w, ddm.h, SDL_BPP(ddm.format), ddm.refresh_rate, cdm.w, cdm.h, SDL_BPP(cdm.format), cdm.refresh_rate ); for (int k = 0; k < numDisplays; ++k) { const int numModes = SDL_GetNumDisplayModes(k); if (numModes <= 0) { LOG("\tdisplay=%d bounds=N/A modes=N/A", k + 1); continue; } SDL_DisplayMode cm = {0, 0, 0, 0, nullptr}; SDL_DisplayMode pm = {0, 0, 0, 0, nullptr}; SDL_Rect db; SDL_GetDisplayBounds(k, &db); LOG("\tdisplay=%d modes=%d bounds={x=%d, y=%d, w=%d, h=%d}", k + 1, numModes, db.x, db.y, db.w, db.h); for (int i = 0; i < numModes; ++i) { SDL_GetDisplayMode(k, i, &cm); const float r0 = (cm.w * 9.0f) / cm.h; const float r1 = (cm.w * 10.0f) / cm.h; const float r2 = (cm.w * 16.0f) / cm.h; // skip legacy (3:2, 4:3, 5:4, ...) and weird (10:6, ...) ratios if (r0 != 16.0f && r1 != 16.0f && r2 != 25.0f) continue; // show only the largest refresh-rate and bit-depth per resolution if (cm.w == pm.w && cm.h == pm.h && (SDL_BPP(cm.format) < SDL_BPP(pm.format) || cm.refresh_rate < pm.refresh_rate)) continue; LOG("\t\t[%2i] %ix%ix%ibpp@%iHz", int(i + 1), cm.w, cm.h, SDL_BPP(cm.format), cm.refresh_rate); pm = cm; } } // we need at least 24bpp or window-creation will fail return (SDL_BPP(ddm.format) >= 24); }
Coord2i getStartingResolution(int display) { SDL_DisplayMode mode; if(SDL_GetDesktopDisplayMode(display, &mode) == 0) { return{mode.w, mode.h}; } throw std::runtime_error("Could not get the initial resolution of display " + std::to_string(display) + ". "); }
void SDLPlatform::getDesktopResolution( Resolution & _resolution ) const { SDL_DisplayMode dm; if (SDL_GetDesktopDisplayMode(0, &dm) == 0) { _resolution.setWidth(static_cast<uint32_t>(dm.w)); _resolution.setHeight(static_cast<uint32_t>(dm.h)); } }
/* * VID_GetDefaultMode */ bool VID_GetDefaultMode( int *width, int *height ) { SDL_DisplayMode mode; SDL_GetDesktopDisplayMode( 0, &mode ); *width = mode.w; *height = mode.h; return true; }
WindowMode getDisplaySize() const override { SDL_DisplayMode new_mode; int display_index = 0; if(window_ != nullptr) { display_index = SDL_GetWindowDisplayIndex(window_.get()); } SDL_GetDesktopDisplayMode(display_index, &new_mode); WindowMode mode = { new_mode.w, new_mode.h, std::make_shared<SDLPixelFormat>(new_mode.format), new_mode.refresh_rate }; return mode; }
int main(int argc, char *argv[]) { SDL_DisplayMode mode; int num_displays, dpy; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Load the SDL library */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_Log("Using video target '%s'.\n", SDL_GetCurrentVideoDriver()); num_displays = SDL_GetNumVideoDisplays(); SDL_Log("See %d displays.\n", num_displays); for (dpy = 0; dpy < num_displays; dpy++) { const int num_modes = SDL_GetNumDisplayModes(dpy); SDL_Rect rect = { 0, 0, 0, 0 }; int m; SDL_GetDisplayBounds(dpy, &rect); SDL_Log("%d: \"%s\" (%dx%d, (%d, %d)), %d modes.\n", dpy, SDL_GetDisplayName(dpy), rect.w, rect.h, rect.x, rect.y, num_modes); if (SDL_GetCurrentDisplayMode(dpy, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " CURRENT: failed to query (%s)\n", SDL_GetError()); } else { print_mode("CURRENT", &mode); } if (SDL_GetDesktopDisplayMode(dpy, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " DESKTOP: failed to query (%s)\n", SDL_GetError()); } else { print_mode("DESKTOP", &mode); } for (m = 0; m < num_modes; m++) { if (SDL_GetDisplayMode(dpy, m, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " MODE %d: failed to query (%s)\n", m, SDL_GetError()); } else { char prefix[64]; SDL_snprintf(prefix, sizeof (prefix), " MODE %d", m); print_mode(prefix, &mode); } } SDL_Log("\n"); } return 0; }
//No settings file found Renderer::Renderer(MaterialManager* const mM, ShaderManager* const sM): mManager{mM},sManager{sM},openglContext{} { SDL_DisplayMode desktop; SDL_Init(SDL_INIT_VIDEO); SDL_GetDesktopDisplayMode(0,&desktop); createContext(desktop.w,desktop.h,true,1); initialize(); guiInitialize(); }
Display::Display(float &WIDTH, float &HEIGHT, std::string title, bool fullscreen) { SDL_Init(SDL_INIT_EVERYTHING); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); 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_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetSwapInterval(0); SDL_ShowCursor(0); if(fullscreen){ SDL_DisplayMode dm; if (SDL_GetDesktopDisplayMode(0, &dm) != 0){ SDL_Log("SDL_GetDesktopDisplayMode failed: %s", SDL_GetError()); } this->width = dm.w; this->height = dm.h; WIDTH = this->width; HEIGHT = this->height; }else{ this->width = WIDTH; this->height = HEIGHT; } window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WIDTH, HEIGHT, SDL_WINDOW_OPENGL | (fullscreen ? SDL_WINDOW_FULLSCREEN : SDL_WINDOW_RESIZABLE)); glContext = SDL_GL_CreateContext(window); GLenum status = glewInit(); if(status != GLEW_OK){ std::cerr << "Glew failed to initialize !" << std::endl; } isWindowClosed = false; glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glViewport(0.0f, 0.0f, WIDTH, HEIGHT); lastFrameTime = SDL_GetTicks(); oneFrameDuration = 1000.0f / (float)MAX_FPS; }
IntVector2 Graphics::GetDesktopResolution() const { #if !defined(__ANDROID__) && !defined(IOS) SDL_DisplayMode mode; SDL_GetDesktopDisplayMode(0, &mode); return IntVector2(mode.w, mode.h); #else // SDL_GetDesktopDisplayMode() may not work correctly on mobile platforms. Rather return the window size return IntVector2(width_, height_); #endif }
static int get_refresh_rate(SDL_Window * win) { SDL_DisplayMode mode; int displayIndex = SDL_GetWindowDisplayIndex(win); if (SDL_GetDesktopDisplayMode(displayIndex, &mode) != 0 ) { return 0; } else { return mode.refresh_rate; } }
static uint32_t getRefreshRate(SDL_Window* window) { int displayIndex = SDL_GetWindowDisplayIndex(window); SDL_DisplayMode displayMode; //stores refresh rate if(SDL_GetDesktopDisplayMode(displayIndex, &displayMode) != 0 && displayMode.refresh_rate != 0) { return displayMode.refresh_rate; } return DEFAULT_REFRESH_RATE; }
// Use SDL to determine desktop size void _Config::SetDefaultFullscreenSize() { if(Config.FullscreenSize != glm::ivec2(0)) return; SDL_DisplayMode DisplayMode; if(SDL_GetDesktopDisplayMode(0, &DisplayMode) != 0) Config.FullscreenSize = DEFAULT_WINDOW_SIZE; else Config.FullscreenSize = glm::ivec2(DisplayMode.w, DisplayMode.h); Config.Save(); }
void ToggleFullscreen(photon_window &window){ window.fullscreen = !window.fullscreen; if(window.fullscreen){ SDL_DisplayMode mode; SDL_GetDesktopDisplayMode(0, &mode); SDL_SetWindowDisplayMode(window.window_SDL, &mode); } SDL_SetWindowFullscreen(window.window_SDL, SDL_bool(window.fullscreen)); PrintToLog("INFO: Window toggled fullscreen."); }
static int lua_SDL_GetDesktopDisplayMode(lutok::state& state){ Lua_SDL_DisplayMode & dm = LOBJECT_INSTANCE(Lua_SDL_DisplayMode); SDL_DisplayMode * mode = new SDL_DisplayMode; if (SDL_GetDesktopDisplayMode(state.to_integer(1), mode) == 0){ dm.push(mode); return 1; }else{ delete mode; return 0; } }
void ProcessEvent(OpenBlox::OBGame* gameInst, SDL_Event event){ switch(event.type){ case SDL_MOUSEMOTION: { SDL_MouseMotionEvent motion = event.motion; gameInst->mouseMove(QPoint(motion.x, motion.y)); break; } case SDL_MOUSEBUTTONDOWN: { SDL_MouseButtonEvent btn = event.button; gameInst->mousePress(btn.button, QPoint(btn.x, btn.y)); break; } case SDL_KEYDOWN: { SDL_KeyboardEvent keyEvt = event.key; SDL_Keysym key = keyEvt.keysym; #ifndef OPENBLOX_STUDIO if(key.sym == SDLK_F11){ if((SDL_GetWindowFlags(OpenBlox::mw) & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN){ SDL_SetWindowFullscreen(OpenBlox::mw, 0); }else{ SDL_DisplayMode dm; if(SDL_GetDesktopDisplayMode(SDL_GetWindowDisplayIndex(OpenBlox::mw), &dm) == 0){ SDL_SetWindowDisplayMode(OpenBlox::mw, &dm); } SDL_SetWindowFullscreen(OpenBlox::mw, SDL_WINDOW_FULLSCREEN); } } #endif break; } case SDL_KEYUP: { SDL_KeyboardEvent keyEvt = event.key; SDL_Keysym key = keyEvt.keysym; Q_UNUSED(key) break; } case SDL_WINDOWEVENT: { SDL_WindowEvent wevt = event.window; switch(wevt.event){ case SDL_WINDOWEVENT_RESIZED: { gameInst->resized(); } } break; } case SDL_QUIT: { shouldQuit = true; break; } } }
//----------------------------------------------------------------------------// Window::Window(SDL_Window* _window) : m_window(_window), m_width(0), m_height(0), m_isOpened(true) { ASSERT(_window != nullptr); SDL_DisplayMode _dm; SDL_GetDesktopDisplayMode(0, &_dm); SDL_SetWindowSize(m_window, (_dm.w >> 2) * 3, (_dm.h >> 2) * 3); SDL_SetWindowPosition(m_window, _dm.w >> 3, _dm.h >> 3); }
static void init_monitors(void) { sdl_monitor_info **tailptr; // make a list of monitors sdl_monitor_list = NULL; tailptr = &sdl_monitor_list; #if (SDLMAME_SDL2) { int i; mame_printf_verbose("Enter init_monitors\n"); for (i = 0; i < SDL_GetNumVideoDisplays(); i++) { sdl_monitor_info *monitor; SDL_DisplayMode dmode; // allocate a new monitor info monitor = global_alloc_clear(sdl_monitor_info); snprintf(monitor->monitor_device, sizeof(monitor->monitor_device)-1, "%s%d", SDLOPTION_SCREEN,i); SDL_GetDesktopDisplayMode(i, &dmode); monitor->monitor_width = dmode.w; monitor->monitor_height = dmode.h; monitor->center_width = dmode.w; monitor->center_height = dmode.h; monitor->handle = i; // guess the aspect ratio assuming square pixels monitor->aspect = (float)(dmode.w) / (float)(dmode.h); mame_printf_verbose("Adding monitor %s (%d x %d)\n", monitor->monitor_device, dmode.w, dmode.h); // save the primary monitor handle if (i == 0) primary_monitor = monitor; // hook us into the list *tailptr = monitor; tailptr = &monitor->next; } } mame_printf_verbose("Leave init_monitors\n"); #elif defined(SDLMAME_WIN32) EnumDisplayMonitors(NULL, NULL, monitor_enum_callback, (LPARAM)&tailptr); #else add_primary_monitor((void *)&tailptr); #endif }