merging up latest mesh-development to nyx-mesh-development

11 files changed, 591 insertions, 64 deletions

diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index 4d2677fd91..3d89867bc1 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -30,20 +30,25 @@ include_directories(
     ${LLVFS_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
     ${LLXML_INCLUDE_DIRS}
+    ${DIRECTX_INCLUDE_DIR}
     )
 
 set(llwindow_SOURCE_FILES
     llkeyboard.cpp
+    llkeyboardheadless.cpp
     llwindowheadless.cpp
     llwindowcallbacks.cpp
+    llwindowlistener.cpp
     )
 
 set(llwindow_HEADER_FILES
     CMakeLists.txt
 
     llkeyboard.h
+    llkeyboardheadless.h
     llwindowheadless.h
     llwindowcallbacks.h
+    llwindowlistener.h
     )
 
 set(viewer_SOURCE_FILES
diff --git a/indra/llwindow/llkeyboardheadless.cpp b/indra/llwindow/llkeyboardheadless.cpp
new file mode 100644
index 0000000000..4dfaaed4e1
--- /dev/null
+++ b/indra/llwindow/llkeyboardheadless.cpp
@@ -0,0 +1,50 @@
+/** 
+ * @file llkeyboardheadless.cpp
+ * @brief Handler for assignable key bindings
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llkeyboardheadless.h"
+#include "llwindowcallbacks.h"
+
+LLKeyboardHeadless::LLKeyboardHeadless()
+{ }
+
+void LLKeyboardHeadless::resetMaskKeys()
+{ }
+
+
+BOOL LLKeyboardHeadless::handleKeyDown(const U16 key, const U32 mask)
+{ return FALSE; }
+
+
+BOOL LLKeyboardHeadless::handleKeyUp(const U16 key, const U32 mask)
+{ return FALSE; }
+
+MASK LLKeyboardHeadless::currentMask(BOOL for_mouse_event)
+{ return MASK_NONE; }
+
+void LLKeyboardHeadless::scanKeyboard()
+{ } 
+ 
diff --git a/indra/llwindow/llkeyboardheadless.h b/indra/llwindow/llkeyboardheadless.h
new file mode 100644
index 0000000000..4e666f8ce8
--- /dev/null
+++ b/indra/llwindow/llkeyboardheadless.h
@@ -0,0 +1,45 @@
+/** 
+ * @file llkeyboardheadless.h
+ * @brief Handler for assignable key bindings
+ *
+ * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLKEYBOARDHEADLESS_H
+#define LL_LLKEYBOARDHEADLESS_H
+
+#include "llkeyboard.h"
+
+class LLKeyboardHeadless : public LLKeyboard
+{
+public:
+	LLKeyboardHeadless();
+	/*virtual*/ ~LLKeyboardHeadless() {};
+
+	/*virtual*/ BOOL	handleKeyUp(const U16 key, MASK mask);
+	/*virtual*/ BOOL	handleKeyDown(const U16 key, MASK mask);
+	/*virtual*/ void	resetMaskKeys();
+	/*virtual*/ MASK	currentMask(BOOL for_mouse_event);
+	/*virtual*/ void	scanKeyboard();
+};
+
+#endif
diff --git a/indra/llwindow/llwindow.cpp b/indra/llwindow/llwindow.cpp
index 072f694c24..71a5df910d 100644
--- a/indra/llwindow/llwindow.cpp
+++ b/indra/llwindow/llwindow.cpp
@@ -41,6 +41,8 @@
 #include "llkeyboard.h"
 #include "linked_lists.h"
 #include "llwindowcallbacks.h"
+#include "llwindowlistener.h"
+#include <boost/lambda/core.hpp>
 
 
 //
@@ -115,10 +117,19 @@ LLWindow::LLWindow(LLWindowCallbacks* callbacks, BOOL fullscreen, U32 flags)
 	  mHideCursorPermanent(FALSE),
 	  mFlags(flags),
 	  mHighSurrogate(0)
-{ }
+{
+	// gKeyboard is still NULL, so it doesn't do LLWindowListener any good to
+	// pass its value right now. Instead, pass it a nullary function that
+	// will, when we later need it, return the value of gKeyboard.
+	// boost::lambda::var() constructs such a functor on the fly.
+	mListener = new LLWindowListener(callbacks, boost::lambda::var(gKeyboard));
+}
 
 LLWindow::~LLWindow()
-{ }
+{
+	delete mListener;
+	mListener = NULL;
+}
 
 //virtual
 BOOL LLWindow::isValid()
diff --git a/indra/llwindow/llwindow.h b/indra/llwindow/llwindow.h
index e8a86a1880..6bdc01ae88 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -36,6 +36,7 @@
 class LLSplashScreen;
 class LLPreeditor;
 class LLWindowCallbacks;
+class LLWindowListener;
 
 // Refer to llwindow_test in test/common/llwindow for usage example
 
@@ -188,6 +189,7 @@ protected:
 	BOOL		mHideCursorPermanent;
 	U32			mFlags;
 	U16			mHighSurrogate;
+	LLWindowListener* mListener;
 
  	// Handle a UTF-16 encoding unit received from keyboard.
  	// Converting the series of UTF-16 encoding units to UTF-32 data,
diff --git a/indra/llwindow/llwindowheadless.cpp b/indra/llwindow/llwindowheadless.cpp
index 35398f1c09..e6e6bc67ff 100644
--- a/indra/llwindow/llwindowheadless.cpp
+++ b/indra/llwindow/llwindowheadless.cpp
@@ -28,6 +28,7 @@
 #include "indra_constants.h"
 
 #include "llwindowheadless.h"
+#include "llkeyboardheadless.h"
 
 //
 // LLWindowHeadless
@@ -37,6 +38,9 @@ LLWindowHeadless::LLWindowHeadless(LLWindowCallbacks* callbacks, const std::stri
 							 BOOL disable_vsync, BOOL use_gl, BOOL ignore_pixel_depth)
 	: LLWindow(callbacks, fullscreen, flags)
 {
+	// Initialize a headless keyboard.
+	gKeyboard = new LLKeyboardHeadless();
+	gKeyboard->setCallbacks(callbacks);
 }
 
 
diff --git a/indra/llwindow/llwindowlistener.cpp b/indra/llwindow/llwindowlistener.cpp
new file mode 100644
index 0000000000..91b99d83c6
--- /dev/null
+++ b/indra/llwindow/llwindowlistener.cpp
@@ -0,0 +1,307 @@
+/** 
+ * @file llwindowlistener.cpp
+ * @brief EventAPI interface for injecting input into LLWindow
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llwindowlistener.h"
+
+#include "llcoord.h"
+#include "llkeyboard.h"
+#include "llwindowcallbacks.h"
+#include <map>
+
+LLWindowListener::LLWindowListener(LLWindowCallbacks *window, const KeyboardGetter& kbgetter)
+	: LLEventAPI("LLWindow", "Inject input events into the LLWindow instance"),
+	  mWindow(window),
+	  mKbGetter(kbgetter)
+{
+	std::string keySomething =
+		"Given [\"keysym\"], [\"keycode\"] or [\"char\"], inject the specified ";
+	std::string keyExplain =
+		"(integer keycode values, or keysym \"XXXX\" from any KEY_XXXX, in\n"
+		"http://hg.secondlife.com/viewer-development/src/tip/indra/llcommon/indra_constants.h )";
+	std::string mask =
+		"Specify optional [\"mask\"] as an array containing any of \"CONTROL\", \"ALT\",\n"
+		"\"SHIFT\" or \"MAC_CONTROL\"; the corresponding modifier bits will be combined\n"
+		"to form the mask used with the event.";
+
+	std::string mouseSomething =
+		"Given [\"button\"], [\"x\"] and [\"y\"], inject the given mouse ";
+	std::string mouseExplain =
+		"(button values \"LEFT\", \"MIDDLE\", \"RIGHT\")";
+
+	add("keyDown",
+		keySomething + "keypress event.\n" + keyExplain + '\n' + mask,
+		&LLWindowListener::keyDown);
+	add("keyUp",
+		keySomething + "key release event.\n" + keyExplain + '\n' + mask,
+		&LLWindowListener::keyUp);
+	add("mouseDown",
+		mouseSomething + "click event.\n" + mouseExplain + '\n' + mask,
+		&LLWindowListener::mouseDown);
+	add("mouseUp",
+		mouseSomething + "release event.\n" + mouseExplain + '\n' + mask,
+		&LLWindowListener::mouseUp);
+	add("mouseMove",
+		std::string("Given [\"x\"] and [\"y\"], inject the given mouse movement event.\n") +
+		mask,
+		&LLWindowListener::mouseMove);
+	add("mouseScroll",
+		"Given an integer number of [\"clicks\"], inject the given mouse scroll event.\n"
+		"(positive clicks moves downward through typical content)",
+		&LLWindowListener::mouseScroll);
+}
+
+template <typename MAPPED>
+class StringLookup
+{
+private:
+	std::string mDesc;
+	typedef std::map<std::string, MAPPED> Map;
+	Map mMap;
+
+public:
+	StringLookup(const std::string& desc): mDesc(desc) {}
+
+	MAPPED lookup(const typename Map::key_type& key) const
+	{
+		typename Map::const_iterator found = mMap.find(key);
+		if (found == mMap.end())
+		{
+			LL_WARNS("LLWindowListener") << "Unknown " << mDesc << " '" << key << "'" << LL_ENDL;
+			return MAPPED();
+		}
+		return found->second;
+	}
+
+protected:
+	void add(const typename Map::key_type& key, const typename Map::mapped_type& value)
+	{
+		mMap.insert(typename Map::value_type(key, value));
+	}
+};
+
+// for WhichKeysym. KeyProxy is like the typedef KEY, except that KeyProxy()
+// (default-constructed) is guaranteed to have the value KEY_NONE.
+class KeyProxy
+{
+public:
+	KeyProxy(KEY k): mKey(k) {}
+	KeyProxy(): mKey(KEY_NONE) {}
+	operator KEY() const { return mKey; }
+
+private:
+	KEY mKey;
+};
+
+struct WhichKeysym: public StringLookup<KeyProxy>
+{
+	WhichKeysym(): StringLookup<KeyProxy>("keysym")
+	{
+		add("RETURN",		KEY_RETURN);
+		add("LEFT",			KEY_LEFT);
+		add("RIGHT",		KEY_RIGHT);
+		add("UP",			KEY_UP);
+		add("DOWN",			KEY_DOWN);
+		add("ESCAPE",		KEY_ESCAPE);
+		add("BACKSPACE",	KEY_BACKSPACE);
+		add("DELETE",		KEY_DELETE);
+		add("SHIFT",		KEY_SHIFT);
+		add("CONTROL",		KEY_CONTROL);
+		add("ALT",			KEY_ALT);
+		add("HOME",			KEY_HOME);
+		add("END",			KEY_END);
+		add("PAGE_UP",		KEY_PAGE_UP);
+		add("PAGE_DOWN",	KEY_PAGE_DOWN);
+		add("HYPHEN",		KEY_HYPHEN);
+		add("EQUALS",		KEY_EQUALS);
+		add("INSERT",		KEY_INSERT);
+		add("CAPSLOCK",		KEY_CAPSLOCK);
+		add("TAB",			KEY_TAB);
+		add("ADD",			KEY_ADD);
+		add("SUBTRACT",		KEY_SUBTRACT);
+		add("MULTIPLY",		KEY_MULTIPLY);
+		add("DIVIDE",		KEY_DIVIDE);
+		add("F1",			KEY_F1);
+		add("F2",			KEY_F2);
+		add("F3",			KEY_F3);
+		add("F4",			KEY_F4);
+		add("F5",			KEY_F5);
+		add("F6",			KEY_F6);
+		add("F7",			KEY_F7);
+		add("F8",			KEY_F8);
+		add("F9",			KEY_F9);
+		add("F10",			KEY_F10);
+		add("F11",			KEY_F11);
+		add("F12",			KEY_F12);
+
+		add("PAD_UP",		KEY_PAD_UP);
+		add("PAD_DOWN",		KEY_PAD_DOWN);
+		add("PAD_LEFT",		KEY_PAD_LEFT);
+		add("PAD_RIGHT",	KEY_PAD_RIGHT);
+		add("PAD_HOME",		KEY_PAD_HOME);
+		add("PAD_END",		KEY_PAD_END);
+		add("PAD_PGUP",		KEY_PAD_PGUP);
+		add("PAD_PGDN",		KEY_PAD_PGDN);
+		add("PAD_CENTER",	KEY_PAD_CENTER); // the 5 in the middle
+		add("PAD_INS",		KEY_PAD_INS);
+		add("PAD_DEL",		KEY_PAD_DEL);
+		add("PAD_RETURN",	KEY_PAD_RETURN);
+		add("PAD_ADD",		KEY_PAD_ADD); // not used
+		add("PAD_SUBTRACT", KEY_PAD_SUBTRACT); // not used
+		add("PAD_MULTIPLY", KEY_PAD_MULTIPLY); // not used
+		add("PAD_DIVIDE",	KEY_PAD_DIVIDE); // not used
+
+		add("BUTTON0",		KEY_BUTTON0);
+		add("BUTTON1",		KEY_BUTTON1);
+		add("BUTTON2",		KEY_BUTTON2);
+		add("BUTTON3",		KEY_BUTTON3);
+		add("BUTTON4",		KEY_BUTTON4);
+		add("BUTTON5",		KEY_BUTTON5);
+		add("BUTTON6",		KEY_BUTTON6);
+		add("BUTTON7",		KEY_BUTTON7);
+		add("BUTTON8",		KEY_BUTTON8);
+		add("BUTTON9",		KEY_BUTTON9);
+		add("BUTTON10",		KEY_BUTTON10);
+		add("BUTTON11",		KEY_BUTTON11);
+		add("BUTTON12",		KEY_BUTTON12);
+		add("BUTTON13",		KEY_BUTTON13);
+		add("BUTTON14",		KEY_BUTTON14);
+		add("BUTTON15",		KEY_BUTTON15);
+	}
+};
+static WhichKeysym keysyms;
+
+struct WhichMask: public StringLookup<MASK>
+{
+	WhichMask(): StringLookup<MASK>("shift mask")
+	{
+		add("NONE",			MASK_NONE);
+		add("CONTROL",		MASK_CONTROL); // Mapped to cmd on Macs
+		add("ALT",			MASK_ALT);
+		add("SHIFT",		MASK_SHIFT);
+		add("MAC_CONTROL",	MASK_MAC_CONTROL); // Un-mapped Ctrl key on Macs, not used on Windows
+	}
+};
+static WhichMask masks;
+
+static MASK getMask(const LLSD& event)
+{
+	MASK mask(MASK_NONE);
+	LLSD masknames(event["mask"]);
+	for (LLSD::array_const_iterator ai(masknames.beginArray()), aend(masknames.endArray());
+		 ai != aend; ++ai)
+	{
+		mask |= masks.lookup(*ai);
+	}
+	return mask;
+}
+
+static KEY getKEY(const LLSD& event)
+{
+    if (event.has("keysym"))
+	{
+		return keysyms.lookup(event["keysym"]);
+	}
+	else if (event.has("keycode"))
+	{
+		return KEY(event["keycode"].asInteger());
+	}
+	else
+	{
+		return KEY(event["char"].asString()[0]);
+	}
+}
+
+void LLWindowListener::keyDown(LLSD const & evt)
+{
+	mKbGetter()->handleTranslatedKeyDown(getKEY(evt), getMask(evt));
+}
+
+void LLWindowListener::keyUp(LLSD const & evt)
+{
+	mKbGetter()->handleTranslatedKeyUp(getKEY(evt), getMask(evt));
+}
+
+// for WhichButton
+typedef BOOL (LLWindowCallbacks::*MouseFunc)(LLWindow *, LLCoordGL, MASK);
+struct Actions
+{
+	Actions(const MouseFunc& d, const MouseFunc& u): down(d), up(u), valid(true) {}
+	Actions(): valid(false) {}
+	MouseFunc down, up;
+	bool valid;
+};
+
+struct WhichButton: public StringLookup<Actions>
+{
+	WhichButton(): StringLookup<Actions>("mouse button")
+	{
+		add("LEFT",		Actions(&LLWindowCallbacks::handleMouseDown,
+								&LLWindowCallbacks::handleMouseUp));
+		add("RIGHT",	Actions(&LLWindowCallbacks::handleRightMouseDown,
+								&LLWindowCallbacks::handleRightMouseUp));
+		add("MIDDLE",	Actions(&LLWindowCallbacks::handleMiddleMouseDown,
+								&LLWindowCallbacks::handleMiddleMouseUp));
+	}
+};
+static WhichButton buttons;
+
+static LLCoordGL getPos(const LLSD& event)
+{
+	return LLCoordGL(event["x"].asInteger(), event["y"].asInteger());
+}
+
+void LLWindowListener::mouseDown(LLSD const & evt)
+{
+	Actions actions(buttons.lookup(evt["button"]));
+	if (actions.valid)
+	{
+		(mWindow->*(actions.down))(NULL, getPos(evt), getMask(evt));
+	}
+}
+
+void LLWindowListener::mouseUp(LLSD const & evt)
+{
+	Actions actions(buttons.lookup(evt["button"]));
+	if (actions.valid)
+	{
+		(mWindow->*(actions.up))(NULL, getPos(evt), getMask(evt));
+	}
+}
+
+void LLWindowListener::mouseMove(LLSD const & evt)
+{
+	mWindow->handleMouseMove(NULL, getPos(evt), getMask(evt));
+}
+
+void LLWindowListener::mouseScroll(LLSD const & evt)
+{
+	S32 clicks = evt["clicks"].asInteger();
+
+	mWindow->handleScrollWheel(NULL, clicks);
+}
+
diff --git a/indra/llwindow/llwindowlistener.h b/indra/llwindow/llwindowlistener.h
new file mode 100644
index 0000000000..74e577ff93
--- /dev/null
+++ b/indra/llwindow/llwindowlistener.h
@@ -0,0 +1,55 @@
+/** 
+ * @file llwindowlistener.h
+ * @brief EventAPI interface for injecting input into LLWindow
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLWINDOWLISTENER_H
+#define LL_LLWINDOWLISTENER_H
+
+#include "lleventapi.h"
+#include <boost/function.hpp>
+
+class LLKeyboard;
+class LLWindowCallbacks;
+
+class LLWindowListener : public LLEventAPI
+{
+public:
+	typedef boost::function<LLKeyboard*()> KeyboardGetter;
+	LLWindowListener(LLWindowCallbacks * window, const KeyboardGetter& kbgetter);
+
+	void keyDown(LLSD const & evt);
+	void keyUp(LLSD const & evt);
+	void mouseDown(LLSD const & evt);
+	void mouseUp(LLSD const & evt);
+	void mouseMove(LLSD const & evt);
+	void mouseScroll(LLSD const & evt);
+
+private:
+	LLWindowCallbacks * mWindow;
+	KeyboardGetter mKbGetter;
+};
+
+
+#endif // LL_LLWINDOWLISTENER_H
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index db90aaf52a..4dd11541b9 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -108,9 +108,6 @@ static long getDictLong (CFDictionaryRef refDict, CFStringRef key);
 static EventTypeSpec WindowHandlerEventList[] =
 {
 	// Window-related events
-	//	{ kEventClassWindow, kEventWindowCollapsing },
-	//	{ kEventClassWindow, kEventWindowCollapsed },
-	//	{ kEventClassWindow, kEventWindowShown },
 	{ kEventClassWindow, kEventWindowActivated },
 	{ kEventClassWindow, kEventWindowDeactivated },
 	{ kEventClassWindow, kEventWindowShown },
@@ -121,8 +118,7 @@ static EventTypeSpec WindowHandlerEventList[] =
 	{ kEventClassWindow, kEventWindowClose },
 	{ kEventClassWindow, kEventWindowBoundsChanging },
 	{ kEventClassWindow, kEventWindowBoundsChanged },
-	//	{ kEventClassWindow, kEventWindowZoomed },
-	//	{ kEventClassWindow, kEventWindowDrawContent },
+	{ kEventClassWindow, kEventWindowGetIdealSize },
 
 	// Mouse events
 	{ kEventClassMouse, kEventMouseDown },
@@ -248,6 +244,7 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
 	mCursorIgnoreNextDelta = FALSE;
 	mNeedsResize = FALSE;
 	mOverrideAspectRatio = 0.f;
+	mMaximized = FALSE;
 	mMinimized = FALSE;
 	mTSMDocument = NULL; // Just in case.
 	mLanguageTextInputAllowed = FALSE;
@@ -455,24 +452,23 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
 	if(!mFullscreen && (mWindow == NULL))
 	{
-		Rect			window_rect;
 		//int				displayWidth = CGDisplayPixelsWide(mDisplay);
 		//int				displayHeight = CGDisplayPixelsHigh(mDisplay);
 		//const int		menuBarPlusTitleBar = 44;   // Ugly magic number.
 
 		LL_DEBUGS("Window") << "createContext: creating window" << LL_ENDL;
 
-		window_rect.left = (long) x;
-		window_rect.right = (long) x + width;
-		window_rect.top = (long) y;
-		window_rect.bottom = (long) y + height;
+		mPreviousWindowRect.left = (long) x;
+		mPreviousWindowRect.right = (long) x + width;
+		mPreviousWindowRect.top = (long) y;
+		mPreviousWindowRect.bottom = (long) y + height;
 
 		//-----------------------------------------------------------------------
 		// Create the window
 		//-----------------------------------------------------------------------
 		mWindow = NewCWindow(
 			NULL,
-			&window_rect,
+			&mPreviousWindowRect,
 			mWindowTitle,
 			false,				// Create the window invisible.  Whoever calls createContext() should show it after any moving/resizing.
 			//		noGrowDocProc,		// Window with no grow box and no zoom box
@@ -481,8 +477,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 			kFirstWindowOfClass,
 			true,
 			(long)this);
-
-
+		
 		if (!mWindow)
 		{
 			setupFailure("Window creation error", "Error", OSMB_OK);
@@ -541,20 +536,20 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 				GLint fullscreenAttrib[] =
 				{
 					AGL_RGBA,
-						AGL_FULLSCREEN,
-						//			AGL_NO_RECOVERY,	// MBW -- XXX -- Not sure if we want this attribute
-						AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
-						AGL_SAMPLES_ARB, mFSAASamples,
-						AGL_DOUBLEBUFFER,
-						AGL_CLOSEST_POLICY,
-						AGL_ACCELERATED,
-						AGL_RED_SIZE, 8,
-						AGL_GREEN_SIZE, 8,
-						AGL_BLUE_SIZE, 8,
-						AGL_ALPHA_SIZE, 8,
-						AGL_DEPTH_SIZE, 24,
-						AGL_STENCIL_SIZE, 8,
-						AGL_NONE
+					AGL_FULLSCREEN,
+					AGL_NO_RECOVERY,
+					AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
+					AGL_SAMPLES_ARB, mFSAASamples,
+					AGL_DOUBLEBUFFER,
+					AGL_CLOSEST_POLICY,
+					AGL_ACCELERATED,
+					AGL_RED_SIZE, 8,
+					AGL_GREEN_SIZE, 8,
+					AGL_BLUE_SIZE, 8,
+					AGL_ALPHA_SIZE, 8,
+					AGL_DEPTH_SIZE, 24,
+					AGL_STENCIL_SIZE, 8,
+					AGL_NONE
 				};
 
 				LL_DEBUGS("Window") << "createContext: creating fullscreen pixelformat" << LL_ENDL;
@@ -567,21 +562,28 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 			}
 			else
 			{
+				// NOTE from Leslie:
+				//
+				// AGL_NO_RECOVERY, when combined with AGL_ACCELERATED prevents software rendering
+				// fallback which means we won't hvae shaders that compile and link but then don't
+				// work.  The drawback is that our shader compilation will be a bit more finicky though.
+
 				GLint windowedAttrib[] =
 				{
 					AGL_RGBA,
-						AGL_DOUBLEBUFFER,
-						AGL_CLOSEST_POLICY,
-						AGL_ACCELERATED,
-						AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
-						AGL_SAMPLES_ARB, mFSAASamples,
-						AGL_RED_SIZE, 8,
-						AGL_GREEN_SIZE, 8,
-						AGL_BLUE_SIZE, 8,
-						AGL_ALPHA_SIZE, 8,
-						AGL_DEPTH_SIZE, 24,
-						AGL_STENCIL_SIZE, 8,
-						AGL_NONE
+					AGL_NO_RECOVERY,
+					AGL_DOUBLEBUFFER,
+					AGL_CLOSEST_POLICY,
+					AGL_ACCELERATED,
+					AGL_SAMPLE_BUFFERS_ARB, mFSAASamples > 0 ? 1 : 0,
+					AGL_SAMPLES_ARB, mFSAASamples,
+					AGL_RED_SIZE, 8,
+					AGL_GREEN_SIZE, 8,
+					AGL_BLUE_SIZE, 8,
+					AGL_ALPHA_SIZE, 8,
+					AGL_DEPTH_SIZE, 24,
+					AGL_STENCIL_SIZE, 8,
+					AGL_NONE
 				};
 
 				LL_DEBUGS("Window") << "createContext: creating windowed pixelformat" << LL_ENDL;
@@ -1093,31 +1095,22 @@ BOOL LLWindowMacOSX::getVisible()
 
 BOOL LLWindowMacOSX::getMinimized()
 {
-	BOOL result = FALSE;
-	
-	// Since the set of states where we want to act "minimized" is non-trivial, it's easier to
-	// track things locally than to try and retrieve the state from the window manager.
-	result = mMinimized;
-
-	return(result);
+	return mMinimized;
 }
 
 BOOL LLWindowMacOSX::getMaximized()
 {
-	BOOL result = FALSE;
-
-	if (mWindow)
-	{
-		// TODO
-	}
-
-	return(result);
+	return mMaximized;
 }
 
 BOOL LLWindowMacOSX::maximize()
 {
-	// TODO
-	return FALSE;
+	if (mWindow && !mMaximized)
+	{
+		ZoomWindow(mWindow, inContent, true);
+	}
+	
+	return mMaximized;
 }
 
 BOOL LLWindowMacOSX::getFullscreen()
@@ -2560,7 +2553,24 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
 
 				GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &currentBounds);
 				GetEventParameter(event, kEventParamPreviousBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &previousBounds);
-
+				
+				// Put an offset into window un-maximize operation since the kEventWindowGetIdealSize
+				// event only allows the specification of size and not position.
+				if (mMaximized)
+				{
+					short leftOffset = mPreviousWindowRect.left - currentBounds.left;
+					currentBounds.left += leftOffset;
+					currentBounds.right += leftOffset;
+					
+					short topOffset = mPreviousWindowRect.top - currentBounds.top;
+					currentBounds.top += topOffset;
+					currentBounds.bottom += topOffset;
+				}
+				else
+				{
+					// Store off the size for future un-maximize operations
+					mPreviousWindowRect = previousBounds;
+				}
 
 				if ((currentBounds.right - currentBounds.left) < MIN_WIDTH)
 				{
@@ -2579,13 +2589,43 @@ OSStatus LLWindowMacOSX::eventHandler (EventHandlerCallRef myHandler, EventRef e
 
 		case kEventWindowBoundsChanged:
 			{
+				// Get new window bounds
 				Rect newBounds;
-
 				GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &newBounds);
+				
+				// Get previous window bounds
+				Rect oldBounds;
+				GetEventParameter(event, kEventParamPreviousBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &oldBounds);
+				
+				// Determine if the new size is larger than the old
+				bool newBoundsLarger = ((newBounds.right - newBounds.left) >= (oldBounds.right - oldBounds.left));
+				newBoundsLarger &= ((newBounds.bottom - newBounds.top) >= (oldBounds.bottom - oldBounds.top));
+				
+				// Check to see if this is a zoom event (+ button on window pane)
+				unsigned int eventParams;
+				GetEventParameter(event, kEventParamAttributes, typeUInt32, NULL, sizeof(int), NULL, &eventParams);
+				bool isZoomEvent = ((eventParams & kWindowBoundsChangeZoom) != 0);
+				
+				// Maximized flag is if zoom event and increasing window size
+				mMaximized = (isZoomEvent && newBoundsLarger);
+				
 				aglUpdateContext(mContext);
+				
 				mCallbacks->handleResize(this, newBounds.right - newBounds.left, newBounds.bottom - newBounds.top);
-
-
+			}
+			break;
+			
+		case kEventWindowGetIdealSize:
+			// Only recommend a new ideal size when un-maximizing
+			if (mMaximized == TRUE)
+			{
+				Point nonMaximizedSize;
+				
+				nonMaximizedSize.v = mPreviousWindowRect.bottom - mPreviousWindowRect.top;
+				nonMaximizedSize.h = mPreviousWindowRect.right - mPreviousWindowRect.left;
+				
+				SetEventParameter(event, kEventParamDimensions, typeQDPoint, sizeof(Point), &nonMaximizedSize);
+				result = noErr;
 			}
 			break;
 
diff --git a/indra/llwindow/llwindowmacosx.h b/indra/llwindow/llwindowmacosx.h
index 6dc093b4be..6c9e075a21 100644
--- a/indra/llwindow/llwindowmacosx.h
+++ b/indra/llwindow/llwindowmacosx.h
@@ -156,7 +156,6 @@ protected:
 	static pascal Boolean staticMoveEventComparator( EventRef event, void* data);
 	OSStatus eventHandler (EventHandlerCallRef myHandler, EventRef event);
 	void adjustCursorDecouple(bool warpingMouse = false);
-	void fixWindowSize(void);
 	void stopDockTileBounce();
 	static MASK modifiersToMask(SInt16 modifiers);
 	
@@ -182,6 +181,7 @@ protected:
 	EventComparatorUPP  mMoveEventCampartorUPP;
 	
 	Rect		mOldMouseClip;  // Screen rect to which the mouse cursor was globally constrained before we changed it in clipMouse()
+	Rect		mPreviousWindowRect;  // Save previous window for un-maximize event
 	Str255 		mWindowTitle;
 	double		mOriginalAspectRatio;
 	BOOL		mSimulatedRightClick;
@@ -195,6 +195,7 @@ protected:
 	BOOL		mNeedsResize;		// Constructor figured out the window is too big, it needs a resize.
 	LLCoordScreen   mNeedsResizeSize;
 	F32			mOverrideAspectRatio;
+	BOOL		mMaximized;
 	BOOL		mMinimized;
 	U32			mFSAASamples;
 	BOOL		mForceRebuild;
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index aba0dc43eb..20286b4ca8 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -500,6 +500,8 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
 	//-----------------------------------------------------------------------
 
 	DEVMODE dev_mode;
+	::ZeroMemory(&dev_mode, sizeof(DEVMODE));
+	dev_mode.dmSize = sizeof(DEVMODE);
 	DWORD current_refresh;
 	if (EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dev_mode))
 	{
@@ -878,6 +880,8 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 {
 	GLuint	pixel_format;
 	DEVMODE dev_mode;
+	::ZeroMemory(&dev_mode, sizeof(DEVMODE));
+	dev_mode.dmSize = sizeof(DEVMODE);
 	DWORD	current_refresh;
 	DWORD	dw_ex_style;
 	DWORD	dw_style;
@@ -2711,6 +2715,8 @@ LLWindow::LLWindowResolution* LLWindowWin32::getSupportedResolutions(S32 &num_re
 	{
 		mSupportedResolutions = new LLWindowResolution[MAX_NUM_RESOLUTIONS];
 		DEVMODE dev_mode;
+		::ZeroMemory(&dev_mode, sizeof(DEVMODE));
+		dev_mode.dmSize = sizeof(DEVMODE);
 
 		mNumSupportedResolutions = 0;
 		for (S32 mode_num = 0; mNumSupportedResolutions < MAX_NUM_RESOLUTIONS; mode_num++)
@@ -2786,7 +2792,8 @@ F32 LLWindowWin32::getPixelAspectRatio()
 BOOL LLWindowWin32::setDisplayResolution(S32 width, S32 height, S32 bits, S32 refresh)
 {
 	DEVMODE dev_mode;
-	dev_mode.dmSize = sizeof(dev_mode);
+	::ZeroMemory(&dev_mode, sizeof(DEVMODE));
+	dev_mode.dmSize = sizeof(DEVMODE);
 	BOOL success = FALSE;
 
 	// Don't change anything if we don't have to