3 files changed, 469 insertions, 47 deletions
diff --git a/platform/windows/detect.py b/platform/windows/detect.py
index 62bab00f7b..9cdf04797c 100644
--- a/platform/windows/detect.py
+++ b/platform/windows/detect.py
@@ -1,4 +1,90 @@
-
+# 
+# 	tested on               | Windows native    | Linux cross-compilation
+#	------------------------+-------------------+---------------------------
+#	MSVS C++ 2010 Express   | WORKS             | n/a
+#	Mingw-w64               | WORKS             | WORKS
+#	Mingw-w32               | WORKS             | WORKS
+#	MinGW                   | WORKS             | untested
+#
+#####
+# Notes about MSVS C++ :
+#
+# 	- MSVC2010-Express compiles to 32bits only.
+#
+#####
+# Notes about Mingw-w64 and Mingw-w32 under Windows :
+#
+#	- both can be installed using the official installer :
+#		http://mingw-w64.sourceforge.net/download.php#mingw-builds
+#
+#	- if you want to compile both 32bits and 64bits, don't forget to
+#	run the installer twice to install them both.
+#
+#	- install them into a path that does not contain spaces
+#		( example : "C:/Mingw-w32", "C:/Mingw-w64" )
+#
+#	- if you want to compile faster using the "-j" option, don't forget
+#	to install the appropriate version of the Pywin32 python extension 
+#	available from : http://sourceforge.net/projects/pywin32/files/
+#
+#	- before running scons, you must add into the environment path 
+#	the path to the "/bin" directory of the Mingw version you want 
+#	to use :
+#
+#		set PATH=C:/Mingw-w32/bin;%PATH%
+#
+#	- then, scons should be able to detect gcc.
+#	- Mingw-w32 only compiles 32bits.
+#	- Mingw-w64 only compiles 64bits.
+#
+#	- it is possible to add them both at the same time into the PATH env, 
+#	if you also define the MINGW32_PREFIX and MINGW64_PREFIX environment 
+#	variables. 
+#	For instance, you could store that set of commands into a .bat script
+#	that you would run just before scons :
+#
+#			set PATH=C:\mingw-w32\bin;%PATH%
+#			set PATH=C:\mingw-w64\bin;%PATH%
+#			set MINGW32_PREFIX=C:\mingw-w32\bin\
+#			set MINGW64_PREFIX=C:\mingw-w64\bin\
+#
+#####
+# Notes about Mingw, Mingw-w64 and Mingw-w32 under Linux :
+#
+#	- default toolchain prefixes are :
+#		"i586-mingw32msvc-" for MinGW
+#		"i686-w64-mingw32-"	for Mingw-w32
+#		"x86_64-w64-mingw32-" for Mingw-w64
+#
+#	- if both MinGW and Mingw-w32 are installed on your system
+#	Mingw-w32 should take the priority over MinGW.
+#
+#	- it is possible to manually override prefixes by defining
+#	the MINGW32_PREFIX and MINGW64_PREFIX environment variables.
+#	
+#####
+# Notes about Mingw under Windows :
+#
+#	- this is the MinGW version from http://mingw.org/ 
+#	- install it into a path that does not contain spaces
+#		( example : "C:/MinGW" )
+#	- several DirectX headers might be missing. You can copy them into 
+#	the C:/MinGW/include" directory from this page :
+#	 https://code.google.com/p/mingw-lib/source/browse/trunk/working/avcodec_to_widget_5/directx_include/
+#	- before running scons, add the path to the "/bin" directory :
+#		set PATH=C:/MinGW/bin;%PATH%
+#	- scons should be able to detect gcc.
+#
+
+#####
+# TODO :
+#
+#	- finish to cleanup this script to remove all the remains of previous hacks and workarounds
+#	- make it work with the Windows7 SDK that is supposed to enable 64bits compilation for MSVC2010-Express
+#	- confirm it works well with other Visual Studio versions.
+#	- update the wiki about the pywin32 extension required for the "-j" option under Windows.
+#	- update the wiki to document MINGW32_PREFIX and MINGW64_PREFIX
+# 	
 
 import os
 
@@ -13,50 +99,70 @@ def get_name():
 
 def can_build():
 	
-	
 	if (os.name=="nt"):
 		#building natively on windows!
 		if (os.getenv("VSINSTALLDIR")):
 			return True 
 		else:
