18 files changed, 432 insertions, 579 deletions

diff --git a/linden/indra/llwindow/files.linux.lst b/linden/indra/llwindow/files.linux.lst
index e41ac2a..a2dfa07 100644
--- a/linden/indra/llwindow/files.linux.lst
+++ b/linden/indra/llwindow/files.linux.lst
@@ -1,4 +1,3 @@
 llwindow/llkeyboardsdl.cpp
 llwindow/llwindowsdl.cpp
-llwindow/llwindowlinux.cpp
 llwindow/llwindowmesaheadless.cpp
diff --git a/linden/indra/llwindow/files.sunos5.lst b/linden/indra/llwindow/files.sunos5.lst
index ee20b05..a2dfa07 100644
--- a/linden/indra/llwindow/files.sunos5.lst
+++ b/linden/indra/llwindow/files.sunos5.lst
@@ -1,4 +1,3 @@
 llwindow/llkeyboardsdl.cpp
 llwindow/llwindowsdl.cpp
-llwindow/llwindowsolaris.cpp
 llwindow/llwindowmesaheadless.cpp
diff --git a/linden/indra/llwindow/lldxhardware.cpp b/linden/indra/llwindow/lldxhardware.cpp
index 4eb8cab..c2d94c3 100644
--- a/linden/indra/llwindow/lldxhardware.cpp
+++ b/linden/indra/llwindow/lldxhardware.cpp
@@ -304,7 +304,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
         IDxDiagContainer *driver_containerp = NULL;
 
     // CoCreate a IDxDiagProvider*
