Moved window focus/move/resize events to WindowManager

BansheeEngine/Include/BsGUIManager.h

@@ -66,6 +66,10 @@ namespace BansheeEngine
 		boost::signals::connection mOnKeyDownConn;
 		boost::signals::connection mOnKeyUpConn;
 
+		boost::signals::connection mWindowGainedFocusConn;
+		boost::signals::connection mWindowLostFocusConn;
+		boost::signals::connection mWindowMovedOrResizedConn;
+
 		void updateMeshes();
 
 		void onKeyDown(const CM::KeyEvent& event);
@@ -75,6 +79,10 @@ namespace BansheeEngine
 		void onMouseDown(const CM::MouseEvent& event, CM::MouseButton buttonID);
 		void onMouseUp(const CM::MouseEvent& event, CM::MouseButton buttonID);
 
+		void onWindowFocusGained(CM::RenderWindow& win);
+		void onWindowFocusLost(CM::RenderWindow& win);
+		void onWindowMovedOrResized(CM::RenderWindow& win);
+
 		CM::Int2 getWidgetRelativePos(const GUIWidget& widget, const CM::Int2& screenPos);
 	};
 }

BansheeEngine/Include/BsGUIWidget.h

@@ -6,8 +6,6 @@
 #include "CmVector3.h"
 #include "CmQuaternion.h"
 
-#include <boost/signals/connection.hpp>
-
 namespace BansheeEngine
 {
 	class BS_EXPORT GUIWidget : public CM::Component
@@ -62,6 +60,7 @@ namespace BansheeEngine
 		friend class CM::SceneObject;
 		friend class GUIElement;
 		friend class GUIArea;
+		friend class GUIManager;
 
 		GUIWidget(const CM::HSceneObject& parent);
 
@@ -73,8 +72,8 @@ namespace BansheeEngine
 	private:
 		void updateBounds() const;
 
-		virtual void ownerWindowResized(CM::RenderTarget* window);
-		virtual void ownerWindowFocusChanged(CM::RenderWindow* window);
+		virtual void ownerWindowResized();
+		virtual void ownerWindowFocusChanged();
 
 		virtual void update();
 
@@ -88,9 +87,6 @@ namespace BansheeEngine
 		CM::Quaternion mLastFrameRotation;
 		CM::Vector3 mLastFrameScale;
 
-		boost::signals::connection mWinResizeConn;
-		boost::signals::connection mWinFocusConn;
-
 		mutable bool mWidgetIsDirty;
 		mutable CM::Rect mBounds;
 		mutable CM::Vector<CM::HMesh>::type mCachedMeshes;

BansheeEngine/Source/BsGUIManager.cpp

@@ -49,6 +49,10 @@ namespace BansheeEngine
 		mOnMouseMovedConn = gInput().onMouseMoved.connect(boost::bind(&GUIManager::onMouseMoved, this, _1));
 		mOnMouseDownConn = gInput().onMouseDown.connect(boost::bind(&GUIManager::onMouseDown, this, _1, _2));
 		mOnMouseUpConn = gInput().onMouseUp.connect(boost::bind(&GUIManager::onMouseUp, this, _1, _2));
+
+		mWindowGainedFocusConn = RenderWindowManager::instance().onFocusGained.connect(boost::bind(&GUIManager::onWindowFocusGained, this, _1));
+		mWindowLostFocusConn = RenderWindowManager::instance().onFocusLost.connect(boost::bind(&GUIManager::onWindowFocusLost, this, _1));
+		mWindowMovedOrResizedConn = RenderWindowManager::instance().onMovedOrResized.connect(boost::bind(&GUIManager::onWindowMovedOrResized, this, _1));
 	}
 
 	GUIManager::~GUIManager()
@@ -58,6 +62,10 @@ namespace BansheeEngine
 		mOnMouseMovedConn.disconnect();
 		mOnMouseDownConn.disconnect();
 		mOnMouseUpConn.disconnect();
+
+		mWindowGainedFocusConn.disconnect();
+		mWindowLostFocusConn.disconnect();
+		mWindowMovedOrResizedConn.disconnect();
 	}
 
 	void GUIManager::registerWidget(GUIWidget* widget)