-			print("MSVC Not detected, attempting mingw.")
+			print("\nMSVC not detected, attempting Mingw.")
+			mingw32 = ""
+			mingw64 = ""
+			if ( os.getenv("MINGW32_PREFIX") ) :
+				mingw32 = os.getenv("MINGW32_PREFIX")
+			if ( os.getenv("MINGW64_PREFIX") ) :
+				mingw64 = os.getenv("MINGW64_PREFIX")
+				
+			test = "gcc --version > NUL 2>&1"
+			if os.system(test)!= 0 and os.system(mingw32+test)!=0 and os.system(mingw64+test)!=0 :
+				print("- could not detect gcc.")
+				print("Please, make sure a path to a Mingw /bin directory is accessible into the environment PATH.\n")
+				return False
+			else:
+				print("- gcc detected.")
+				
 			return True
 			
-			
-			
 	if (os.name=="posix"):
 
 		mingw = "i586-mingw32msvc-"
-		mingw64 = "i686-w64-mingw32-"
+		mingw64 = "x86_64-w64-mingw32-"
+		mingw32 = "i686-w64-mingw32-"
+		
 		if (os.getenv("MINGW32_PREFIX")):
-			mingw=os.getenv("MINGW32_PREFIX")
+			mingw32=os.getenv("MINGW32_PREFIX")
+			mingw = mingw32
 		if (os.getenv("MINGW64_PREFIX")):
 			mingw64=os.getenv("MINGW64_PREFIX")
-
-		if os.system(mingw+"gcc --version >/dev/null") == 0 or os.system(mingw64+"gcc --version >/dev/null") ==0:
+			
+		test = "gcc --version >/dev/null"
+		if os.system(mingw+test) == 0 or os.system(mingw64+test) ==0 or os.system(mingw32+test) ==0 :
 			return True
-
-
 			
 	return False
 		
 def get_opts():
 
 	mingw=""
+	mingw32=""
 	mingw64=""
-	if (os.name!="nt"):
+	if ( os.name == "posix" ):
 		mingw = "i586-mingw32msvc-"
-		mingw64 = "i686-w64-mingw32-"
-		if (os.getenv("MINGW32_PREFIX")):
-			mingw=os.getenv("MINGW32_PREFIX")
-		if (os.getenv("MINGW64_PREFIX")):
-			mingw64=os.getenv("MINGW64_PREFIX")
+		mingw32 = "i686-w64-mingw32-"
+		mingw64 = "x86_64-w64-mingw32-"
+		
+		if os.system(mingw32+"gcc --version >/dev/null") != 0 :
+			mingw32 = mingw
+	
+	if (os.getenv("MINGW32_PREFIX")):
+		mingw32=os.getenv("MINGW32_PREFIX")
+		mingw = mingw32
+	if (os.getenv("MINGW64_PREFIX")):
+		mingw64=os.getenv("MINGW64_PREFIX")
 
 
 	return [
-		('mingw_prefix','Mingw Prefix',mingw),
+		('mingw_prefix','Mingw Prefix',mingw32),
 		('mingw_prefix_64','Mingw Prefix 64 bits',mingw64),
-		('mingw64_for_32','Use Mingw 64 for 32 Bits Build',"no"),
 	]
   
 def get_flags():
@@ -140,13 +246,13 @@ def configure(env):
 		# http://www.scons.org/wiki/LongCmdLinesOnWin32
 		if (os.name=="nt"):
 			import subprocess
-			def mySpawn(sh, escape, cmd, args, env):
-				newargs = ' '.join(args[1:])
-				cmdline = cmd + " " + newargs
+			
+			def mySubProcess(cmdline,env):
+				#print "SPAWNED : " + cmdline
 				startupinfo = subprocess.STARTUPINFO()
 				startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
 				proc = subprocess.Popen(cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-				    stderr=subprocess.PIPE, startupinfo=startupinfo, shell = False, env = env)
+					stderr=subprocess.PIPE, startupinfo=startupinfo, shell = False, env = env)
 				data, err = proc.communicate()
 				rv = proc.wait()
 				if rv:
@@ -154,35 +260,45 @@ def configure(env):
 					print err
 					print "====="
 				return rv