-        llinfos << "CoCreateInstance IID_IDxDiagProvider" << llendl;
+        LL_DEBUGS("AppInit") << "CoCreateInstance IID_IDxDiagProvider" << LL_ENDL;
     hr = CoCreateInstance(CLSID_DxDiagProvider,
                           NULL,
                           CLSCTX_INPROC_SERVER,
@@ -313,7 +313,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
 
         if (FAILED(hr))
         {
-                llwarns << "No DXDiag provider found!  DirectX 9 not installed!" << llendl;
+                LL_WARNS("AppInit") << "No DXDiag provider found!  DirectX 9 not installed!" << LL_ENDL;
                 gWriteDebug("No DXDiag provider found!  DirectX 9 not installed!\n");
                 goto LCleanup;
         }
@@ -331,14 +331,14 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
         dx_diag_init_params.bAllowWHQLChecks        = TRUE;
         dx_diag_init_params.pReserved               = NULL;
 
-                llinfos << "dx_diag_providerp->Initialize" << llendl;
+                LL_DEBUGS("AppInit") << "dx_diag_providerp->Initialize" << LL_ENDL;
         hr = dx_diag_providerp->Initialize(&dx_diag_init_params);
         if(FAILED(hr))
                 {
             goto LCleanup;
                 }
 
-                llinfos << "dx_diag_providerp->GetRootContainer" << llendl;
+                LL_DEBUGS("AppInit") << "dx_diag_providerp->GetRootContainer" << LL_ENDL;
         hr = dx_diag_providerp->GetRootContainer( &dx_diag_rootp );
         if(FAILED(hr) || !dx_diag_rootp)
                 {
@@ -348,7 +348,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
                 HRESULT hr;
 
                 // Get display driver information
-                llinfos << "dx_diag_rootp->GetChildContainer" << llendl;
+                LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer" << LL_ENDL;
                 hr = dx_diag_rootp->GetChildContainer(L"DxDiag_DisplayDevices", &devices_containerp);
                 if(FAILED(hr) || !devices_containerp)
                 {
@@ -356,7 +356,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
                 }
 
                 // Get device 0
-                llinfos << "devices_containerp->GetChildContainer" << llendl;
+                LL_DEBUGS("AppInit") << "devices_containerp->GetChildContainer" << LL_ENDL;
                 hr = devices_containerp->GetChildContainer(L"0", &device_containerp);
                 if(FAILED(hr) || !device_containerp)
                 {
@@ -373,10 +373,9 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
                   // Dump the string as an int into the structure
                   char *stopstring;
                   mVRAM = strtol(ram_str.c_str(), &stopstring, 10); 
-                  llinfos << "VRAM Detected: " << mVRAM << " DX9 string: " << ram_str << llendl;
+                  LL_INFOS("AppInit") << "VRAM Detected: " << mVRAM << " DX9 string: " << ram_str << LL_ENDL;
                 }
 
-                
                 if (vram_only)
                 {
                         ok = TRUE;
@@ -393,7 +392,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
                 // This call may take some time while dxdiag gathers the info.
                 DWORD num_devices = 0;
             WCHAR wszContainer[256];
-                llinfos << "dx_diag_rootp->GetChildContainer DxDiag_SystemDevices" << llendl;
+                LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer DxDiag_SystemDevices" << LL_ENDL;
                 hr = dx_diag_rootp->GetChildContainer(L"DxDiag_SystemDevices", &system_device_containerp);
                 if (FAILED(hr))
                 {
@@ -406,7 +405,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
                         goto LCleanup;
                 }
 
-                llinfos << "DX9 iterating over devices" << llendl;
+                LL_DEBUGS("AppInit") << "DX9 iterating over devices" << LL_ENDL;
                 S32 device_num = 0;
                 for (device_num = 0; device_num < (S32)num_devices; device_num++)
                 {
@@ -523,7 +522,7 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
 LCleanup:
         if (!ok)
         {
-                llwarns << "DX9 probe failed" << llendl;
+                LL_WARNS("AppInit") << "DX9 probe failed" << LL_ENDL;
                 gWriteDebug("DX9 probe failed\n");
         }
 
diff --git a/linden/indra/llwindow/llgl.cpp b/linden/indra/llwindow/llgl.cpp
index 229fdf2..e8169b6 100644
--- a/linden/indra/llwindow/llgl.cpp
+++ b/linden/indra/llwindow/llgl.cpp
@@ -41,7 +41,7 @@
 #include "llsys.h"
 
 #include "llgl.h"
-#include "llglimmediate.h"
+#include "llrender.h"
 
 #include "llerror.h"
 #include "llquaternion.h"
@@ -55,6 +55,7 @@
 //#define GL_STATE_VERIFY
 #endif
 
+BOOL gDebugGL = FALSE;
 BOOL gClothRipple = FALSE;
 BOOL gNoRender = FALSE;
 LLMatrix4 gGLObliqueProjectionInverse;
@@ -253,50 +254,50 @@ PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
 
 LLGLManager gGLManager;
 
-LLGLManager::LLGLManager()
-{
-        mInited = FALSE;
-        mIsDisabled = FALSE;
-        mHasCubeMap = FALSE;
-        mHasMultitexture = FALSE;
-        mHasMipMapGeneration = FALSE;
-        mHasAnisotropic = FALSE;
-        mHasCompressedTextures = FALSE;
-        mHasARBEnvCombine = FALSE;
-        mIsGF2or4MX = FALSE;
-        mIsGF3 = FALSE;
-        mIsGFFX = FALSE;
-        mIsATI = FALSE;
-        mATIOffsetVerticalLines = FALSE;
-        mHasVertexShader = FALSE;
-        mHasFragmentShader = FALSE;
-        mHasShaderObjects = FALSE;
-        mHasPointParameters = FALSE;
-
-#if LL_WINDOWS
-        mHasWGLARBPixelFormat = FALSE;
-#endif // LL_WINDOWS
-
-#if LL_DARWIN
-        mHasAPPLEVertexArrayRange = FALSE;
-        mHasAPPLEFence = FALSE;
-        mHasAPPLEVAO = FALSE;
-#endif
-
-        mIsNVIDIA = FALSE;
-        mIsIntel = FALSE;
+LLGLManager::LLGLManager() :
+        mInited(FALSE),
+        mIsDisabled(FALSE),
+
+        mHasMultitexture(FALSE),
+        mNumTextureUnits(1),
+        mHasMipMapGeneration(FALSE),
+        mHasPalettedTextures(FALSE),
+        mHasCompressedTextures(FALSE),
+        mHasFramebufferObject(FALSE),
+
+        mHasVertexBufferObject(FALSE),
+        mHasPBuffer(FALSE),
+        mHasShaderObjects(FALSE),
+        mHasVertexShader(FALSE),
+        mHasFragmentShader(FALSE),
+        mHasOcclusionQuery(FALSE),
+        mHasPointParameters(FALSE),
+
+        mHasAnisotropic(FALSE),
+        mHasARBEnvCombine(FALSE),
+        mHasCubeMap(FALSE),
+
+        mIsATI(FALSE),
+        mIsNVIDIA(FALSE),
+        mIsIntel(FALSE),
+        mIsGF2or4MX(FALSE),
+        mIsGF3(FALSE),
+        mIsGFFX(FALSE),
+        mATIOffsetVerticalLines(FALSE),
+
+        mHasRequirements(TRUE),
+
+        mHasSeparateSpecularColor(FALSE),
+
+        mDriverVersionMajor(1),
+        mDriverVersionMinor(0),
+        mDriverVersionRelease(0),
+        mGLVersion(1.0f),
                 
-        mDriverVersionMajor = 1;
-        mDriverVersionMinor = 0;
-        mDriverVersionRelease = 0;
-        mGLVersion = 1.0f;
-        
-        mNumTextureUnits = 1;
-        mVRAM = 0;
-        mGLMaxVertexRange = 0;
-        mGLMaxIndexRange = 0;
-
-        mHasRequirements = TRUE;
+        mVRAM(0),
+        mGLMaxVertexRange(0),
+        mGLMaxIndexRange(0)
+{
 }
 
 //---------------------------------------------------------------------
@@ -308,7 +309,7 @@ void LLGLManager::initWGL()
 #if LL_WINDOWS && !LL_MESA_HEADLESS
         if (!glh_init_extensions("WGL_ARB_pixel_format"))
         {
-                llwarns << "No ARB pixel format extensions" << llendl;
+                LL_WARNS("RenderInit") << "No ARB pixel format extensions" << LL_ENDL;
         }
 
         if (ExtensionExists("WGL_EXT_swap_control", gGLHExts.mSysExts))
@@ -316,15 +317,14 @@ void LLGLManager::initWGL()
         GLH_EXT_NAME(wglSwapIntervalEXT) = (PFNWGLSWAPINTERVALEXTPROC)GLH_EXT_GET_PROC_ADDRESS("wglSwapIntervalEXT");
         }
 
-        mHasWGLARBPixelFormat = glh_init_extensions("WGL_ARB_pbuffer");
-        if( !mHasWGLARBPixelFormat )
+        if( !glh_init_extensions("WGL_ARB_pbuffer") )
         {
-                llwarns << "No ARB WGL PBuffer extensions" << llendl;
+                LL_WARNS("RenderInit") << "No ARB WGL PBuffer extensions" << LL_ENDL;
         }
 
         if( !glh_init_extensions("WGL_ARB_render_texture") )
         {
-                llwarns << "No ARB WGL render texture extensions" << llendl;
+                LL_WARNS("RenderInit") << "No ARB WGL render texture extensions" << LL_ENDL;
         }
 
         mHasPBuffer = ExtensionExists("WGL_ARB_pbuffer", gGLHExts.mSysExts) &&
@@ -338,19 +338,15 @@ bool LLGLManager::initGL()
 {
         if (mInited)
         {
-                llerrs << "Calling init on LLGLManager after already initialized!" << llendl;
+                LL_ERRS("RenderInit") << "Calling init on LLGLManager after already initialized!" << LL_ENDL;
         }
 
         GLint alpha_bits;
         glGetIntegerv( GL_ALPHA_BITS, &alpha_bits );
         if( 8 != alpha_bits )
         {
-                llwarns << "Frame buffer has less than 8 bits of alpha.  Avatar texture compositing will fail." << llendl;
+                LL_WARNS("RenderInit") << "Frame buffer has less than 8 bits of alpha.  Avatar texture compositing will fail." << LL_ENDL;
         }
-        
-        // This function uses at least one variable that's initialized below.
-        // Moved this call down to after we figure out which card we're dealing with.  -- MBW 2003.10.07
-//      initExtensions();
 
         // Extract video card strings and convert to upper case to
         // work around driver-to-driver variation in capitalization.
@@ -445,7 +441,7 @@ bool LLGLManager::initGL()
                 mHasRequirements = FALSE;
 
                 // We don't support cards that don't support the GL_ARB_multitexture extension
-                llwarns << "GL Drivers do not support GL_ARB_multitexture" << llendl;
+                LL_WARNS("RenderInit") << "GL Drivers do not support GL_ARB_multitexture" << LL_ENDL;
                 return false;
         }
         
@@ -489,6 +485,22 @@ LLString LLGLManager::getGLInfoString()
         return info_str;
 }
 
+void LLGLManager::printGLInfoString()
+{
+        LLString info_str;
+        LLString all_exts, line;
+        
+        LL_INFOS("RenderInit") << "GL_VENDOR:     " << ((const char *)glGetString(GL_VENDOR)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_RENDERER:   " << ((const char *)glGetString(GL_RENDERER)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_VERSION:    " << ((const char *)glGetString(GL_VERSION)) << LL_ENDL;
+
+#if !LL_MESA_HEADLESS
+        all_exts = (const char *)gGLHExts.mSysExts;
+        LLString::replaceChar(all_exts, ' ', '\n');
+        LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:\n" << all_exts << LL_ENDL;
+#endif
+}
+
 LLString LLGLManager::getRawGLString()
 {
         LLString gl_string;
@@ -595,8 +607,7 @@ void LLGLManager::initExtensions()
                 mHasShaderObjects = FALSE;
                 mHasVertexShader = FALSE;
                 mHasFragmentShader = FALSE;
-                llwarns << "GL extension support DISABLED via LL_GL_NOEXT" <<
-                        llendl;
+                LL_WARNS("RenderInit") << "GL extension support DISABLED via LL_GL_NOEXT" << LL_ENDL;
         }
         else if (getenv("LL_GL_BASICEXT"))      /* Flawfinder: ignore */
         {
@@ -612,8 +623,7 @@ void LLGLManager::initExtensions()
                 mHasShaderObjects = FALSE;
                 mHasVertexShader = FALSE;
                 mHasFragmentShader = FALSE;
-                llwarns << "GL extension support forced to SIMPLE level via LL_GL_BASICEXT" <<
-                        llendl;
+                LL_WARNS("RenderInit") << "GL extension support forced to SIMPLE level via LL_GL_BASICEXT" << LL_ENDL;
         }
         if (getenv("LL_GL_BLACKLIST"))  /* Flawfinder: ignore */
         {
@@ -621,7 +631,7 @@ void LLGLManager::initExtensions()
                 // GL extensions to isolate problems with their hardware.
                 // SL-28126
                 const char *const blacklist = getenv("LL_GL_BLACKLIST");        /* Flawfinder: ignore */
-                llwarns << "GL extension support partially disabled via LL_GL_BLACKLIST: " << blacklist << llendl;
+                LL_WARNS("RenderInit") << "GL extension support partially disabled via LL_GL_BLACKLIST: " << blacklist << LL_ENDL;
                 if (strchr(blacklist,'a')) mHasARBEnvCombine = FALSE;
                 if (strchr(blacklist,'b')) mHasCompressedTextures = FALSE;
                 if (strchr(blacklist,'c')) mHasVertexBufferObject = FALSE;
@@ -651,62 +661,62 @@ void LLGLManager::initExtensions()
         
         if (!mHasMultitexture)
         {
-                llinfos << "Couldn't initialize multitexturing" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize multitexturing" << LL_ENDL;
         }
         if (!mHasMipMapGeneration)
         {
-                llinfos << "Couldn't initialize mipmap generation" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize mipmap generation" << LL_ENDL;
         }
         if (!mHasARBEnvCombine)
         {
-                llinfos << "Couldn't initialize GL_ARB_texture_env_combine" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_env_combine" << LL_ENDL;
         }
         if (!mHasPalettedTextures)
         {
-                llinfos << "Couldn't initialize GL_EXT_paletted_texture" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_EXT_paletted_texture" << LL_ENDL;
         }
         if (!mHasSeparateSpecularColor)
         {
-                llinfos << "Couldn't initialize separate specular color" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize separate specular color" << LL_ENDL;
         }
         if (!mHasAnisotropic)
         {
-                llinfos << "Couldn't initialize anisotropic filtering" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize anisotropic filtering" << LL_ENDL;
         }
         if (!mHasCompressedTextures)
         {
-                llinfos << "Couldn't initialize GL_ARB_texture_compression" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_compression" << LL_ENDL;
         }
         if (!mHasOcclusionQuery)
         {
-                llinfos << "Couldn't initialize GL_ARB_occlusion_query" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_occlusion_query" << LL_ENDL;
         }
         if (!mHasPointParameters)
         {
-                llinfos << "Couldn't initialize GL_ARB_point_parameters" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_point_parameters" << LL_ENDL;
         }
         if (!mHasShaderObjects)
         {
-                llinfos << "Couldn't initialize GL_ARB_shader_objects" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_shader_objects" << LL_ENDL;
         }
         if (!mHasVertexShader)
         {
-                llinfos << "Couldn't initialize GL_ARB_vertex_shader" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_vertex_shader" << LL_ENDL;
         }
         if (!mHasFragmentShader)
         {
-                llinfos << "Couldn't initialize GL_ARB_fragment_shader" << llendl;
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_fragment_shader" << LL_ENDL;
         }
 
         // Disable certain things due to known bugs
         if (mIsIntel && mHasMipMapGeneration)
         {
-                llinfos << "Disabling mip-map generation for Intel GPUs" << llendl;
+                LL_INFOS("RenderInit") << "Disabling mip-map generation for Intel GPUs" << LL_ENDL;
                 mHasMipMapGeneration = FALSE;
         }
         if (mIsATI && mHasMipMapGeneration)
         {
-                llinfos << "Disabling mip-map generation for ATI GPUs (performance opt)" << llendl;
+                LL_INFOS("RenderInit") << "Disabling mip-map generation for ATI GPUs (performance opt)" << LL_ENDL;
                 mHasMipMapGeneration = FALSE;
         }
         
@@ -714,30 +724,8 @@ void LLGLManager::initExtensions()
         glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
         glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
         
-        // Apple specific
-#if LL_DARWIN
-        mHasAPPLEVertexArrayRange = glh_init_extensions("GL_APPLE_vertex_array_range");
-        if (!mHasAPPLEVertexArrayRange)
-        {
-                llinfos << "Couldn't initialize GL_APPLE_vertex_array_range" << llendl;
-        }
-
-        mHasAPPLEFence = glh_init_extensions("GL_APPLE_fence");
-        if (!mHasAPPLEFence)
-        {
-                llinfos << "Couldn't initialize GL_APPLE_fence" << llendl;
-        }
-        
-        mHasAPPLEVAO = glh_init_extensions("GL_APPLE_vertex_array_object");
-        if (mHasAPPLEVAO)
-        {
-                llinfos << "Has GL_APPLE_vertex_array_object!" << llendl;
-        }
-
-#endif // LL_DARWIN
-
 #if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
-        llinfos << "GL Probe: Getting symbols" << llendl;
+        LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
         if (mHasVertexBufferObject)
         {
                 glBindBufferARB = (PFNGLBINDBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBindBufferARB");
@@ -921,7 +909,7 @@ void LLGLManager::initExtensions()
                 glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glgetVertexAttribPointervARB");
                 glIsProgramARB = (PFNGLISPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glIsProgramARB");
         }
-        llinfos << "GL Probe: Got symbols" << llendl;
+        LL_DEBUGS("RenderInit") << "GL Probe: Got symbols" << LL_ENDL;
 #endif
 
         mInited = TRUE;
@@ -941,33 +929,41 @@ void flush_glerror()
 
 void assert_glerror()
 {
-        if (gNoRender) 
+        if (gNoRender || !gDebugGL) 
         {
                 return;
         }
         if (!gGLManager.mInited)
         {
-                llerrs << "GL not initialized" << llendl;
+                LL_ERRS("RenderInit") << "GL not initialized" << LL_ENDL;
         }
         //  Create or update texture to be used with this data 
         GLenum error;
         error = glGetError();
-        if (error)
+        BOOL quit = FALSE;
+        while (error)
         {
+                quit = TRUE;
 #ifndef LL_LINUX // *FIX: !  This should be an error for linux as well.
                 GLubyte const * gl_error_msg = gluErrorString(error);
                 if (NULL != gl_error_msg)
                 {
-                        llerrs << "GL Error:" << gl_error_msg << llendl;
+                        LL_WARNS("RenderState") << "GL Error:" << gl_error_msg << LL_ENDL;
                 }
                 else
                 {
                         // gluErrorString returns NULL for some extensions' error codes.
                         // you'll probably have to grep for the number in glext.h.
-                        llerrs << "GL Error: UNKNOWN 0x" << std::hex << error << llendl;
+                        LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << LL_ENDL;
                 }
+                error = glGetError();
 #endif
         }
+
+        if (quit)
+        {
+                llerrs << "One or more unhandled GL errors." << llendl;
+        }
 }
 
 void clear_glerror()
@@ -977,8 +973,7 @@ void clear_glerror()
         error = glGetError();
 }
 
-//============================================================================
-
+///////////////////////////////////////////////////////////////
 //
 // LLGLState
 //
@@ -1014,7 +1009,7 @@ void LLGLState::resetTextureStates()
         glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
         for (S32 j = maxTextureUnits-1; j >=0; j--)
         {
-                glActiveTextureARB(GL_TEXTURE0_ARB+j);
+                gGL.getTexUnit(j)->activate();
                 glClientActiveTextureARB(GL_TEXTURE0_ARB+j);
                 j == 0 ? glEnable(GL_TEXTURE_2D) : glDisable(GL_TEXTURE_2D);
         }
@@ -1022,17 +1017,21 @@ void LLGLState::resetTextureStates()
 
 void LLGLState::dumpStates() 
 {
-        llinfos << "GL States:" << llendl;
+        LL_INFOS("RenderState") << "GL States:" << LL_ENDL;
         for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
                  iter != sStateMap.end(); ++iter)
         {
-                llinfos << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << llendl;
+                LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
         }
 }
 
 void LLGLState::checkStates()  
 {
-#if LL_DEBUG_GL
+        if (!gDebugGL)
+        {
+                return;
+        }
+
         stop_glerror();
 
         GLint activeTexture;
@@ -1040,7 +1039,7 @@ void LLGLState::checkStates()
         
         if (activeTexture != GL_TEXTURE0_ARB)
         {
-                LL_GL_ERRS << "Texture channel corrupted. " << llendl;
+                LL_GL_ERRS << "Texture channel corrupted. " << LL_ENDL;
         }
         
         GLint src;
@@ -1050,7 +1049,7 @@ void LLGLState::checkStates()
         
         if (src != GL_SRC_ALPHA || dst != GL_ONE_MINUS_SRC_ALPHA)
         {
-                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << llendl;
+                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << LL_ENDL;
         }
         
         for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
@@ -1062,17 +1061,20 @@ void LLGLState::checkStates()
                 if(cur_state != gl_state)
                 {
                         dumpStates();
-                        LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << llendl;
+                        LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << LL_ENDL;
                 }
         }
         
         stop_glerror();
-#endif
 }
 
 void LLGLState::checkTextureChannels()
 {
-#if LL_DEBUG_GL
+        if (!gDebugGL)
+        {
+                return;
+        }
+
         GLint activeTexture;
         glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTexture);
         
@@ -1081,12 +1083,12 @@ void LLGLState::checkTextureChannels()
         if (activeTexture != GL_TEXTURE0_ARB)
         {
                 error = TRUE;
-                llwarns << "Active texture channel corrupted. " << llendl;
+                LL_WARNS("RenderState") << "Active texture channel corrupted. " << LL_ENDL;
         }
         else if (!glIsEnabled(GL_TEXTURE_2D))
         {
                 error = TRUE;
-                llwarns << "GL_TEXTURE_2D not enabled on texture channel 0." << llendl;
+                LL_WARNS("RenderState") << "GL_TEXTURE_2D not enabled on texture channel 0." << LL_ENDL;
         }
         else 
         {
@@ -1096,7 +1098,7 @@ void LLGLState::checkTextureChannels()
                 if (tex_env_mode != GL_MODULATE)
                 {
                         error = TRUE;
-                        llwarns << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << llendl;
+                        LL_WARNS("RenderState") << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << LL_ENDL;
                 }
         }
 
@@ -1133,7 +1135,7 @@ void LLGLState::checkTextureChannels()
 
         for (GLint i = 0; i < maxTextureUnits; i++)
         {
-                glActiveTextureARB(GL_TEXTURE0_ARB+i);
+                gGL.getTexUnit(i)->activate();
                 glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
 
                 glGetIntegerv(GL_TEXTURE_STACK_DEPTH, &stackDepth);
@@ -1141,7 +1143,7 @@ void LLGLState::checkTextureChannels()
                 if (stackDepth != 1)
                 {
                         error = TRUE;
-                        llwarns << "Texture matrix stack corrupted." << llendl;
+                        LL_WARNS("RenderState") << "Texture matrix stack corrupted." << LL_ENDL;
                 }
 
                 glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) matrix.mMatrix);
@@ -1149,7 +1151,7 @@ void LLGLState::checkTextureChannels()
                 if (matrix != identity)
                 {
                         error = TRUE;
-                        llwarns << "Texture matrix in channel " << i << " corrupt." << llendl;
+                        LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
                 }
 
                 for (S32 j = (i == 0 ? 1 : 0); j < 8; j++)
@@ -1157,24 +1159,27 @@ void LLGLState::checkTextureChannels()
                         if (glIsEnabled(value[j]))
                         {
                                 error = TRUE;
-                                llwarns << "Texture channel " << i << " still has " << label[j] << " enabled." << llendl;
+                                LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
                         }
                 }
         }
 
-        glActiveTextureARB(GL_TEXTURE0_ARB);
+        gGL.getTexUnit(0)->activate();
         glClientActiveTextureARB(GL_TEXTURE0_ARB);
 
         if (error)
         {
-                LL_GL_ERRS << "GL texture state corruption detected." << llendl;
+                LL_GL_ERRS << "GL texture state corruption detected." << LL_ENDL;
         }
-#endif
 }
 
 void LLGLState::checkClientArrays(U32 data_mask)
 {
-#if LL_DEBUG_GL
+        if (!gDebugGL)
+        {
+                return;
+        }
+
         stop_glerror();
         BOOL error = FALSE;
 
@@ -1226,7 +1231,7 @@ void LLGLState::checkClientArrays(U32 data_mask)
                         if (!(mask[j] & data_mask))
                         {
                                 error = TRUE;
-                                llwarns << "GL still has " << label[j] << " enabled." << llendl;
+                                LL_WARNS("RenderState") << "GL still has " << label[j] << " enabled." << LL_ENDL;
                         }
                 }
                 else