@@ -665,6 +673,33 @@ namespace BansheeEngine
 		event.markAsUsed();
 	}
 
+	void GUIManager::onWindowFocusGained(RenderWindow& win)
+	{
+		for(auto& widget : mWidgets)
+		{
+			if(widget->getOwnerWindow() == &win)
+				widget->ownerWindowFocusChanged();
+		}
+	}
+
+	void GUIManager::onWindowFocusLost(RenderWindow& win)
+	{
+		for(auto& widget : mWidgets)
+		{
+			if(widget->getOwnerWindow() == &win)
+				widget->ownerWindowFocusChanged();
+		}
+	}
+
+	void GUIManager::onWindowMovedOrResized(RenderWindow& win)
+	{
+		for(auto& widget : mWidgets)
+		{
+			if(widget->getOwnerWindow() == &win)
+				widget->ownerWindowResized();
+		}
+	}
+
 	Int2 GUIManager::getWidgetRelativePos(const GUIWidget& widget, const Int2& screenPos)
 	{
 		const RenderWindow* window = widget.getOwnerWindow();

BansheeEngine/Source/BsGUIWidget.cpp

@@ -46,9 +46,6 @@ namespace BansheeEngine
 		}
 
 		mElements.clear();
-
-		mWinResizeConn.disconnect();
-		mWinFocusConn.disconnect();
 	}
 
 	void GUIWidget::initialize(Viewport* target, RenderWindow* ownerWindow)
@@ -63,9 +60,6 @@ namespace BansheeEngine
 		mOwnerWindow = ownerWindow;
 
 		GUIManager::instance().registerWidget(this);
-
-		mWinResizeConn = mOwnerWindow->onMovedOrResized.connect(boost::bind(&GUIWidget::ownerWindowResized, this, _1));
-		mWinFocusConn = mOwnerWindow->onFocusChanged.connect(boost::bind(&GUIWidget::ownerWindowFocusChanged, this, _1));
 	}
 
 	void GUIWidget::update()
@@ -246,15 +240,15 @@ namespace BansheeEngine
 		}
 	}
 
-	void GUIWidget::ownerWindowResized(RenderTarget* window)
+	void GUIWidget::ownerWindowResized()
 	{
 		for(auto& area : mAreas)
 		{
-			area->notifyWindowResized(window->getWidth(), window->getHeight());
+			area->notifyWindowResized(getOwnerWindow()->getWidth(), getOwnerWindow()->getHeight());
 		}
 	}
 
-	void GUIWidget::ownerWindowFocusChanged(RenderWindow* window)
+	void GUIWidget::ownerWindowFocusChanged()
 	{
 
 	}

CamelotClient/BsGUIWindowFrameWidget.cpp

@@ -47,8 +47,8 @@ namespace BansheeEditor
 		return GUIWidget::_mouseEvent(element, ev);
 	}
 
-	void WindowFrameWidget::ownerWindowFocusChanged(CM::RenderWindow* window)
+	void WindowFrameWidget::ownerWindowFocusChanged()
 	{
-		mWindowFrame->setFocused(window->hasFocus());
+		mWindowFrame->setFocused(getOwnerWindow()->hasFocus());
 	}
 }

CamelotClient/BsGUIWindowFrameWidget.h

@@ -21,6 +21,6 @@ namespace BansheeEditor
 		virtual void update();
 
 		virtual bool _mouseEvent(BS::GUIElement* element, const BS::GUIMouseEvent& ev);
-		virtual void ownerWindowFocusChanged(CM::RenderWindow* window);
+		virtual void ownerWindowFocusChanged();
 	};
 }

CamelotCore/Include/CmRenderWindow.h

@@ -176,18 +176,21 @@ namespace CamelotFramework
           */
         void setDeactivateOnFocusChange(bool deactivate);
 
-		void setHasFocus(bool focus);
+		/**
+		 * @brief	Internal method. Called when window gets or loses focus.
+		 */
+		void _setHasFocus(bool focus);
 		bool hasFocus() const { return mHasFocus; }
 
 		virtual Int2 screenToWindowPos(const Int2& screenPos) const = 0;
 