+				
+			def mySpawn(sh, escape, cmd, args, env):
+								
+				newargs = ' '.join(args[1:])
+				cmdline = cmd + " " + newargs
+				
+				rv=0
+				if len(cmdline) > 32000 and cmd.endswith("ar") :
+					cmdline = cmd + " " + args[1] + " " + args[2] + " "
+					for i in range(3,len(args)) :
+						rv = mySubProcess( cmdline + args[i], env )
+						if rv :
+							break	
+				else:				
+					rv = mySubProcess( cmdline, env )
+					
+				return rv
+				
 			env['SPAWN'] = mySpawn
 
 		#build using mingw
 		if (os.name=="nt"):
 			env['ENV']['TMP'] = os.environ['TMP'] #way to go scons, you can be so stupid sometimes
 		else:
-			env["PROGSUFFIX"]=env["PROGSUFFIX"]+".exe"
+			env["PROGSUFFIX"]=env["PROGSUFFIX"]+".exe" # for linux cross-compilation
 
 		mingw_prefix=""
 
 		if (env["bits"]=="default"):
 			env["bits"]="32"
 
-		use64=False
 		if (env["bits"]=="32"):
-
-			if (env["mingw64_for_32"]=="yes"):
-				env.Append(CCFLAGS=['-m32'])
-				env.Append(LINKFLAGS=['-m32'])
-				env.Append(LINKFLAGS=['-static-libgcc'])
-				env.Append(LINKFLAGS=['-static-libstdc++'])
-				mingw_prefix=env["mingw_prefix_64"];
-			else:
-				mingw_prefix=env["mingw_prefix"];
-
-
+			env.Append(LINKFLAGS=['-static'])
+			env.Append(LINKFLAGS=['-static-libgcc'])
+			env.Append(LINKFLAGS=['-static-libstdc++'])
+			mingw_prefix=env["mingw_prefix"];
 		else:
-			mingw_prefix=env["mingw_prefix_64"];
 			env.Append(LINKFLAGS=['-static'])
+			mingw_prefix=env["mingw_prefix_64"];
 
 		nulstr=""
 
@@ -193,10 +309,10 @@ def configure(env):
 
 
 
-		if os.system(mingw_prefix+"gcc --version"+nulstr)!=0:
-			#not really super consistent but..
-			print("Can't find Windows compiler: "+mingw_prefix)
-			sys.exit(255)
+		# if os.system(mingw_prefix+"gcc --version"+nulstr)!=0:
+			# #not really super consistent but..
+			# print("Can't find Windows compiler: "+mingw_prefix)
+			# sys.exit(255)
 
 		if (env["target"]=="release"):
 			
@@ -231,11 +347,11 @@ def configure(env):
 		env.Append(CCFLAGS=['-DGLES2_ENABLED','-DGLEW_ENABLED'])
 		env.Append(LIBS=['mingw32','opengl32', 'dsound', 'ole32', 'd3d9','winmm','gdi32','iphlpapi','shlwapi','wsock32','kernel32'])
 
-		if (env["bits"]=="32" and env["mingw64_for_32"]!="yes"):
-#			env.Append(LIBS=['gcc_s'])
-			#--with-arch=i686
-			env.Append(CPPFLAGS=['-march=i686'])
-			env.Append(LINKFLAGS=['-march=i686'])
+		# if (env["bits"]=="32"):
+# #			env.Append(LIBS=['gcc_s'])
+			# #--with-arch=i686
+			# env.Append(CPPFLAGS=['-march=i686'])
+			# env.Append(LINKFLAGS=['-march=i686'])
 
 
 
diff --git a/platform/windows/os_windows.cpp b/platform/windows/os_windows.cpp
index e392a56aa8..414c250bd4 100644
--- a/platform/windows/os_windows.cpp
+++ b/platform/windows/os_windows.cpp
@@ -171,6 +171,8 @@ void OS_Windows::initialize_core() {
 	last_button_state=0;
 
 	//RedirectIOToConsole();
+	maximized=false;
+	minimized=false;
 
 	ThreadWindows::make_default();	
 	SemaphoreWindows::make_default();	
@@ -1007,6 +1009,23 @@ void OS_Windows::process_joysticks() {
 	};
 };
 