@@ -1234,19 +1239,19 @@ void LLGLState::checkClientArrays(U32 data_mask)
                         if (mask[j] & data_mask)
                         {
                                 error = TRUE;
-                                llwarns << "GL does not have " << label[j] << " enabled." << llendl;
+                                LL_WARNS("RenderState") << "GL does not have " << label[j] << " enabled." << LL_ENDL;
                         }
                 }
         }
 
         glClientActiveTextureARB(GL_TEXTURE1_ARB);
-        glActiveTextureARB(GL_TEXTURE1_ARB);
+        gGL.getTexUnit(1)->activate();
         if (glIsEnabled(GL_TEXTURE_COORD_ARRAY))
         {
                 if (!(data_mask & 0x0008))
                 {
                         error = TRUE;
-                        llwarns << "GL still has GL_TEXTURE_COORD_ARRAY enabled on channel 1." << llendl;
+                        LL_WARNS("RenderState") << "GL still has GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
                 }
         }
         else
@@ -1254,7 +1259,7 @@ void LLGLState::checkClientArrays(U32 data_mask)
                 if (data_mask & 0x0008)
                 {
                         error = TRUE;
-                        llwarns << "GL does not have GL_TEXTURE_COORD_ARRAY enabled on channel 1." << llendl;
+                        LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
                 }
         }
 
@@ -1263,7 +1268,7 @@ void LLGLState::checkClientArrays(U32 data_mask)
                 if (!(data_mask & 0x0008))
                 {
                         error = TRUE;
-                        llwarns << "GL still has GL_TEXTURE_2D enabled on channel 1." << llendl;
+                        LL_WARNS("RenderState") << "GL still has GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
                 }
         }
         else
@@ -1271,26 +1276,25 @@ void LLGLState::checkClientArrays(U32 data_mask)
                 if (data_mask & 0x0008)
                 {
                         error = TRUE;
-                        llwarns << "GL does not have GL_TEXTURE_2D enabled on channel 1." << llendl;
+                        LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
                 }
         }
 
         glClientActiveTextureARB(GL_TEXTURE0_ARB);
-        glActiveTextureARB(GL_TEXTURE0_ARB);
+        gGL.getTexUnit(0)->activate();
 
         if (error)
         {
-                LL_GL_ERRS << "GL client array corruption detected." << llendl;
+                LL_GL_ERRS << "GL client array corruption detected." << LL_ENDL;
         }
-#endif
 }
 
-//============================================================================
+///////////////////////////////////////////////////////////////////////
 