-		mutable boost::signal<void(RenderWindow*)> onFocusChanged;
-
 		virtual void destroy();
 
 		static RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow = nullptr);
 
     protected:
+		friend class RenderWindowManager;
+
         /** Default constructor.
         */
         RenderWindow(const RENDER_WINDOW_DESC& desc);

CamelotCore/Include/CmRenderWindowManager.h

@@ -3,25 +3,44 @@
 #include "CmPrerequisites.h"
 #include "CmModule.h"
 #include "CmRenderWindow.h"
+#include <boost/signals.hpp>
 
 namespace CamelotFramework
 {
 	class CM_EXPORT RenderWindowManager : public Module<RenderWindowManager>
 	{
 	public:
-		/** Creates a new rendering window.
-		*/
+		RenderWindowManager();
+
+		/**
+		 * @brief	Creates a new rendering window.
+		 */
 		RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
+		/**
+		 * @brief	Called once per frame. Dispatches events. Internal method.
+		 */
+		void _update();
+
 		Vector<RenderWindow*>::type getRenderWindows() const;
+
+		boost::signal<void(RenderWindow&)> onFocusGained;
+		boost::signal<void(RenderWindow&)> onFocusLost;
+		boost::signal<void(RenderWindow&)> onMovedOrResized;
 	protected:
 		friend class RenderWindow;
 
 		CM_MUTEX(mWindowMutex);
 		Vector<RenderWindow*>::type mCreatedWindows;
 
+		RenderWindow* mWindowInFocus;
+		RenderWindow* mNewWindowInFocus;
+		Vector<RenderWindow*>::type mMovedOrResizedWindows;
+
 		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
 
 		void windowDestroyed(RenderWindow* window);
+		void windowGotFocus(RenderWindow* window);
+		void windowMovedOrResized(RenderWindow* window);
 	};
 }

CamelotCore/Include/CmWindowEventUtilities.h