+
+BOOL CALLBACK OS_Windows::MonitorEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor,  LPARAM dwData) {
+	OS_Windows *self=(OS_Windows*)OS::get_singleton();
+	MonitorInfo minfo;
+	minfo.hMonitor=hMonitor;
+	minfo.hdcMonitor=hdcMonitor;
+	minfo.rect.pos.x=lprcMonitor->left;
+	minfo.rect.pos.y=lprcMonitor->top;
+	minfo.rect.size.x=lprcMonitor->right - lprcMonitor->left;
+	minfo.rect.size.y=lprcMonitor->bottom - lprcMonitor->top;
+
+	self->monitor_info.push_back(minfo);
+
+	return TRUE;
+}
+
+
 void OS_Windows::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
 
 
@@ -1045,6 +1064,10 @@ void OS_Windows::initialize(const VideoMode& p_desired,int p_video_driver,int p_
 	}
 	
 	
+	EnumDisplayMonitors(NULL,NULL,MonitorEnumProc,0);
+
+	print_line("DETECTED MONITORS: "+itos(monitor_info.size()));
+	pre_fs_valid=true;
 	if (video_mode.fullscreen) {
 
 		DEVMODE current;
@@ -1067,6 +1090,7 @@ void OS_Windows::initialize(const VideoMode& p_desired,int p_video_driver,int p_
 
 			video_mode.fullscreen=false;
 		}*/
+		pre_fs_valid=false;
 	}
 
 	DWORD		dwExStyle;
@@ -1475,6 +1499,251 @@ void OS_Windows::get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen)
 	
 }
 