-LLGLState::LLGLState(LLGLenum state, S32 enabled)
+LLGLState::LLGLState(LLGLenum state, S32 enabled) :
+        mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
 {
         stop_glerror();
-        mState = state;
         if (state)
         {
                 mWasEnabled = sStateMap[state];
@@ -1330,9 +1334,11 @@ LLGLState::~LLGLState()
         stop_glerror();
         if (mState)
         {
-#if LL_DEBUG_GL
-                llassert(sStateMap[mState] == glIsEnabled(mState));
-#endif
+                if (gDebugGL)
+                {
+                        llassert_always(sStateMap[mState] == glIsEnabled(mState));
+                }
+
                 if (mIsEnabled != mWasEnabled)
                 {
                         gGL.flush();
@@ -1351,7 +1357,7 @@ LLGLState::~LLGLState()
         stop_glerror();
 }
 
-//============================================================================
+////////////////////////////////////////////////////////////////////////////////
 
 void LLGLManager::initGLStates()
 {
@@ -1359,7 +1365,7 @@ void LLGLManager::initGLStates()
         LLGLState::initClass();
 }
 
-//============================================================================
+////////////////////////////////////////////////////////////////////////////////
 
 void enable_vertex_weighting(const S32 index)
 {
diff --git a/linden/indra/llwindow/llgl.h b/linden/indra/llwindow/llgl.h
index e8f17bf..2618dca 100644
--- a/linden/indra/llwindow/llgl.h
+++ b/linden/indra/llwindow/llgl.h
@@ -48,9 +48,9 @@
 #include "llglheaders.h"
 #include "glh/glh_linear.h"
 
-#define LL_DEBUG_GL 1
+extern BOOL gDebugGL;
 
-#define LL_GL_ERRS llerrs
+#define LL_GL_ERRS LL_ERRS("RenderState")
 
 class LLSD;
 
@@ -92,7 +92,7 @@ public:
         BOOL mHasARBEnvCombine;
         BOOL mHasCubeMap;
 
-        // Vender specific extensions
+        // Vendor-specific extensions
         BOOL mIsATI;
         BOOL mIsNVIDIA;
         BOOL mIsIntel;
@@ -104,18 +104,7 @@ public:
         // Whether this version of GL is good enough for SL to use
         BOOL mHasRequirements;
 
-#if LL_WINDOWS
-        BOOL mHasWGLARBPixelFormat;
-#endif // LL_WINDOWS
-
-#if LL_DARWIN
-        // Apple extensions.
-        BOOL mHasAPPLEVertexArrayRange;
-        BOOL mHasAPPLEFence;
-        BOOL mHasAPPLEVAO;
-#endif
-
-        // Misc exitensions
+        // Misc extensions
         BOOL mHasSeparateSpecularColor;
         
         S32 mDriverVersionMajor;
@@ -131,6 +120,7 @@ public:
         void getPixelFormat(); // Get the best pixel format
 
         LLString getGLInfoString();
+        void printGLInfoString();
         void getGLInfo(LLSD& info);
 
         // In ALL CAPS
@@ -159,13 +149,13 @@ void assert_glerror();
 
 void clear_glerror();
 
-#if LL_DEBUG
+//#if LL_DEBUG
 # define stop_glerror() assert_glerror()
 # define llglassertok() assert_glerror()
-#else
-# define stop_glerror()
-# define llglassertok()
-#endif
+//#else
+//# define stop_glerror()
+//# define llglassertok()
+//#endif
 
 #define llglassertok_always() assert_glerror()
 
diff --git a/linden/indra/llwindow/llwindow.cpp b/linden/indra/llwindow/llwindow.cpp
index 9963228..ffb6393 100644
--- a/linden/indra/llwindow/llwindow.cpp
+++ b/linden/indra/llwindow/llwindow.cpp
@@ -40,8 +40,6 @@
 #include "llwindowwin32.h"
 #elif LL_DARWIN
 #include "llwindowmacosx.h"
-#elif LL_LINUX
-#include "llwindowlinux.h" // currently just a dummy wrapper
 #endif
 
 #include "llerror.h"
@@ -287,6 +285,20 @@ void LLWindow::setCallbacks(LLWindowCallbacks *callbacks)
         }
 }
 
+// static
+std::string LLWindow::getFontListSans()
+{
+#if LL_WINDOWS
+        return LLWindowWin32::getFontListSans();
+#elif LL_DARWIN
+        return LLWindowMacOSX::getFontListSans();
+#elif LL_SDL
+        return LLWindowSDL::getFontListSans();
+#else
+        return "";
+#endif
+}
+
 #define UTF16_IS_HIGH_SURROGATE(U) ((U16)((U) - 0xD800) < 0x0400)
 #define UTF16_IS_LOW_SURROGATE(U)  ((U16)((U) - 0xDC00) < 0x0400)
 #define UTF16_SURROGATE_PAIR_TO_UTF32(H,L) (((H) << 10) + (L) - (0xD800 << 10) - 0xDC00 + 0x00010000)
@@ -450,10 +462,6 @@ LLWindow* LLWindowManager::createWindow(
                 new_window = new LLWindowMacOSX(
                         title, name, x, y, width, height, flags, 
                         fullscreen, clearBg, disable_vsync, use_gl, ignore_pixel_depth, fsaa_samples);
-#elif LL_LINUX
-                new_window = new LLWindowLinux(
-                        title, name, x, y, width, height, flags, 
-                        fullscreen, clearBg, disable_vsync, use_gl, ignore_pixel_depth);
 #endif
         }
         else
diff --git a/linden/indra/llwindow/llwindow.h b/linden/indra/llwindow/llwindow.h
index 89de5a0..a63c8d5 100644
--- a/linden/indra/llwindow/llwindow.h
+++ b/linden/indra/llwindow/llwindow.h
@@ -234,6 +234,8 @@ public:
         virtual void updateLanguageTextInputArea() {}
         virtual void interruptLanguageTextInput() {}
 
+        static std::string getFontListSans();
+
 protected:
         LLWindow(BOOL fullscreen, U32 flags);
         virtual ~LLWindow() {}
diff --git a/linden/indra/llwindow/llwindowlinux.h b/linden/indra/llwindow/llwindowlinux.h
deleted file mode 100644
index da80fd4..0000000
--- a/linden/indra/llwindow/llwindowlinux.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/** 
- * @file llwindowlinux.h
- * @brief Linux implementation of LLWindow class
- *
- * $LicenseInfo:firstyear=2001&license=viewergpl$
- * 
- * Copyright (c) 2001-2008, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLWINDOWWIN32_H
-#define LL_LLWINDOWWIN32_H
-
-#include "llwindow.h"
-
-class LLWindowLinux : public LLWindow
-{
-public:
-        /*virtual*/ void show() {};
-        /*virtual*/ void hide() {};
-        /*virtual*/ void close() {};
-        /*virtual*/ BOOL getVisible() {return FALSE;};
-        /*virtual*/ BOOL getMinimized() {return FALSE;};
-        /*virtual*/ BOOL getMaximized() {return FALSE;};
-        /*virtual*/ BOOL maximize() {return FALSE;};
-        /*virtual*/ BOOL getFullscreen() {return FALSE;};
-        /*virtual*/ BOOL getPosition(LLCoordScreen *position) {return FALSE;};
-        /*virtual*/ BOOL getSize(LLCoordScreen *size) {return FALSE;};
-        /*virtual*/ BOOL getSize(LLCoordWindow *size) {return FALSE;};
-        /*virtual*/ BOOL setPosition(LLCoordScreen position) {return FALSE;};
-        /*virtual*/ BOOL setSize(LLCoordScreen size) {return FALSE;};
-        /*virtual*/ BOOL switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL disable_vsync, const LLCoordScreen * const posp = NULL) {return FALSE;};
-        /*virtual*/ BOOL setCursorPosition(LLCoordWindow position) {return FALSE;};
-        /*virtual*/ BOOL getCursorPosition(LLCoordWindow *position) {return FALSE;};
-        /*virtual*/ void showCursor() {};
-        /*virtual*/ void hideCursor() {};
-        /*virtual*/ void showCursorFromMouseMove() {};
-        /*virtual*/ void hideCursorUntilMouseMove() {};
-        /*virtual*/ BOOL isCursorHidden() {return FALSE;};
-        /*virtual*/ void setCursor(ECursorType cursor) {};
-        //virtual ECursorType getCursor() { return mCurrentCursor; };
-        /*virtual*/ void captureMouse() {};
-        /*virtual*/ void releaseMouse() {};
-        /*virtual*/ void setMouseClipping( BOOL b ) {};
-        /*virtual*/ BOOL isClipboardTextAvailable() {return FALSE; };
-        /*virtual*/ BOOL pasteTextFromClipboard(LLWString &dst) {return FALSE; };
-        /*virtual*/ BOOL copyTextToClipboard(const LLWString &src) {return FALSE; };
-        /*virtual*/ void flashIcon(F32 seconds) {};
-        /*virtual*/ F32 getGamma() {return 1.0f; };
-        /*virtual*/ BOOL setGamma(const F32 gamma) {return FALSE; }; // Set the gamma
-        /*virtual*/ BOOL restoreGamma() {return FALSE; };       // Restore original gamma table (before updating gamma)
-        //virtual ESwapMethod getSwapMethod() { return mSwapMethod; }
-        /*virtual*/ void gatherInput() {};
-        /*virtual*/ void delayInputProcessing() {};
-        /*virtual*/ void swapBuffers();
-
-        /*virtual*/ LLString getTempFileName() {return LLString(""); };
-        /*virtual*/ void deleteFile( const char* file_name ) {};
-        /*virtual*/ S32 stat( const char* file_name, struct stat* stat_info ) {return 0; };
-        /*virtual*/ BOOL sendEmail(const char* address,const char* subject,const char* body_text,const char* attachment=NULL, const char* attachment_displayed_name=NULL) { return FALSE; };
-
-
-        // handy coordinate space conversion routines
-        /*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordWindow *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordScreen *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordGL *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordWindow *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordGL *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordScreen *to) { return FALSE; };
-
-        /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) { return NULL; };
-        /*virtual*/ F32 getNativeAspectRatio() { return 1.0f; };
-        /*virtual*/ F32 getPixelAspectRatio() { return 1.0f; };
-        /*virtual*/ void setNativeAspectRatio(F32 ratio) {}
-
-        //virtual       BOOL dialog_color_picker (F32 *r, F32 *g, F32 *b );
-
-        /*virtual*/ void *getPlatformWindow() { return NULL; }
-        
-        LLWindowLinux(char *title, char *name, S32 x, S32 y, S32 width, S32 height,
-                                  U32 flags,  BOOL fullscreen, BOOL clearBg,
-                                  BOOL disable_vsync, BOOL use_gl, BOOL ignore_pixel_depth);
-        ~LLWindowLinux();
-};
-
-class LLSplashScreenLinux : public LLSplashScreen
-{
-public:
-        LLSplashScreenLinux() {};
-        virtual ~LLSplashScreenLinux() {};
-
-        /*virtual*/ void showImpl() {};
-        /*virtual*/ void updateImpl(const char* mesg) {};
-        /*virtual*/ void hideImpl() {};
-
-};
-
-#endif //LL_LLWINDOWWIN32_H
diff --git a/linden/indra/llwindow/llwindowmacosx-objc.mm b/linden/indra/llwindow/llwindowmacosx-objc.mm
index d2efd77..d4ea2be 100644
--- a/linden/indra/llwindow/llwindowmacosx-objc.mm
+++ b/linden/indra/llwindow/llwindowmacosx-objc.mm
@@ -47,6 +47,8 @@ void setupCocoa()
         
         if(!inited)
         {
+                NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+                
                 // This is a bit of voodoo taken from the Apple sample code "CarbonCocoa_PictureCursor":
                 //   http://developer.apple.com/samplecode/CarbonCocoa_PictureCursor/index.html
                 
@@ -55,6 +57,8 @@ void setupCocoa()
 
                 //      Must first call [[[NSWindow alloc] init] release] to get the NSWindow machinery set up so that NSCursor can use a window to cache the cursor image
                 [[[NSWindow alloc] init] release];
+
+                [pool release];
         }
 }
 