@@ -45,72 +45,6 @@ THE SOFTWARE.
 
 namespace CamelotFramework
 {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/**
-	@Remarks
-		Callback class used to send out window events to client app
-	*/
-	class CM_EXPORT WindowEventListener
-	{
-	public:
-		virtual ~WindowEventListener() {}
-
-		/**
-		@Remarks
-			Window has moved position
-		@param rw
-			The RenderWindow which created this events
-		*/
-		virtual void windowMoved(RenderWindow* rw)
-                { (void)rw; }
-
-		/**
-		@Remarks
-			Window has resized
-		@param rw
-			The RenderWindow which created this events
-		*/
-		virtual void windowResized(RenderWindow* rw)
-                { (void)rw; }
-
-		/**
-		@Remarks
-			Window is closing (Only triggered if user pressed the [X] button)
-		@param rw
-			The RenderWindow which created this events
-		@return True will close the window(default).
-		*/
-		virtual bool windowClosing(RenderWindow* rw)
-		{ (void)rw; return true; }
-
-		/**
-		@Remarks
-			Window has been closed (Only triggered if user pressed the [X] button)
-		@param rw
-			The RenderWindow which created this events
-		@note
-			The window has not actually close yet when this event triggers. It's only closed after
-			all windowClosed events are triggered. This allows apps to deinitialise properly if they
-			have services that needs the window to exist when deinitialising.
-		*/
-		virtual void windowClosed(RenderWindow* rw)
-                { (void)rw; }
-
-		/**
-		@Remarks
-			Window has lost/gained focus
-		@param rw
-			The RenderWindow which created this events
-		*/
-		virtual void windowFocusChange(RenderWindow* rw)
-                { (void)rw; }
-	};
-
 	/**
 	@Remarks
 		Utility class to handle Window Events/Pumping/Messages
@@ -125,28 +59,6 @@ namespace CamelotFramework
 		*/
 		static void messagePump();
 
-		/**
-		@Remarks
-			Add a listener to listen to renderwindow events (multiple listener's per renderwindow is fine)
-			The same listener can listen to multiple windows, as the Window Pointer is sent along with
-			any messages.
-		@param window
-			The RenderWindow you are interested in monitoring
-		@param listner
-			Your callback listener
-		*/
-		static void addWindowEventListener( RenderWindow* window, WindowEventListener* listener );
-
-		/**
-		@Remarks
-			Remove previously added listener
-		@param window
-			The RenderWindow you registered with
-		@param listner
-			The listener registered
-		*/
-		static void removeWindowEventListener( RenderWindow* window, WindowEventListener* listener );
-
 		/**
 		@Remarks
 			Called by RenderWindows upon creation for Ogre generated windows. You are free to add your
@@ -173,10 +85,6 @@ namespace CamelotFramework
         static OSStatus _CarbonWindowHandler(EventHandlerCallRef nextHandler, EventRef event, void* wnd);
 #endif
 
-		//These are public only so GLXProc can access them without adding Xlib headers header
-		typedef Multimap<RenderWindow*, WindowEventListener*>::type WindowEventListeners;
-		static WindowEventListeners _msListeners;
-
 		typedef Vector<RenderWindow*>::type Windows;
 		static Windows _msWindows;
 	};

CamelotCore/Source/CmApplication.cpp

@@ -24,6 +24,7 @@
 #include "CmMeshManager.h"
 #include "CmMaterialManager.h"
 #include "CmFontManager.h"
+#include "CmRenderWindowManager.h"
 #include "CmRenderer.h"
 
 #include "CmMaterial.h"
@@ -89,6 +90,7 @@ namespace CamelotFramework
 
 		while(mRunMainLoop)
 		{
+			RenderWindowManager::instance()._update();
 			gInput().update();
 			gSceneManager().update();
 

CamelotCore/Source/CmRenderWindow.cpp

@@ -75,14 +75,18 @@ namespace CamelotFramework
 	{
 		if(!onMovedOrResized.empty())
 			onMovedOrResized(this);
+
+		RenderWindowManager::instance().windowMovedOrResized(this);
 	}
 
-	void RenderWindow::setHasFocus(bool focus)
-	{ 
+	void RenderWindow::_setHasFocus(bool focus)
+	{
+		// TODO: Core thread only
+
 		mHasFocus = focus; 
 
-		if(!onFocusChanged.empty())
-			onFocusChanged(this);
+		if(mHasFocus)
+			RenderWindowManager::instance().windowGotFocus(this);
 	}
 
 	void RenderWindow::destroy()

CamelotCore/Source/CmRenderWindowManager.cpp

@@ -2,6 +2,12 @@
 
 namespace CamelotFramework
 {
+	RenderWindowManager::RenderWindowManager()
+		:mWindowInFocus(nullptr), mNewWindowInFocus(nullptr)
+	{
+
+	}
+
 	RenderWindowPtr RenderWindowManager::create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow)
 	{
 		RenderWindowPtr renderWindow = createImpl(desc, parentWindow);
@@ -31,6 +37,65 @@ namespace CamelotFramework
 		}
 	}
 
+	void RenderWindowManager::windowGotFocus(RenderWindow* window)
+	{
+		CM_LOCK_MUTEX(mWindowMutex);
+		mNewWindowInFocus = window;
+	}
+
+	void RenderWindowManager::windowMovedOrResized(RenderWindow* window)
+	{
+		CM_LOCK_MUTEX(mWindowMutex);
+
+		auto iterFind = std::find(begin(mMovedOrResizedWindows), end(mMovedOrResizedWindows), window);
+
+		if(iterFind != end(mMovedOrResizedWindows))
+			mMovedOrResizedWindows.push_back(window);
+	}
+
+	void RenderWindowManager::_update()
+	{
+		RenderWindow* newWinInFocus = nullptr;
+		Vector<RenderWindow*>::type movedOrResizedWindows;
+
+		{
+			CM_LOCK_MUTEX(mWindowMutex);
+			newWinInFocus = mNewWindowInFocus;
+
+			movedOrResizedWindows = mMovedOrResizedWindows;
+			mMovedOrResizedWindows.clear();
+		}
+
+		if(mWindowInFocus != newWinInFocus)
+		{
+			if(mWindowInFocus != nullptr)
+			{
+				mWindowInFocus->_setHasFocus(false);
+
+				if(!onFocusLost.empty())
+					onFocusLost(*mWindowInFocus);
+			}
+
+			if(newWinInFocus != nullptr)
+			{
+				newWinInFocus->_setHasFocus(true);
+
+				if(!onFocusGained.empty())
+					onFocusGained(*newWinInFocus);
+			}
+
+			mWindowInFocus = newWinInFocus;
+		}
+
+		if(!onMovedOrResized.empty())
+		{
+			for(auto& window : movedOrResizedWindows)
+			{
+				onMovedOrResized(*window);
+			}
+		}
+	}
+
 	Vector<RenderWindow*>::type RenderWindowManager::getRenderWindows() const
 	{
 		CM_LOCK_MUTEX(mWindowMutex);

CamelotCore/Source/CmWindowEventUtilities.cpp

@@ -39,7 +39,6 @@ void GLXProc( CamelotFramework::RenderWindow *win, const XEvent &event );
 
 using namespace CamelotFramework;
 
-WindowEventUtilities::WindowEventListeners WindowEventUtilities::_msListeners;
 WindowEventUtilities::Windows WindowEventUtilities::_msWindows;
 
 //--------------------------------------------------------------------------------//
@@ -99,28 +98,6 @@ void WindowEventUtilities::messagePump()
 	}
 #endif
 }
-
-//--------------------------------------------------------------------------------//
-void WindowEventUtilities::addWindowEventListener( RenderWindow* window, WindowEventListener* listener )
-{
-	_msListeners.insert(std::make_pair(window, listener));
-}
-
-//--------------------------------------------------------------------------------//
-void WindowEventUtilities::removeWindowEventListener( RenderWindow* window, WindowEventListener* listener )
-{
-	WindowEventListeners::iterator i = _msListeners.begin(), e = _msListeners.end();
-
-	for( ; i != e; ++i )
-	{
-		if( i->first == window && i->second == listener )
-		{
-			_msListeners.erase(i);
-			break;
-		}
-	}
-}
-
 //--------------------------------------------------------------------------------//
 void WindowEventUtilities::_addRenderWindow(RenderWindow* window)
 {
@@ -151,12 +128,6 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
 	if (!win)
 		return DefWindowProc(hWnd, uMsg, wParam, lParam);
 
-	//LogManager* log = LogManager::getSingletonPtr();
-	//Iterator of all listeners registered to this RenderWindow
-	WindowEventListeners::iterator index,
-        start = _msListeners.lower_bound(win),
-        end = _msListeners.upper_bound(win);
-
 	switch( uMsg )
 	{
 	case WM_ACTIVATE:
@@ -167,7 +138,7 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
 		    win->setActive( true );
 
 			if(!win->hasFocus())
-				win->setHasFocus(true);
+				win->_setHasFocus(true);
 
 			gInput().inputWindowChanged(*win);
         }
@@ -179,11 +150,9 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
             }
 
 			if(win->hasFocus())
-				win->setHasFocus(false);
+				win->_setHasFocus(false);
         }
 
-	    for( ; start != end; ++start )
-		    (start->second)->windowFocusChange(win);
 		break;
 	}
 	case WM_SYSKEYDOWN:
@@ -213,27 +182,17 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
 			return 0;
 		break;
 	case WM_ENTERSIZEMOVE:
-		//log->logMessage("WM_ENTERSIZEMOVE");
 		break;
 	case WM_EXITSIZEMOVE:
-		//log->logMessage("WM_EXITSIZEMOVE");
 		break;
 	case WM_MOVE:
-		//log->logMessage("WM_MOVE");
 		win->windowMovedOrResized();
-		for(index = start; index != end; ++index)
-			(index->second)->windowMoved(win);
 		break;
 	case WM_DISPLAYCHANGE:
 		win->windowMovedOrResized();
-		for(index = start; index != end; ++index)
-			(index->second)->windowResized(win);
 		break;
 	case WM_SIZE:
-		//log->logMessage("WM_SIZE");
 		win->windowMovedOrResized();
-		for(index = start; index != end; ++index)
-			(index->second)->windowResized(win);
 		break;
 	case WM_SETCURSOR:
 		if(Cursor::isHidden())
@@ -248,18 +207,7 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
 		break;
 	case WM_CLOSE:
 	{
-		//log->logMessage("WM_CLOSE");
-		bool close = true;
-		for(index = start; index != end; ++index)
-		{
-			if (!(index->second)->windowClosing(win))
-				close = false;
-		}
-		if (!close) return 0;
-
-		for(index = _msListeners.lower_bound(win); index != end; ++index)
-			(index->second)->windowClosed(win);
-
+		// TODO - Only stop main loop if primary window is closed!!
 		gApplication().stopMainLoop();
 
 		return 0;
@@ -272,11 +220,6 @@ LRESULT CALLBACK WindowEventUtilities::_WndProc(HWND hWnd, UINT uMsg, WPARAM wPa
 //--------------------------------------------------------------------------------//
 void GLXProc( RenderWindow *win, const XEvent &event )
 {
-	//An iterator for the window listeners
-	WindowEventUtilities::WindowEventListeners::iterator index,
-		start = WindowEventUtilities::_msListeners.lower_bound(win),
-		end   = WindowEventUtilities::_msListeners.upper_bound(win);
-
 	switch(event.type)
 	{
 	case ClientMessage:
@@ -284,20 +227,8 @@ void GLXProc( RenderWindow *win, const XEvent &event )
 		::Atom atom;
 		win->getCustomAttribute("ATOM", &atom);
 		if(event.xclient.format == 32 && event.xclient.data.l[0] == (long)atom)
-		{	//Window closed by window manager
-			//Send message first, to allow app chance to unregister things that need done before
-			//window is shutdown
-			bool close = true;
-            for(index = start ; index != end; ++index)
-			{
-				if (!(index->second)->windowClosing(win))
-					close = false;
-			}
-			if (!close) return;
-
-            for(index = start ; index != end; ++index)
-                (index->second)->windowClosed(win);
-
+		{	
+			//Window closed by window manager
 		}
 		break;
 	}
@@ -306,9 +237,6 @@ void GLXProc( RenderWindow *win, const XEvent &event )
 		if (!win->isClosed())
 		{
 			// Window closed without window manager warning.
-            for(index = start ; index != end; ++index)
-                (index->second)->windowClosed(win);
-
 		}
 		break;
 	}
@@ -324,34 +252,17 @@ void GLXProc( RenderWindow *win, const XEvent &event )
 		int newLeft, newTop;
 		win->getMetrics(newWidth, newHeight, newDepth, newLeft, newTop);
 
-		if (newLeft != oldLeft || newTop != oldTop)
-		{
-            for(index = start ; index != end; ++index)
-                (index->second)->windowMoved(win);
-		}
-
-		if (newWidth != oldWidth || newHeight != oldHeight)
-		{
-            for(index = start ; index != end; ++index)
-                (index->second)->windowResized(win);
-		}
 		break;
 	}
 	case FocusIn:     // Gained keyboard focus
 	case FocusOut:    // Lost keyboard focus
-        for(index = start ; index != end; ++index)
-            (index->second)->windowFocusChange(win);
 		break;
 	case MapNotify:   //Restored
 		win->setActive( true );
-        for(index = start ; index != end; ++index)
-            (index->second)->windowFocusChange(win);
 		break;
 	case UnmapNotify: //Minimised
 		win->setActive( false );
 		win->setVisible( false );
-        for(index = start ; index != end; ++index)
-            (index->second)->windowFocusChange(win);
 		break;
 	case VisibilityNotify:
 		switch(event.xvisibility.state)
@@ -369,8 +280,6 @@ void GLXProc( RenderWindow *win, const XEvent &event )
 			win->setVisible( false );
 			break;
 		}
-        for(index = start ; index != end; ++index)
-            (index->second)->windowFocusChange(win);
 		break;
 	default:
 		break;

TODO.txt

@@ -42,6 +42,10 @@ Add separate classes:
 AT THE END DONT FORGET:
  Compile new OIS for all other build types (also update libs and includes)
 
+More concrete changes:
+ - onMovedOrResized is still used by Viewport
+ - Replace list of windows in WIndowEventUtilities with WindowManagers list. No need to keep two lists I think
+
 ------------
 
 How to design OSInputHandler and how does it interact with msg loop?