+int OS_Windows::get_screen_count() const {
+
+	return monitor_info.size();
+}
+int OS_Windows::get_current_screen() const{
+
+	HMONITOR monitor = MonitorFromWindow(hWnd,MONITOR_DEFAULTTONEAREST);
+	for(int i=0;i<monitor_info.size();i++) {
+		if (monitor_info[i].hMonitor==monitor)
+			return i;
+	}
+
+	return 0;
+}
+void OS_Windows::set_current_screen(int p_screen){
+
+	ERR_FAIL_INDEX(p_screen,monitor_info.size());
+
+	Vector2 ofs = get_window_position() - get_screen_position(get_current_screen());
+	set_window_position(ofs+get_screen_position(p_screen));
+
+}
+
+Point2 OS_Windows::get_screen_position(int p_screen) const{
+
+	ERR_FAIL_INDEX_V(p_screen,monitor_info.size(),Point2());
+	return Vector2( monitor_info[p_screen].rect.pos );
+
+}
+Size2 OS_Windows::get_screen_size(int p_screen) const{
+
+	ERR_FAIL_INDEX_V(p_screen,monitor_info.size(),Point2());
+	return Vector2( monitor_info[p_screen].rect.size );
+
+}
+Point2 OS_Windows::get_window_position() const{
+
+	RECT r;
+	GetWindowRect(hWnd,&r);
+	return Point2(r.left,r.top);
+}
+void OS_Windows::set_window_position(const Point2& p_position){
+
+	RECT r;
+	GetWindowRect(hWnd,&r);
+	MoveWindow(hWnd,p_position.x,p_position.y,r.right-r.left,r.bottom-r.top,TRUE);
+
+}
+Size2 OS_Windows::get_window_size() const{
+
+	RECT r;
+	GetClientRect(hWnd,&r);
+	return Vector2(r.right-r.left,r.bottom-r.top);
+
+}
+void OS_Windows::set_window_size(const Size2 p_size){
+
+	video_mode.width=p_size.width;
+	video_mode.height=p_size.height;
+
+	if (video_mode.fullscreen) {
+		return;
+	}
+
+
+	RECT crect;
+	GetClientRect(hWnd,&crect);
+
+	RECT rect;
+	GetWindowRect(hWnd,&rect);
+	int dx = (rect.right-rect.left)-(crect.right-crect.left);
+	int dy = (rect.bottom-rect.top)-(crect.bottom-crect.top);
+
+	rect.right=rect.left+p_size.width+dx;
+	rect.bottom=rect.top+p_size.height+dy;
+
+
+	//print_line("PRE: "+itos(rect.left)+","+itos(rect.top)+","+itos(rect.right-rect.left)+","+itos(rect.bottom-rect.top));
+
+	/*if (video_mode.resizable) {
+		AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
+	} else {
+		AdjustWindowRect(&rect, WS_CAPTION | WS_POPUPWINDOW, FALSE);
+	}*/
+
+	//print_line("POST: "+itos(rect.left)+","+itos(rect.top)+","+itos(rect.right-rect.left)+","+itos(rect.bottom-rect.top));
+
+	MoveWindow(hWnd,rect.left,rect.top,rect.right-rect.left,rect.bottom-rect.top,TRUE);
+
+}
+void OS_Windows::set_window_fullscreen(bool p_enabled){
+
+	if (video_mode.fullscreen==p_enabled)
+		return;
+
+
+
+	if (p_enabled) {
+
+
+		if (pre_fs_valid) {
+			GetWindowRect(hWnd,&pre_fs_rect);
+			//print_line("A: "+itos(pre_fs_rect.left)+","+itos(pre_fs_rect.top)+","+itos(pre_fs_rect.right-pre_fs_rect.left)+","+itos(pre_fs_rect.bottom-pre_fs_rect.top));
+			//MapWindowPoints(hWnd, GetParent(hWnd), (LPPOINT) &pre_fs_rect, 2);
+			//print_line("B: "+itos(pre_fs_rect.left)+","+itos(pre_fs_rect.top)+","+itos(pre_fs_rect.right-pre_fs_rect.left)+","+itos(pre_fs_rect.bottom-pre_fs_rect.top));
+		}
+
+
+		int cs = get_current_screen();
+		Point2 pos = get_screen_position(cs);
+		Size2 size = get_screen_size(cs);
+
+	/*	r.left = pos.x;
+		r.top = pos.y;
+		r.bottom = pos.y+size.y;
+		r.right = pos.x+size.x;
+*/
+		SetWindowLongPtr(hWnd, GWL_STYLE,
+		    WS_SYSMENU | WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VISIBLE);
+		MoveWindow(hWnd, pos.x, pos.y, size.width, size.height, TRUE);
+
+		video_mode.fullscreen=true;
+
+
+	} else {
+
+		RECT rect;
+
+		if (pre_fs_valid) {
+			rect=pre_fs_rect;
+		} else {
+			rect.left=0;
+			rect.right=video_mode.width;
+			rect.top=0;
+			rect.bottom=video_mode.height;
+		}
+
+
+
+		if (video_mode.resizable) {
+
+			SetWindowLongPtr(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
+			//AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);
+			MoveWindow(hWnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
+		} else {
+
+			SetWindowLongPtr(hWnd, GWL_STYLE, WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE);
+			//AdjustWindowRect(&rect, WS_CAPTION | WS_POPUPWINDOW, FALSE);
+			MoveWindow(hWnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
+		}
+
+		video_mode.fullscreen=false;
+		pre_fs_valid=true;
+/*
+		DWORD dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+		DWORD dwStyle=WS_OVERLAPPEDWINDOW;
+		if (!video_mode.resizable) {
+			dwStyle &= ~WS_THICKFRAME;
+			dwStyle &= ~WS_MAXIMIZEBOX;
+		}
+		AdjustWindowRectEx(&pre_fs_rect, dwStyle, FALSE, dwExStyle);
+		video_mode.fullscreen=false;
+		video_mode.width=pre_fs_rect.right-pre_fs_rect.left;
+		video_mode.height=pre_fs_rect.bottom-pre_fs_rect.top;
+*/
+	}
+
+//	MoveWindow(hWnd,r.left,r.top,p_size.x,p_size.y,TRUE);
+
+
+}
+bool OS_Windows::is_window_fullscreen() const{
+
+	return video_mode.fullscreen;
+}
+void OS_Windows::set_window_resizable(bool p_enabled){
+
+	if (video_mode.resizable==p_enabled)
+		return;
+/*
+	GetWindowRect(hWnd,&pre_fs_rect);
+	DWORD dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+	DWORD dwStyle=WS_OVERLAPPEDWINDOW;
+	if (!p_enabled) {
+		dwStyle &= ~WS_THICKFRAME;
+		dwStyle &= ~WS_MAXIMIZEBOX;
+	}
+	AdjustWindowRectEx(&pre_fs_rect, dwStyle, FALSE, dwExStyle);
+	*/
+
+	if (!video_mode.fullscreen) {
+		if (p_enabled) {
+			SetWindowLongPtr(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
+		} else {
+			SetWindowLongPtr(hWnd, GWL_STYLE, WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE);
+
+		}
+
+		RECT rect;
+		GetWindowRect(hWnd,&rect);
+		MoveWindow(hWnd, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, TRUE);
+	}
+
+	video_mode.resizable=p_enabled;
+
+}
+bool OS_Windows::is_window_resizable() const{
+
+	return video_mode.resizable;
+}
+void OS_Windows::set_window_minimized(bool p_enabled){
+
+	if (p_enabled) {
+		maximized=false;
+		minimized=true;
+		ShowWindow(hWnd,SW_MINIMIZE);
+	} else {
+		ShowWindow(hWnd,SW_RESTORE);
+		maximized=false;
+		minimized=false;
+	}
+}
+bool OS_Windows::is_window_minimized() const{
+
+	return minimized;
+
+}
+void OS_Windows::set_window_maximized(bool p_enabled){
+
+	if (p_enabled) {
+		maximized=true;
+		minimized=false;
+		ShowWindow(hWnd,SW_MAXIMIZE);
+	} else {
+		ShowWindow(hWnd,SW_RESTORE);
+		maximized=false;
+		minimized=false;
+	}
+}
+bool OS_Windows::is_window_maximized() const{
+
+	return maximized;
+}
+
+
 void OS_Windows::print_error(const char* p_function,const char* p_file,int p_line,const char *p_code,const char*p_rationale,ErrorType p_type) {
 
 	HANDLE hCon=GetStdHandle(STD_OUTPUT_HANDLE);
@@ -1862,6 +2131,7 @@ String OS_Windows::get_stdin_string(bool p_block) {
 void OS_Windows::move_window_to_foreground() {
 
 	SetForegroundWindow(hWnd);
+	BringWindowToTop(hWnd);
 
 }
 
diff --git a/platform/windows/os_windows.h b/platform/windows/os_windows.h
index 210e25d2d6..4995adc874 100644
--- a/platform/windows/os_windows.h
+++ b/platform/windows/os_windows.h
@@ -86,7 +86,7 @@ class OS_Windows : public OS {
 	uint64_t ticks_start;
 	uint64_t ticks_per_second;
 
-	bool minimized;
+
         bool old_invalid;
         bool outside;
 	int old_x,old_y;
@@ -130,6 +130,7 @@ class OS_Windows : public OS {
 	int joystick_count;
 	Joystick joysticks[JOYSTICKS_MAX];
 	
+	Size2 window_rect;
 	VideoMode video_mode;
 
 	MainLoop *main_loop;
@@ -196,6 +197,23 @@ protected:
 	};
 	Map<ProcessID, ProcessInfo>* process_map;
 
+	struct MonitorInfo {
+		HMONITOR hMonitor;
+		HDC hdcMonitor;
+		Rect2 rect;
+
+
+	};
+
+	bool pre_fs_valid;
+	RECT pre_fs_rect;
+	Vector<MonitorInfo> monitor_info;
+	bool maximized;
+	bool minimized;
+
+	static BOOL CALLBACK MonitorEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor,  LPARAM dwData);
+
+
 public:
 	LRESULT WndProc(HWND	hWnd,UINT uMsg,	WPARAM	wParam,	LPARAM	lParam);
 
@@ -218,6 +236,24 @@ public:
 	virtual VideoMode get_video_mode(int p_screen=0) const;
 	virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen=0) const;
 
+	virtual int get_screen_count() const;
+	virtual int get_current_screen() const;
+	virtual void set_current_screen(int p_screen);
+	virtual Point2 get_screen_position(int p_screen=0) const;
+	virtual Size2 get_screen_size(int p_screen=0) const;
+	virtual Point2 get_window_position() const;
+	virtual void set_window_position(const Point2& p_position);
+	virtual Size2 get_window_size() const;
+	virtual void set_window_size(const Size2 p_size);
+	virtual void set_window_fullscreen(bool p_enabled);
+	virtual bool is_window_fullscreen() const;
+	virtual void set_window_resizable(bool p_enabled);
+	virtual bool is_window_resizable() const;
+	virtual void set_window_minimized(bool p_enabled);
+	virtual bool is_window_minimized() const;
+	virtual void set_window_maximized(bool p_enabled);
+	virtual bool is_window_maximized() const;
+
 	virtual MainLoop *get_main_loop() const;
 
 	virtual String get_name();