@@ -82,8 +86,10 @@ OSErr releaseImageCursor(CursorRef ref)
 {
         if( ref != NULL )
         {
+                NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
                 NSCursor *cursor = (NSCursor*)ref;
                 [cursor release];
+                [pool release];
         }
         else
         {
@@ -97,8 +103,10 @@ OSErr setImageCursor(CursorRef ref)
 {
         if( ref != NULL )
         {
+                NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
                 NSCursor *cursor = (NSCursor*)ref;
                 [cursor set];
+                [pool release];
         }
         else
         {
diff --git a/linden/indra/llwindow/llwindowmacosx.cpp b/linden/indra/llwindow/llwindowmacosx.cpp
index f5cc8c6..5ab0ba6 100644
--- a/linden/indra/llwindow/llwindowmacosx.cpp
+++ b/linden/indra/llwindow/llwindowmacosx.cpp
@@ -359,7 +359,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
         if (mFullscreen && (mOldDisplayMode == NULL))
         {
-                llinfos << "createContext: setting up fullscreen " << width << "x" << height << llendl;
+                LL_INFOS("Window") << "createContext: setting up fullscreen " << width << "x" << height << LL_ENDL;
 
                 // NOTE: The refresh rate will be REPORTED AS 0 for many DVI and notebook displays.  Plan accordingly.
                 double refresh = getDictDouble (CGDisplayCurrentMode (mDisplay),  kCGDisplayRefreshRate);
@@ -380,18 +380,18 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                                 U32 closestWidth = 0;
                                 int i;
 
-                                llinfos << "createContext: searching for a display mode, original aspect is " << mOriginalAspectRatio << llendl;
+                                LL_DEBUGS("Window") << "createContext: searching for a display mode, original aspect is " << mOriginalAspectRatio << LL_ENDL;
 
                                 for(i=0; i < resolutionCount; i++)
                                 {
                                         F32 aspect = (F32)resolutionList[i].mWidth / (F32)resolutionList[i].mHeight;
 
-                                        llinfos << "createContext: width " << resolutionList[i].mWidth << " height " << resolutionList[i].mHeight << " aspect " << aspect << llendl;
+                                        LL_DEBUGS("Window") << "createContext: width " << resolutionList[i].mWidth << " height " << resolutionList[i].mHeight << " aspect " << aspect << LL_ENDL;
 
                                         if( (resolutionList[i].mHeight >= 700) && (resolutionList[i].mHeight <= 800) &&
                                                 (fabs(aspect - mOriginalAspectRatio) < fabs(closestAspect - mOriginalAspectRatio)))
                                         {
-                                                llinfos << " (new closest mode) " << llendl;
+                                                LL_DEBUGS("Window") << " (new closest mode) " << LL_ENDL;
 
                                                 // This is the closest mode we've seen yet.
                                                 closestWidth = resolutionList[i].mWidth;
@@ -437,7 +437,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
                         if (refDisplayMode)
                         {
-                                llinfos << "createContext: switching display resolution" << llendl;
+                                LL_DEBUGS("Window") << "createContext: switching display resolution" << LL_ENDL;
                                 mOldDisplayMode = CGDisplayCurrentMode (mDisplay);
                                 CGDisplaySwitchToMode (mDisplay, refDisplayMode);
                                 //                              CFRelease(refDisplayMode);
@@ -452,11 +452,11 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                         mFullscreenBits    = CGDisplayBitsPerPixel(mDisplay);
                         mFullscreenRefresh = llround(getDictDouble (CGDisplayCurrentMode (mDisplay),  kCGDisplayRefreshRate));
 
-                        llinfos << "Running at " << mFullscreenWidth
+                        LL_INFOS("Window") << "Running at " << mFullscreenWidth
                                 << "x"   << mFullscreenHeight
                                 << "x"   << mFullscreenBits
                                 << " @ " << mFullscreenRefresh
-                                << llendl;
+                                << LL_ENDL;
                 }
                 else
                 {
@@ -480,7 +480,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                 //int                           displayHeight = CGDisplayPixelsHigh(mDisplay);
                 //const int             menuBarPlusTitleBar = 44;   // Ugly magic number.
 
-                llinfos << "createContext: creating window" << llendl;
+                LL_DEBUGS("Window") << "createContext: creating window" << LL_ENDL;
 
                 window_rect.left = (long) x;
                 window_rect.right = (long) x + width;
@@ -534,7 +534,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                 err = NewTSMDocument(1, types, &mTSMDocument, 0);
                 if (err != noErr)
                 {
-                        llwarns << "createContext: couldn't create a TSMDocument (" << err << ")" << llendl;
+                        LL_WARNS("Window") << "createContext: couldn't create a TSMDocument (" << err << ")" << LL_ENDL;
                 }
                 if (mTSMDocument)
                 {
@@ -575,7 +575,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                                                 AGL_NONE
                                 };
 
-                                llinfos << "createContext: creating fullscreen pixelformat" << llendl;
+                                LL_DEBUGS("Window") << "createContext: creating fullscreen pixelformat" << LL_ENDL;
 
                                 GDHandle gdhDisplay = NULL;
                                 err = DMGetGDeviceByDisplayID ((DisplayIDType)mDisplay, &gdhDisplay, false);
@@ -602,7 +602,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                                                 AGL_NONE
                                 };
 
-                                llinfos << "createContext: creating windowed pixelformat" << llendl;
+                                LL_DEBUGS("Window") << "createContext: creating windowed pixelformat" << LL_ENDL;
 
                                 mPixelFormat = aglChoosePixelFormat(NULL, 0, windowedAttrib);
 
@@ -622,7 +622,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
                 if(mPixelFormat)
                 {
-                        llinfos << "createContext: creating GL context" << llendl;
+                        LL_DEBUGS("Window") << "createContext: creating GL context" << LL_ENDL;
                         mContext = aglCreateContext(mPixelFormat, NULL);
                 }
 
@@ -670,7 +670,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
         {
                 // We successfully captured the display.  Use a fullscreen drawable
 
-                llinfos << "createContext: attaching fullscreen drawable" << llendl;
+                LL_DEBUGS("Window") << "createContext: attaching fullscreen drawable" << LL_ENDL;
 
 #if CAPTURE_ALL_DISPLAYS
                 // Capture all displays (may want to do this for final build)
@@ -688,7 +688,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
         }
         else if(!mFullscreen && (mWindow != NULL))
         {
-                llinfos << "createContext: attaching windowed drawable" << llendl;
+                LL_DEBUGS("Window") << "createContext: attaching windowed drawable" << LL_ENDL;
 
                 // We created a window.  Use it as the drawable.
                 if(!aglSetDrawable(mContext, GetWindowPort (mWindow)))
@@ -705,7 +705,7 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
         if(mContext != NULL)
         {
-                llinfos << "createContext: setting current context" << llendl;
+                LL_DEBUGS("Window") << "createContext: setting current context" << LL_ENDL;
 
                 if (!aglSetCurrentContext(mContext))
                 {
@@ -759,11 +759,11 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
                 return FALSE;
         }
 
-        llinfos << "GL buffer: Color Bits " << S32(colorBits)
+        LL_INFOS("GLInit") << "GL buffer: Color Bits " << S32(colorBits)
                 << " Alpha Bits " << S32(alphaBits)
                 << " Depth Bits " << S32(depthBits)
                 << " Stencil Bits" << S32(stencilBits)
-                << llendl;
+                << LL_ENDL;
 
         if (colorBits < 32)
         {
@@ -798,12 +798,12 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
         GLint frames_per_swap = 0;
         if (disable_vsync)
         {
-                llinfos << "Disabling vertical sync" << llendl;
+                LL_DEBUGS("GLInit") << "Disabling vertical sync" << LL_ENDL;
                 frames_per_swap = 0;
         }
         else
         {
-                llinfos << "Keeping vertical sync" << llendl;
+                LL_DEBUGS("GLinit") << "Keeping vertical sync" << LL_ENDL;
                 frames_per_swap = 1;
         }
         aglSetInteger(mContext, AGL_SWAP_INTERVAL, &frames_per_swap);  
@@ -818,11 +818,11 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 
                 if (cgl_err != kCGLNoError )
                 {
-                        llinfos << "Multi-threaded OpenGL not available." << llendl;
+                        LL_DEBUGS("GLInit") << "Multi-threaded OpenGL not available." << LL_ENDL;
                 }    
                 else
                 {
-                        llinfos << "Multi-threaded OpenGL enabled." << llendl;
+                        LL_DEBUGS("GLInit") << "Multi-threaded OpenGL enabled." << LL_ENDL;
                 }
         }
 
@@ -869,11 +869,11 @@ BOOL LLWindowMacOSX::switchContext(BOOL fullscreen, const LLCoordScreen &size, B
                         mFullscreenBits    = CGDisplayBitsPerPixel(mDisplay);
                         mFullscreenRefresh = llround(getDictDouble (CGDisplayCurrentMode (mDisplay),  kCGDisplayRefreshRate));
 
-                        llinfos << "Switched resolution to " << mFullscreenWidth
+                        LL_INFOS("Window") << "Switched resolution to " << mFullscreenWidth
                                 << "x"   << mFullscreenHeight
                                 << "x"   << mFullscreenBits
                                 << " @ " << mFullscreenRefresh
-                                << llendl;
+                                << LL_ENDL;
 
                         // Update the GL context to the new screen size
                         if (!aglUpdateContext(mContext))
@@ -943,7 +943,7 @@ void LLWindowMacOSX::destroyContext()
         // Unhook the GL context from any drawable it may have
         if(mContext != NULL)
         {
-                llinfos << "destroyContext: unhooking drawable " << llendl;
+                LL_DEBUGS("Window") << "destroyContext: unhooking drawable " << LL_ENDL;
 
                 aglSetCurrentContext (NULL);
                 aglSetDrawable(mContext, NULL);
@@ -952,7 +952,7 @@ void LLWindowMacOSX::destroyContext()
         // Make sure the display resolution gets restored
         if(mOldDisplayMode != NULL)
         {
-                llinfos << "destroyContext: restoring display resolution " << llendl;
+                LL_DEBUGS("Window") << "destroyContext: restoring display resolution " << LL_ENDL;
 
                 CGDisplaySwitchToMode (mDisplay, mOldDisplayMode);
 
@@ -978,7 +978,7 @@ void LLWindowMacOSX::destroyContext()
         // Clean up the pixel format
         if(mPixelFormat != NULL)
         {
-                llinfos << "destroyContext: destroying pixel format " << llendl;
+                LL_DEBUGS("Window") << "destroyContext: destroying pixel format " << LL_ENDL;
                 aglDestroyPixelFormat(mPixelFormat);
                 mPixelFormat = NULL;
         }
@@ -986,14 +986,14 @@ void LLWindowMacOSX::destroyContext()
         // Remove any Carbon Event handlers we installed
         if(mGlobalHandlerRef != NULL)
         {
-                llinfos << "destroyContext: removing global event handler" << llendl;
+                LL_DEBUGS("Window") << "destroyContext: removing global event handler" << LL_ENDL;
                 RemoveEventHandler(mGlobalHandlerRef);
                 mGlobalHandlerRef = NULL;
         }
 
         if(mWindowHandlerRef != NULL)
         {
-                llinfos << "destroyContext: removing window event handler" << llendl;
+                LL_DEBUGS("Window") << "destroyContext: removing window event handler" << LL_ENDL;
                 RemoveEventHandler(mWindowHandlerRef);
                 mWindowHandlerRef = NULL;
         }
@@ -1001,7 +1001,7 @@ void LLWindowMacOSX::destroyContext()
         // Cleanup any TSM document we created.
         if(mTSMDocument != NULL)
         {
-                llinfos << "destroyContext: deleting TSM document" << llendl;
+                LL_DEBUGS("Window") << "destroyContext: deleting TSM document" << LL_ENDL;
                 DeactivateTSMDocument(mTSMDocument);
                 DeleteTSMDocument(mTSMDocument);
                 mTSMDocument = NULL;
@@ -1010,7 +1010,7 @@ void LLWindowMacOSX::destroyContext()
         // Close the window
         if(mWindow != NULL)
         {
-                llinfos << "destroyContext: disposing window" << llendl;
+                LL_DEBUGS("Window") << "destroyContext: disposing window" << LL_ENDL;
                 DisposeWindow(mWindow);
                 mWindow = NULL;
         }
@@ -1018,7 +1018,7 @@ void LLWindowMacOSX::destroyContext()
         // Clean up the GL context
         if(mContext != NULL)
         {
-                llinfos << "destroyContext: destroying GL context" << llendl;
+                LL_DEBUGS("Window") << "destroyContext: destroying GL context" << LL_ENDL;
                 aglDestroyContext(mContext);
                 mContext = NULL;
         }
@@ -3394,4 +3394,13 @@ void LLWindowMacOSX::interruptLanguageTextInput()
         // Well, if Apple's TSM document is correct, we don't.
 }
 
+//static
+std::string LLWindowMacOSX::getFontListSans()
+{
+        // This is a fairly complete Japanese font that ships with Mac OS X.
+        // The first filename is in UTF8, but it shows up in the font menu as "Hiragino Kaku Gothic Pro W3".
+        // The third filename is in UTF8, but it shows up in the font menu as "STHeiti Light"
+        return "\xE3\x83\x92\xE3\x83\xA9\xE3\x82\xAD\xE3\x82\x99\xE3\x83\x8E\xE8\xA7\x92\xE3\x82\xB3\xE3\x82\x99 Pro W3.otf;\xE3\x83\x92\xE3\x83\xA9\xE3\x82\xAD\xE3\x82\x99\xE3\x83\x8E\xE8\xA7\x92\xE3\x82\xB3\xE3\x82\x99 ProN W3.otf;AppleGothic.dfont;AppleGothic.ttf;\xe5\x8d\x8e\xe6\x96\x87\xe7\xbb\x86\xe9\xbb\x91.ttf";
+}
+
 #endif // LL_DARWIN
diff --git a/linden/indra/llwindow/llwindowmacosx.h b/linden/indra/llwindow/llwindowmacosx.h
index 1edb218..d8a0788 100644
--- a/linden/indra/llwindow/llwindowmacosx.h
+++ b/linden/indra/llwindow/llwindowmacosx.h
@@ -116,6 +116,8 @@ public:
         /*virtual*/ void allowLanguageTextInput(LLPreeditor *preeditor, BOOL b);
         /*virtual*/ void interruptLanguageTextInput();
 
+        static std::string getFontListSans();
+
 protected:
         LLWindowMacOSX(
                 char *title, char *name, int x, int y, int width, int height, U32 flags,
diff --git a/linden/indra/llwindow/llwindowsdl.cpp b/linden/indra/llwindow/llwindowsdl.cpp
index d9dc040..0d1d622 100644
--- a/linden/indra/llwindow/llwindowsdl.cpp
+++ b/linden/indra/llwindow/llwindowsdl.cpp
@@ -39,6 +39,7 @@
 #include "llgl.h"
 #include "llstring.h"
 #include "lldir.h"
+#include "llfindlocale.h"
 
 #include "llglheaders.h"
 
@@ -51,6 +52,10 @@ extern "C" {
 #include <locale.h>
 #endif // LL_GTK
 
+extern "C" {
+# include "fontconfig/fontconfig.h"
+}
+
 #if LL_LINUX || LL_SOLARIS
 // not necessarily available on random SDL platforms, so #if LL_LINUX
 // for execv(), waitpid(), fork()
@@ -2030,7 +2035,8 @@ void LLWindowSDL::gatherInput()
             // the locale to protect it, as exotic/non-C locales
             // causes our code lots of general critical weirdness
             // and crashness. (SL-35450)
-            std::string saved_locale = setlocale(LC_ALL, NULL);
+            static std::string saved_locale;
+            saved_locale = ll_safe_string(setlocale(LC_ALL, NULL));
 
             // Pump until we've nothing left to do or passed 1/15th of a
             // second pumping for this frame.
@@ -2751,8 +2757,8 @@ void spawn_web_browser(const char* escaped_url)
 # endif // LL_X11
 
         std::string cmd;
-        cmd  = gDirUtilp->getAppRODataDir().c_str();
-        cmd += gDirUtilp->getDirDelimiter().c_str();
+        cmd  = gDirUtilp->getAppRODataDir();
+        cmd += gDirUtilp->getDirDelimiter();
         cmd += "launch_url.sh";
         char* const argv[] = {(char*)cmd.c_str(), (char*)escaped_url, NULL};
 
@@ -2829,4 +2835,90 @@ void LLWindowSDL::bringToFront()
 #endif // LL_X11
 }
 
+//static
+std::string LLWindowSDL::getFontListSans()
+{
+        // Use libfontconfig to find us a nice ordered list of fallback fonts
+        // specific to this system.
+        std::string final_fallback("/usr/share/fonts/truetype/kochi/kochi-gothic.ttf");
+        // Our 'ideal' font properties which define the sorting results.
+        // slant=0 means Roman, index=0 means the first face in a font file
+        // (the one we actually use), weight=80 means medium weight,
+        // spacing=0 means proportional spacing.
+        std::string sort_order("slant=0:index=0:weight=80:spacing=0");
+        // elide_unicode_coverage removes fonts from the list whose unicode
+        // range is covered by fonts earlier in the list.  This usually
+        // removes ~90% of the fonts as redundant (which is great because
+        // the font list can be huge), but might unnecessarily reduce the
+        // renderable range if for some reason our FreeType actually fails
+        // to use some of the fonts we want it to.
+        const bool elide_unicode_coverage = true;
+        std::string rtn;
+        FcFontSet *fs = NULL;
+        FcPattern *sortpat = NULL;
+        int font_count = 0;
+
+        llinfos << "Getting system font list from FontConfig..." << llendl;
+
+        // If the user has a system-wide language preference, then favor
+        // fonts from that language group.  This doesn't affect the types
+        // of languages that can be displayed, but ensures that their
+        // preferred language is rendered from a single consistent font where
+        // possible.
+        FL_Locale *locale = NULL;
+        FL_Success success = FL_FindLocale(&locale, FL_MESSAGES);
+        if (success != 0)
+        {
+                if (success >= 2 && locale->lang) // confident!
+                {
+                        llinfos << "Preferring fonts of language: "
+                                << locale->lang
+                                << llendl;
+                        sort_order = "lang=" + std::string(locale->lang) + ":"
+                                + sort_order;
+                }
+                FL_FreeLocale(&locale);
+        }
+
+        if (!FcInit())
+        {
+                llwarns << "FontConfig failed to initialize." << llendl;
+                return final_fallback;
+        }
+
+        sortpat = FcNameParse((FcChar8*) sort_order.c_str());
+        if (sortpat)
+        {
+                // Sort the list of system fonts from most-to-least-desirable.
+                fs = FcFontSort(NULL, sortpat, elide_unicode_coverage,
+                                NULL, NULL);
+                FcPatternDestroy(sortpat);
+        }
+
+        if (fs)
+        {
+                // Get the full pathnames to the fonts, where available,
+                // which is what we really want.
+                int i;
+                for (i=0; i<fs->nfont; ++i)
+                {
+                        FcChar8 *filename;
+                        if (FcResultMatch == FcPatternGetString(fs->fonts[i],
+                                                                FC_FILE, 0,
+                                                                &filename)
+                            && filename)
+                        {
+                                rtn += std::string((const char*)filename)+";";
+                                ++font_count;
+                        }
+                }
+                FcFontSetDestroy (fs);
+        }
+
+        lldebugs << "Using font list: " << rtn << llendl;
+        llinfos << "Using " << font_count << " system font(s)." << llendl;
+
+        return rtn + final_fallback;
+}
+
 #endif // LL_SDL
diff --git a/linden/indra/llwindow/llwindowsdl.h b/linden/indra/llwindow/llwindowsdl.h
index d1b2b77..5aed4e6 100644
--- a/linden/indra/llwindow/llwindowsdl.h
+++ b/linden/indra/llwindow/llwindowsdl.h
@@ -120,6 +120,8 @@ public:
         /*virtual*/ void *getPlatformWindow();
         /*virtual*/ void bringToFront();
 
+        static std::string getFontListSans();
+
         // Not great that these are public, but they have to be accessible
         // by non-class code and it's better than making them global.
 #if LL_X11
@@ -154,7 +156,6 @@ protected:
 
         BOOL    shouldPostQuit() { return mPostQuit; }
 
-
 protected:
         //
         // Platform specific methods
diff --git a/linden/indra/llwindow/llwindowsolaris.h b/linden/indra/llwindow/llwindowsolaris.h
deleted file mode 100644
index 7a271c0..0000000
--- a/linden/indra/llwindow/llwindowsolaris.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/** 
- * @file fmodwrapper.cpp
- * @brief dummy source file for building a shared library to wrap libfmod.a
- *
- * $LicenseInfo:firstyear=2005&license=viewergpl$
- * 
- * Copyright (c) 2005-2008, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLWINDOWSOLARIS_H
-#define LL_LLWINDOWSOLARIS_H
-
-#include "llwindow.h"
-
-class LLWindowSolaris : public LLWindow
-{
-public:
-        /*virtual*/ void show() {};
-        /*virtual*/ void hide() {};
-        /*virtual*/ void close() {};
-        /*virtual*/ BOOL getVisible() {return FALSE;};
-        /*virtual*/ BOOL getMinimized() {return FALSE;};
-        /*virtual*/ BOOL getMaximized() {return FALSE;};
-        /*virtual*/ BOOL maximize() {return FALSE;};
-        /*virtual*/ BOOL getFullscreen() {return FALSE;};
-        /*virtual*/ BOOL getPosition(LLCoordScreen *position) {return FALSE;};
-        /*virtual*/ BOOL getSize(LLCoordScreen *size) {return FALSE;};
-        /*virtual*/ BOOL getSize(LLCoordWindow *size) {return FALSE;};
-        /*virtual*/ BOOL setPosition(LLCoordScreen position) {return FALSE;};
-        /*virtual*/ BOOL setSize(LLCoordScreen size) {return FALSE;};
-        /*virtual*/ BOOL switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL disable_vsync, const LLCoordScreen * const posp = NULL) {return FALSE;};
-        /*virtual*/ BOOL setCursorPosition(LLCoordWindow position) {return FALSE;};
-        /*virtual*/ BOOL getCursorPosition(LLCoordWindow *position) {return FALSE;};
-        /*virtual*/ void showCursor() {};
-        /*virtual*/ void hideCursor() {};
-        /*virtual*/ void showCursorFromMouseMove() {};
-        /*virtual*/ void hideCursorUntilMouseMove() {};
-        /*virtual*/ BOOL isCursorHidden() {return FALSE;};
-        /*virtual*/ void setCursor(ECursorType cursor) {};
-        //virtual ECursorType getCursor() { return mCurrentCursor; };
-        /*virtual*/ void captureMouse() {};
-        /*virtual*/ void releaseMouse() {};
-        /*virtual*/ void setMouseClipping( BOOL b ) {};
-        /*virtual*/ BOOL isClipboardTextAvailable() {return FALSE; };
-        /*virtual*/ BOOL pasteTextFromClipboard(LLWString &dst) {return FALSE; };
-        /*virtual*/ BOOL copyTextToClipboard(const LLWString &src) {return FALSE; };
-        /*virtual*/ void flashIcon(F32 seconds) {};
-        /*virtual*/ F32 getGamma() {return 1.0f; };
-        /*virtual*/ BOOL setGamma(const F32 gamma) {return FALSE; }; // Set the gamma
-        /*virtual*/ U32 getFSAASamples() { return 0; }
-        /*virtual*/ void setFSAASamples(const U32 samples) { }
-        /*virtual*/ BOOL restoreGamma() {return FALSE; };       // Restore original gamma table (before updating gamma)
-        //virtual ESwapMethod getSwapMethod() { return mSwapMethod; }
-        /*virtual*/ void gatherInput() {};
-        /*virtual*/ void delayInputProcessing() {};
-        /*virtual*/ void swapBuffers();
-
-        /*virtual*/ LLString getTempFileName() {return LLString(""); };
-        /*virtual*/ void deleteFile( const char* file_name ) {};
-        /*virtual*/ S32 stat( const char* file_name, struct stat* stat_info ) {return 0; };
-        /*virtual*/ BOOL sendEmail(const char* address,const char* subject,const char* body_text,const char* attachment=NULL, const char* attachment_displayed_name=NULL) { return FALSE; };
-
-
-        // handy coordinate space conversion routines
-        /*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordWindow *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordScreen *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordGL *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordWindow *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordGL *to) { return FALSE; };
-        /*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordScreen *to) { return FALSE; };
-
-        /*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) { return NULL; };
-        /*virtual*/ F32 getNativeAspectRatio() { return 1.0f; };
-        /*virtual*/ F32 getPixelAspectRatio() { return 1.0f; };
-        /*virtual*/ void setNativeAspectRatio(F32 ratio) {}
-
-        //virtual       BOOL dialog_color_picker (F32 *r, F32 *g, F32 *b );
-
-        /*virtual*/ void *getPlatformWindow() { return NULL; }
-        
-        LLWindowSolaris(char *title, char *name, S32 x, S32 y, S32 width, S32 height,
-                                  U32 flags,  BOOL fullscreen, BOOL clearBg,
-                                  BOOL disable_vsync, BOOL use_gl, BOOL ignore_pixel_depth);
-        ~LLWindowSolaris();
-};
-
-class LLSplashScreenLinux : public LLSplashScreen
-{
-public:
-        LLSplashScreenLinux() {};
-        virtual ~LLSplashScreenLinux() {};
-
-        /*virtual*/ void showImpl() {};
-        /*virtual*/ void updateImpl(const char* mesg) {};
-        /*virtual*/ void hideImpl() {};
-
-};
-
-#endif //LL_LLWINDOWSOLARIS_H
diff --git a/linden/indra/llwindow/llwindowwin32.cpp b/linden/indra/llwindow/llwindowwin32.cpp
index 9963493..f2a2727 100644
--- a/linden/indra/llwindow/llwindowwin32.cpp
+++ b/linden/indra/llwindow/llwindowwin32.cpp
@@ -84,7 +84,7 @@ LLW32MsgCallback gAsyncMsgCallback = NULL;
 
 void show_window_creation_error(const char* title)
 {
-        llwarns << title << llendl;
+        LL_WARNS("Window") << title << LL_ENDL;
 }
 
 //static
@@ -534,7 +534,7 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
 
                 if (closest_refresh == 0)
                 {
-                        llwarns << "Couldn't find display mode " << width << " by " << height << " at " << BITS_PER_PIXEL << " bits per pixel" << llendl;
+                        LL_WARNS("Window") << "Couldn't find display mode " << width << " by " << height << " at " << BITS_PER_PIXEL << " bits per pixel" << LL_ENDL;
                         success = FALSE;
                 }
 
@@ -557,11 +557,11 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
                         mFullscreenBits    = dev_mode.dmBitsPerPel;
                         mFullscreenRefresh = dev_mode.dmDisplayFrequency;
 
-                        llinfos << "Running at " << dev_mode.dmPelsWidth
+                        LL_INFOS("Window") << "Running at " << dev_mode.dmPelsWidth
                                 << "x"   << dev_mode.dmPelsHeight
                                 << "x"   << dev_mode.dmBitsPerPel
                                 << " @ " << dev_mode.dmDisplayFrequency
-                                << llendl;
+                                << LL_ENDL;
                 }
                 else
                 {
@@ -576,7 +576,7 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
                         OSMessageBox(error, "Error", OSMB_OK);
                 }
         }
-        
+
         // TODO: add this after resolving _WIN32_WINNT issue
         //      if (!fullscreen)
         //      {
@@ -588,7 +588,7 @@ LLWindowWin32::LLWindowWin32(char *title, char *name, S32 x, S32 y, S32 width,
         //              TrackMouseEvent( &track_mouse_event ); 
         //      }
 
-        
+
         //-----------------------------------------------------------------------
         // Create GL drawing context
         //-----------------------------------------------------------------------
@@ -657,7 +657,7 @@ void LLWindowWin32::restore()
 // Usually called from LLWindowManager::destroyWindow()
 void LLWindowWin32::close()
 {
-        llinfos << "Closing LLWindowWin32" << llendl;
+        LL_DEBUGS("Window") << "Closing LLWindowWin32" << LL_ENDL;
         // Is window is already closed?
         if (!mWindowHandle)
         {
@@ -675,20 +675,20 @@ void LLWindowWin32::close()
         }
 
         // Clean up remaining GL state
-        llinfos << "Shutting down GL" << llendl;
+        LL_DEBUGS("Window") << "Shutting down GL" << LL_ENDL;
         gGLManager.shutdownGL();
 
-        llinfos << "Releasing Context" << llendl;
+        LL_DEBUGS("Window") << "Releasing Context" << LL_ENDL;
         if (mhRC)
         {
                 if (!wglMakeCurrent(NULL, NULL))
                 {
-                        llwarns << "Release of DC and RC failed" << llendl;
+                        LL_WARNS("Window") << "Release of DC and RC failed" << LL_ENDL;
                 }
 
                 if (!wglDeleteContext(mhRC))
                 {
-                        llwarns << "Release of rendering context failed" << llendl;
+                        LL_WARNS("Window") << "Release of rendering context failed" << LL_ENDL;
                 }
 
                 mhRC = NULL;
@@ -699,11 +699,11 @@ void LLWindowWin32::close()
 
         if (mhDC && !ReleaseDC(mWindowHandle, mhDC))
         {
-                llwarns << "Release of ghDC failed" << llendl;
+                LL_WARNS("Window") << "Release of ghDC failed" << LL_ENDL;
                 mhDC = NULL;
         }
 
-        llinfos << "Destroying Window" << llendl;
+        LL_DEBUGS("Window") << "Destroying Window" << LL_ENDL;
         
         // Don't process events in our mainWindowProc any longer.
         SetWindowLong(mWindowHandle, GWL_USERDATA, NULL);
@@ -866,12 +866,12 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
         {
                 if (!wglMakeCurrent(NULL, NULL))
                 {
-                        llwarns << "Release of DC and RC failed" << llendl;
+                        LL_WARNS("Window") << "Release of DC and RC failed" << LL_ENDL;
                 }
 
                 if (!wglDeleteContext(mhRC))
                 {
-                        llwarns << "Release of rendering context failed" << llendl;
+                        LL_WARNS("Window") << "Release of rendering context failed" << LL_ENDL;
                 }
 
                 mhRC = NULL;
@@ -905,7 +905,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 
                 if (closest_refresh == 0)
                 {
-                        llwarns << "Couldn't find display mode " << width << " by " << height << " at " << BITS_PER_PIXEL << " bits per pixel" << llendl;
+                        LL_WARNS("Window") << "Couldn't find display mode " << width << " by " << height << " at " << BITS_PER_PIXEL << " bits per pixel" << LL_ENDL;
                         return FALSE;
                 }
 
@@ -927,11 +927,11 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                         mFullscreenBits    = dev_mode.dmBitsPerPel;
                         mFullscreenRefresh = dev_mode.dmDisplayFrequency;
 
-                        llinfos << "Running at " << dev_mode.dmPelsWidth
+                        LL_INFOS("Window") << "Running at " << dev_mode.dmPelsWidth
                                 << "x"   << dev_mode.dmPelsHeight
                                 << "x"   << dev_mode.dmBitsPerPel
                                 << " @ " << dev_mode.dmDisplayFrequency
-                                << llendl;
+                                << LL_ENDL;
 
                         window_rect.left = (long) 0;
                         window_rect.right = (long) width;                       // Windows GDI rects don't include rightmost pixel
@@ -952,8 +952,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                         mFullscreenBits    = -1;
                         mFullscreenRefresh = -1;
 
-                        llinfos << "Unable to run fullscreen at " << width << "x" << height << llendl;
-                        llinfos << "Running in window." << llendl;
+                        LL_INFOS("Window") << "Unable to run fullscreen at " << width << "x" << height << LL_ENDL;
                         return FALSE;
                 }
         }
@@ -1146,7 +1145,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                 {
                         if (end_attrib > 0)
                         {
-                                llinfos << "No valid pixel format for " << mFSAASamples << "x anti-aliasing." << llendl;
+                                LL_INFOS("Window") << "No valid pixel format for " << mFSAASamples << "x anti-aliasing." << LL_ENDL;
                                 attrib_list[end_attrib] = 0;
 
                                 BOOL result = wglChoosePixelFormatARB(mhDC, attrib_list, NULL, 256, pixel_formats, &num_formats);
@@ -1160,7 +1159,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 
                         if (!num_formats)
                         {
-                                llinfos << "No 32 bit z-buffer, trying 24 bits instead" << llendl;
+                                LL_INFOS("Window") << "No 32 bit z-buffer, trying 24 bits instead" << LL_ENDL;
                                 // Try 24-bit format
                                 attrib_list[1] = 24;
                                 BOOL result = wglChoosePixelFormatARB(mhDC, attrib_list, NULL, 256, pixel_formats, &num_formats);
@@ -1173,7 +1172,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
 
                                 if (!num_formats)
                                 {
-                                        llwarns << "Couldn't get 24 bit z-buffer,trying 16 bits instead!" << llendl;
+                                        LL_WARNS("Window") << "Couldn't get 24 bit z-buffer,trying 16 bits instead!" << LL_ENDL;
                                         attrib_list[1] = 16;
                                         BOOL result = wglChoosePixelFormatARB(mhDC, attrib_list, NULL, 256, pixel_formats, &num_formats);
                                         if (!result || !num_formats)
@@ -1185,7 +1184,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                                 }
                         }
 
-                        llinfos << "Choosing pixel formats: " << num_formats << " pixel formats returned" << llendl;
+                        LL_INFOS("Window") << "Choosing pixel formats: " << num_formats << " pixel formats returned" << LL_ENDL;
                 }
 
                 pixel_format = pixel_formats[0];
@@ -1241,26 +1240,26 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                         {
                         case WGL_SWAP_EXCHANGE_ARB:
                                 mSwapMethod = SWAP_METHOD_EXCHANGE;
-                                llinfos << "Swap Method: Exchange" << llendl;
+                                LL_DEBUGS("Window") << "Swap Method: Exchange" << LL_ENDL;
                                 break;
                         case WGL_SWAP_COPY_ARB:
                                 mSwapMethod = SWAP_METHOD_COPY;
-                                llinfos << "Swap Method: Copy" << llendl;
+                                LL_DEBUGS("Window") << "Swap Method: Copy" << LL_ENDL;
                                 break;
                         case WGL_SWAP_UNDEFINED_ARB:
                                 mSwapMethod = SWAP_METHOD_UNDEFINED;
-                                llinfos << "Swap Method: Undefined" << llendl;
+                                LL_DEBUGS("Window") << "Swap Method: Undefined" << LL_ENDL;
                                 break;
                         default:
                                 mSwapMethod = SWAP_METHOD_UNDEFINED;
-                                llinfos << "Swap Method: Unknown" << llendl;
+                                LL_DEBUGS("Window") << "Swap Method: Unknown" << LL_ENDL;
                                 break;
                         }
                 }               
         }
         else
         {
-                llwarns << "No wgl_ARB_pixel_format extension, using default ChoosePixelFormat!" << llendl;
+                LL_WARNS("Window") << "No wgl_ARB_pixel_format extension, using default ChoosePixelFormat!" << LL_ENDL;
         }
 
         // Verify what pixel format we actually received.
@@ -1272,10 +1271,10 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
                 return FALSE;
         }
 
-        llinfos << "GL buffer: Color Bits " << S32(pfd.cColorBits) 
+        LL_INFOS("Window") << "GL buffer: Color Bits " << S32(pfd.cColorBits) 
                 << " Alpha Bits " << S32(pfd.cAlphaBits)
                 << " Depth Bits " << S32(pfd.cDepthBits) 
-                << llendl;
+                << LL_ENDL;
 
         // make sure we have 32 bits per pixel
         if (pfd.cColorBits < 32 || GetDeviceCaps(mhDC, BITSPIXEL) < 32)
@@ -1338,12 +1337,12 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
         // Disable vertical sync for swap
         if (disable_vsync && wglSwapIntervalEXT)
         {
-                llinfos << "Disabling vertical sync" << llendl;
+                LL_DEBUGS("Window") << "Disabling vertical sync" << LL_ENDL;
                 wglSwapIntervalEXT(0);
         }
         else
         {
-                llinfos << "Keeping vertical sync" << llendl;
+                LL_DEBUGS("Window") << "Keeping vertical sync" << LL_ENDL;
         }
 
         SetWindowLong(mWindowHandle, GWL_USERDATA, (U32)this);
@@ -1701,11 +1700,11 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
 
                                 if (gDebugWindowProc)
                                 {
-                                        llinfos << "WINDOWPROC ActivateApp "
+                                        LL_INFOS("Window") << "WINDOWPROC ActivateApp "
                                                 << " activating " << S32(activating)
                                                 << " minimized " << S32(minimized)
                                                 << " fullscreen " << S32(window_imp->mFullscreen)
-                                                << llendl;
+                                                << LL_ENDL;
                                 }
 
                                 if (window_imp->mFullscreen)
@@ -1746,10 +1745,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                                 // properly when we run fullscreen.
                                 if (gDebugWindowProc)
                                 {
-                                        llinfos << "WINDOWPROC Activate "
+                                        LL_INFOS("Window") << "WINDOWPROC Activate "
                                                 << " activating " << S32(activating) 
                                                 << " minimized " << S32(minimized)
-                                                << llendl;
+                                                << LL_ENDL;
                                 }
 
                                 // Don't handle this.
@@ -1805,9 +1804,9 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                         {
                                 if (gDebugWindowProc)
                                 {
-                                        llinfos << "Debug WindowProc WM_KEYDOWN "
+                                        LL_INFOS("Window") << "Debug WindowProc WM_KEYDOWN "
                                                 << " key " << S32(w_param) 
-                                                << llendl;
+                                                << LL_ENDL;
                                 }
                                 if(gKeyboard->handleKeyDown(w_param, mask) && eat_keystroke)
                                 {
@@ -1824,9 +1823,9 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
 
                         if (gDebugWindowProc)
                         {
-                                llinfos << "Debug WindowProc WM_KEYUP "
+                                LL_INFOS("Window") << "Debug WindowProc WM_KEYUP "
                                         << " key " << S32(w_param) 
-                                        << llendl;
+                                        << LL_ENDL;
                         }
                         if (gKeyboard->handleKeyUp(w_param, mask) && eat_keystroke)
                         {
@@ -1909,13 +1908,11 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                         // it is worth trying.  The good old WM_CHAR works just fine even for supplementary
                         // characters.  We just need to take care of surrogate pairs sent as two WM_CHAR's
                         // by ourselves.  It is not that tough.  -- Alissa Sabre @ SL
-                        //
-                        // llinfos << "WM_CHAR: " << w_param << llendl;
                         if (gDebugWindowProc)
                         {
-                                llinfos << "Debug WindowProc WM_CHAR "
+                                LL_INFOS("Window") << "Debug WindowProc WM_CHAR "
                                         << " key " << S32(w_param) 
-                                        << llendl;
+                                        << LL_ENDL;
                         }
                         // Even if LLWindowCallbacks::handleUnicodeChar(llwchar, BOOL) returned FALSE,
                         // we *did* processed the event, so I believe we should not pass it to DefWindowProc...
@@ -1985,7 +1982,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                                 LLFastTimer t2(LLFastTimer::FTM_MOUSEHANDLER);
                                 //if (gDebugClicks)
                                 //{
-                                //      llinfos << "WndProc left button up" << llendl;
+                                //      LL_INFOS("Window") << "WndProc left button up" << LL_ENDL;
                                 //}
                                 // Because we move the cursor position in the app, we need to query
                                 // to find out where the cursor at the time the event is handled.
@@ -2181,12 +2178,12 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                                         BOOL restored  = ( w_param == SIZE_RESTORED );
                                         BOOL minimized = ( w_param == SIZE_MINIMIZED );
 
-                                        llinfos << "WINDOWPROC Size "
+                                        LL_INFOS("Window") << "WINDOWPROC Size "
                                                 << width << "x" << height
                                                 << " max " << S32(maximized)
                                                 << " min " << S32(minimized)
                                                 << " rest " << S32(restored)
-                                                << llendl;
+                                                << LL_ENDL;
                                 }
 
                                 // There's an odd behavior with WM_SIZE that I would call a bug. If 
@@ -2232,7 +2229,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 case WM_SETFOCUS:
                         if (gDebugWindowProc)
                         {
-                                llinfos << "WINDOWPROC SetFocus" << llendl;
+                                LL_INFOS("Window") << "WINDOWPROC SetFocus" << LL_ENDL;
                         }
                         window_imp->mCallbacks->handleFocus(window_imp);
                         return 0;
@@ -2240,7 +2237,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 case WM_KILLFOCUS:
                         if (gDebugWindowProc)
                         {
-                                llinfos << "WINDOWPROC KillFocus" << llendl;
+                                LL_INFOS("Window") << "WINDOWPROC KillFocus" << LL_ENDL;
                         }
                         window_imp->mCallbacks->handleFocusLost(window_imp);
                         return 0;
@@ -2596,7 +2593,7 @@ BOOL LLWindowWin32::setGamma(const F32 gamma)
 {
         mCurrentGamma = gamma;
 
-        llinfos << "Setting gamma to " << gamma << llendl;
+        LL_DEBUGS("Window") << "Setting gamma to " << gamma << LL_ENDL;
 
         for ( int i = 0; i < 256; ++i )
         {
@@ -2737,8 +2734,8 @@ BOOL LLWindowWin32::setDisplayResolution(S32 width, S32 height, S32 bits, S32 re
 
         if (!success)
         {
-                llwarns << "setDisplayResolution failed, "
-                        << width << "x" << height << "x" << bits << " @ " << refresh << llendl;
+                LL_WARNS("Window") << "setDisplayResolution failed, "
+                        << width << "x" << height << "x" << bits << " @ " << refresh << LL_ENDL;
         }
 
         return success;
@@ -2760,7 +2757,7 @@ BOOL LLWindowWin32::setFullscreenResolution()
 // protected
 BOOL LLWindowWin32::resetDisplayResolution()
 {
-        llinfos << "resetDisplayResolution START" << llendl;
+        LL_DEBUGS("Window") << "resetDisplayResolution START" << LL_ENDL;
 
         LONG cds_result = ChangeDisplaySettings(NULL, 0);
 
@@ -2768,10 +2765,10 @@ BOOL LLWindowWin32::resetDisplayResolution()
 
         if (!success)
         {
-                llwarns << "resetDisplayResolution failed" << llendl;
+                LL_WARNS("Window") << "resetDisplayResolution failed" << LL_ENDL;
         }
 
-        llinfos << "resetDisplayResolution END" << llendl;
+        LL_DEBUGS("Window") << "resetDisplayResolution END" << LL_ENDL;
 
         return success;
 }
@@ -2908,11 +2905,11 @@ void spawn_web_browser(const char* escaped_url )
 
         if (!found)
         {
-                llwarns << "spawn_web_browser() called for url with protocol not on whitelist: " << escaped_url << llendl;
+                LL_WARNS("Window") << "spawn_web_browser() called for url with protocol not on whitelist: " << escaped_url << LL_ENDL;
                 return;
         }
 
-        llinfos << "Opening URL " << escaped_url << llendl;
+        LL_INFOS("Window") << "Opening URL " << escaped_url << LL_ENDL;
 
         // replaced ShellExecute code with ShellExecuteEx since ShellExecute doesn't work
         // reliablly on Vista.
@@ -2952,7 +2949,7 @@ void spawn_web_browser(const char* escaped_url )
 
         if (browser_open_wstring.length() < 2)
         {
-                llwarns << "Invalid browser executable in registry " << browser_open_wstring << llendl;
+                LL_WARNS("Window") << "Invalid browser executable in registry " << browser_open_wstring << LL_ENDL;
                 return;
         }
 
@@ -2972,8 +2969,8 @@ void spawn_web_browser(const char* escaped_url )
                 browser_executable = browser_open_wstring.substr(0, space_pos);
         }
 
-        llinfos << "Browser reg key: " << wstring_to_utf8str(browser_open_wstring) << llendl;
-        llinfos << "Browser executable: " << wstring_to_utf8str(browser_executable) << llendl;
+        LL_DEBUGS("Window") << "Browser reg key: " << wstring_to_utf8str(browser_open_wstring) << LL_ENDL;
+        LL_INFOS("Window") << "Browser executable: " << wstring_to_utf8str(browser_executable) << LL_ENDL;
 
         // Convert URL to wide string for Windows API
         // Assume URL is UTF8, as can come from scripts
@@ -2995,11 +2992,11 @@ void spawn_web_browser(const char* escaped_url )
                                                                         SW_SHOWNORMAL);
         if (retval > 32)
         {
-                llinfos << "load_url success with " << retval << llendl;
+                LL_DEBUGS("Window") << "load_url success with " << retval << LL_ENDL;
         }
         else
         {
-                llinfos << "load_url failure with " << retval << llendl;
+                LL_INFOS("Window") << "load_url failure with " << retval << LL_ENDL;
         }
         */
 }
@@ -3541,7 +3538,7 @@ BOOL LLWindowWin32::handleImeRequests(U32 request, U32 param, LRESULT *result)
 
                                 if (!mPreeditor->getPreeditLocation(position, &caret_coord, &preedit_bounds, &text_control))
                                 {
-                                        llwarns << "*** IMR_QUERYCHARPOSITON called but getPreeditLocation failed." << llendl;
+                                        LL_WARNS("Window") << "*** IMR_QUERYCHARPOSITON called but getPreeditLocation failed." << LL_ENDL;
                                         return FALSE;
                                 }
                                 fillCharPosition(caret_coord, preedit_bounds, text_control, char_position);
@@ -3628,5 +3625,13 @@ BOOL LLWindowWin32::handleImeRequests(U32 request, U32 param, LRESULT *result)
         return FALSE;
 }
 
+//static
+std::string LLWindowWin32::getFontListSans()
+{
+        // Lists Japanese, Korean, and Chinese sanserif fonts available in
+        // Windows XP and Vista, as well as "Arial Unicode MS".
+        return "MSGOTHIC.TTC;gulim.ttc;simhei.ttf;ArialUni.ttf";
+}
+
 
 #endif // LL_WINDOWS
diff --git a/linden/indra/llwindow/llwindowwin32.h b/linden/indra/llwindow/llwindowwin32.h
index 5535af4..feb1c74 100644
--- a/linden/indra/llwindow/llwindowwin32.h
+++ b/linden/indra/llwindow/llwindowwin32.h
@@ -116,6 +116,8 @@ public:
         /*virtual*/ void updateLanguageTextInputArea();
         /*virtual*/ void interruptLanguageTextInput();
 
+        static std::string getFontListSans();
+
 protected:
         LLWindowWin32(
                 char *title, char *name, int x, int y, int width, int height, U32 flags, 
diff --git a/linden/indra/llwindow/llwindowlinux.cpp b/linden/indra/newview/llanimstatelabels.cpp
index 6c026e4..c51740f 100644
--- a/linden/indra/llwindow/llwindowlinux.cpp
+++ b/linden/indra/newview/llanimstatelabels.cpp
@@ -1,6 +1,6 @@
 /** 
- * @file llwindowlinux.cpp
- * @brief Platform-dependent implementation of llwindow
+ * @file llanimationstatenames.cpp
+ * @brief Names for built-in animation states
  *
  * $LicenseInfo:firstyear=2001&license=viewergpl$
  * 
@@ -29,33 +29,11 @@
  * $/LicenseInfo$
  */
 
-#if LL_LINUX
+#include "llviewerprecompiledheaders.h"
+#include "llanimstatelabels.h"
+#include "lltrans.h"
 
-#include "linden_common.h"
-#include "indra_constants.h"
-
-#include "llwindowlinux.h"
-#include "llgl.h"
-#include "llglheaders.h"
-
-//
-// LLWindowLinux
-//
-LLWindowLinux::LLWindowLinux(char *title, char *name, S32 x, S32 y, S32 width, S32 height,
-                                                         U32 flags,  BOOL fullscreen, BOOL clearBg,
-                                                         BOOL disable_vsync, BOOL use_gl, BOOL ignore_pixel_depth)
-        : LLWindow(fullscreen, flags)
-{
-        llerrs << "Linux window not yet supported" << llendl;
-}
-
-
-LLWindowLinux::~LLWindowLinux()
+std::string LLAnimStateLabels::getStateLabel( const char *animName )
 {
+        return LLTrans::getString("anim_" + LLString(animName) );
 }
-
-void LLWindowLinux::swapBuffers()
-{
-}
-
-#endif // LL_LINUX
diff --git a/linden/indra/llwindow/llwindowsolaris.cpp b/linden/indra/newview/llstylemap.h
index 54a77ae..2e9339c 100644
--- a/linden/indra/llwindow/llwindowsolaris.cpp
+++ b/linden/indra/newview/llstylemap.h
@@ -1,10 +1,10 @@
 /** 
- * @file fmodwrapper.cpp
- * @brief dummy source file for building a shared library to wrap libfmod.a
+ * @file LLStyleMap.h
+ * @brief LLStyleMap class definition
  *
- * $LicenseInfo:firstyear=2005&license=viewergpl$
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
  * 
- * Copyright (c) 2005-2008, Linden Research, Inc.
+ * Copyright (c) 2002-2008, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -29,33 +29,26 @@
  * $/LicenseInfo$
  */
 
-#if LL_SOLARIS
 
-#include "linden_common.h"
-#include "indra_constants.h"
+#ifndef LL_LLSTYLE_MAP_H
+#define LL_LLSTYLE_MAP_H
 
-#include "llwindowsolaris.h"
-#include "llgl.h"
-#include "llglheaders.h"
-
-//
-// LLWindowSolaris
-//
-LLWindowSolaris::LLWindowSolaris(char *title, char *name, S32 x, S32 y, S32 width, S32 height,
-                                                         U32 flags,  BOOL fullscreen, BOOL clearBg,
-                                                         BOOL disable_vsync, BOOL use_gl, BOOL ignore_pixel_depth)
-        : LLWindow(fullscreen, flags)
-{
-        llerrs << "Solaris window not yet supported" << llendl;
-}
+#include "llstyle.h"
+#include "lluuid.h"
 
+// Lightweight class for holding and managing mappings between UUIDs and links.
+// Used (for example) to create clickable name links off of IM chat.
 
-LLWindowSolaris::~LLWindowSolaris()
-{
-}
+typedef std::map<LLUUID, LLStyleSP> style_map_t;
 
-void LLWindowSolaris::swapBuffers()
+class LLStyleMap : public style_map_t
 {
-}
-
-#endif // LL_SOLARIS
+public:
+        LLStyleMap();
+        ~LLStyleMap();
+        // Just like the [] accessor but it will add the entry in if it doesn't exist.
+        const LLStyleSP &lookup(const LLUUID &source); 
+        static LLStyleMap &instance();
+};
+
+#endif  // LL_LLSTYLE_MAP_H