VideoDriver *_video_driver;

char _ini_videodriver[32];

int _num_resolutions;

SoundDriver *_sound_driver;

char _ini_sounddriver[32];

	return result;

}

{

	if (x != 0) return x;

}

void SortResolutions(int count)

{

}

extern int _pal_first_dirty;

extern int _pal_count_dirty;

extern int _num_resolutions;

extern Colour _cur_palette[256];

void HandleKeypress(uint32 key);

 */

void GameSizeChanged()

{

	ScreenSizeChanged();

	RelocateAllWindows(_screen.width, _screen.height);

	MarkWholeScreenDirty();

 * @param res variable to store the resolution in.

 * @param s   the string to decompose.

 */

{

	const char *t = strchr(s, 'x');

	if (t == NULL) {

		return;

	}

}

static void InitializeDynamicVariables()

	int i;

	const char *optformat;

	char musicdriver[32], sounddriver[32], videodriver[32], blitter[32];

	Year startyear = INVALID_YEAR;

	uint generation_seed = GENERATE_NEW_SEED;

	bool save_config = true;

			debuglog_conn = mgo.opt;

			break;

#endif /* ENABLE_NETWORK */

		case 't': startyear = atoi(mgo.opt); break;

		case 'd': {

#if defined(WIN32)

	if (!StrEmpty(sounddriver)) ttd_strlcpy(_ini_sounddriver, sounddriver, sizeof(_ini_sounddriver));

	if (!StrEmpty(videodriver)) ttd_strlcpy(_ini_videodriver, videodriver, sizeof(_ini_videodriver));

	if (!StrEmpty(blitter))     ttd_strlcpy(_ini_blitter, blitter, sizeof(_ini_blitter));

	if (startyear != INVALID_YEAR) _settings_newgame.game_creation.starting_year = startyear;

	if (generation_seed != GENERATE_NEW_SEED) _settings_newgame.game_creation.generation_seed = generation_seed;

	/* The width and height must be at least 1 pixel, this

	 * way all internal drawing routines work correctly. */

#if defined(ENABLE_NETWORK)

	if (dedicated_host) snprintf(_settings_client.network.server_bind_ip, sizeof(_settings_client.network.server_bind_ip), "%s", dedicated_host);

	  SDTG_STR("sounddriver",      SLE_STRB,C|S,0, _ini_sounddriver,       NULL,    STR_NULL, NULL),

	  SDTG_STR("blitter",          SLE_STRB,C|S,0, _ini_blitter,           NULL,    STR_NULL, NULL),

	  SDTG_STR("language",         SLE_STRB, S, 0, _dynlang.curr_file,     NULL,    STR_NULL, NULL),

	  SDTG_STR("screenshot_format",SLE_STRB, S, 0, _screenshot_format_name,NULL,    STR_NULL, NULL),

	  SDTG_STR("savegame_format",  SLE_STRB, S, 0, _savegame_format,       NULL,    STR_NULL, NULL),

	 SDTG_BOOL("rightclick_emulate",         S, 0, _rightclick_emulate,   false,    STR_NULL, NULL),

	int i;

	for (i = 0; i != _num_resolutions; i++) {

			break;

		}

	}

				break;

			case GAMEOPT_RESOLUTION_BTN: // Change resolution

					this->SetDirty();

				}

				break;

	if (IsInsideMM(ind, (SPECSTR_RESOLUTION_START - 0x70E4), (SPECSTR_RESOLUTION_END - 0x70E4) + 1)) {

		int i = ind - (SPECSTR_RESOLUTION_START - 0x70E4);

		buff += snprintf(

		);

		return buff;

	}

	count = _cocoa_subdriver->ListModes(modes, lengthof(modes));

	for (i = 0; i < count; i++) {

	}

	_num_resolutions = count;

	/* Don't create a window or enter fullscreen if we're just going to show a dialog. */

	if (_cocoa_video_dialog) return NULL;

	bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();

	_cocoa_subdriver = QZ_CreateSubdriver(width, height, bpp, _fullscreen, true);

{

	int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth();

	if (bpp == 0) _dedicated_video_mem = NULL;

	ScreenSizeChanged();

	SetDebugString("net=6");

const char *VideoDriver_Null::Start(const char* const *parm)

{

	this->ticks = GetDriverParamInt(parm, "ticks", 1000);

	ScreenSizeChanged();

	/* Do not render, nor blit */

	}

}

	{ 640,  480},

	{ 800,  600},

	{1024,  768},

			if (w >= 640 && h >= 480) {

				int j;

				for (j = 0; j < n; j++) {

				}

				if (j == n) {

					if (++n == lengthof(_resolutions)) break;

				}

			}

	// is the wanted mode among the available modes?

	for (i = 0; i != _num_resolutions; i++) {

	}

	// use the closest possible resolution

	best = 0;

	for (i = 1; i != _num_resolutions; ++i) {

		if (newdelta < delta) {

			best = i;

			delta = newdelta;

		}

	}

}

#ifndef ICON_DIR

	DEBUG(driver, 1, "SDL: using driver '%s'", buf);

	GetVideoModes();

	MarkWholeScreenDirty();

	SDL_CALL SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);

{

	_fullscreen = fullscreen;

	GetVideoModes(); // get the list of available video modes

		// switching resolution failed, put back full_screen to original status

		_fullscreen ^= true;

		return false;

#define VIDEO_VIDEO_DRIVER_HPP

#include "../driver.h"

class VideoDriver: public Driver {

public:

extern VideoDriver *_video_driver;

extern char _ini_videodriver[32];

extern int _num_resolutions;

#endif /* VIDEO_VIDEO_DRIVER_HPP */

bool _window_maximize;

uint _display_hz;

uint _fullscreen_bpp;

#if !defined(UNICODE)

uint _codepage;

#endif

			return 0;

		case WM_DESTROY:

			return 0;

		case WM_LBUTTONDOWN:

				/* Set maximized flag when we maximize (obviously), but also when we

				 * switched to fullscreen from a maximized state */

				_window_maximize = (wParam == SIZE_MAXIMIZED || (_window_maximize && _fullscreen));

				ClientSizeChanged(LOWORD(lParam), HIWORD(lParam));

			}

			return 0;

	return true;

}

	{  640,  480 },

	{  800,  600 },

	{ 1024,  768 },

			uint j;

			for (j = 0; j < n; j++) {

			}

			/* In the previous loop we have checked already existing/added resolutions if

			 * looped all and found none, add the new one to the list. If we have reached the

			 * maximum amount of resolutions, then quit querying the display */

			if (j == n) {

				if (++n == lengthof(_resolutions)) break;

			}

		}

	FindResolutions();

	// fullscreen uses those

	MakeWindow(_fullscreen);

	MarkWholeScreenDirty();