Merge branch 'VWR-2896' into menu_viewer

Conflicts:
	linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml

3 files changed, 3217 insertions, 0 deletions

diff --git a/ChangeLog.txt b/ChangeLog.txt
index adb3efc..7dd2814 100644
--- a/ChangeLog.txt
+++ b/ChangeLog.txt
@@ -1,5 +1,13 @@
 2008-09-19  Jacek Antonelli  <jacek.antonelli@gmail.com>
 
+        * linden/indra/newview/llviewermenu.cpp: 
+        VWR-2947: Create event callbacks for Advanced menu functions.
+        Part of VWR-2896: Convert "Advanced" menu to XUI.
+
+        * linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml:
+        VWR-2948: Create XUI-based Advanced menu.
+        Part of VWR-2896: Convert "Advanced" menu to XUI.
+
         * linden/indra/SConstruct:
         New optional SConstruct flag to specify an exact path to build
         directory: BUILD_DIR. For convenience until we switch to CMake.
diff --git a/linden/indra/newview/llviewermenu.cpp b/linden/indra/newview/llviewermenu.cpp
index 3e99384..ae37d96 100644
--- a/linden/indra/newview/llviewermenu.cpp
+++ b/linden/indra/newview/llviewermenu.cpp
@@ -750,10 +750,13 @@ void init_menus()
         gLandmarkMenu = menu;
         */
 
+        // Advanced (Client) menu is XUI now! \o/
+        /*
         menu = new LLMenuGL(CLIENT_MENU_NAME);
         init_client_menu(menu);
         gMenuBarView->appendMenu( menu );
         menu->updateParent(LLMenuGL::sMenuContainer);
+        */
 
         menu = new LLMenuGL(SERVER_MENU_NAME);
         init_server_menu(menu);
@@ -7720,6 +7723,2118 @@ class LLWorldDayCycle : public view_listener_t
 
 
 
+
+//-------------------------------------------------------------------
+// Advanced menu
+//-------------------------------------------------------------------
+
+
+///////////////////
+// SHOW CONSOLES //
+///////////////////
+
+
+class LLAdvancedToggleConsole : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString console_type = userdata.asString();
+                if ("frame" == console_type)
+                {
+                        toggle_visibility( (void*)gDebugView->mFrameStatView );
+                }
+                else if ("texture" == console_type)
+                {
+                        toggle_visibility( (void*)gTextureView );
+                }
+                else if ("debug" == console_type)
+                {
+                        toggle_visibility( (void*)((LLView*)gDebugView->mDebugConsolep) );
+                }
+                else if ("fast timers" == console_type)
+                {
+                        toggle_visibility( (void*)gDebugView->mFastTimerView );
+                }
+                else if ("memory" == console_type)
+                {
+                        toggle_visibility( (void*)gDebugView->mMemoryView );
+                }
+                return true;
+        }
+};
+
+
+class LLAdvancedCheckConsole : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString console_type = userdata["data"].asString();
+                bool new_value = false;
+                if ("frame" == console_type)
+                {
+                        new_value = get_visibility( (void*)gDebugView->mFrameStatView );
+                }
+                else if ("texture" == console_type)
+                {
+                        new_value = get_visibility( (void*)gTextureView );
+                }
+                else if ("debug" == console_type)
+                {
+                        new_value = get_visibility( (void*)((LLView*)gDebugView->mDebugConsolep) );
+                }
+                else if ("fast timers" == console_type)
+                {
+                        new_value = get_visibility( (void*)gDebugView->mFastTimerView );
+                }
+                else if ("memory" == console_type)
+                {
+                        new_value = get_visibility( (void*)gDebugView->mMemoryView );
+                }
+
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////////
+// DUMP INFO TO CONSOLE //
+//////////////////////////
+
+
+class LLAdvancedDumpInfoToConsole : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString info_type = userdata.asString();
+                if ("region" == info_type)
+                {
+                        handle_region_dump_settings(NULL);
+                }
+                else if ("group" == info_type)
+                {
+                        handle_dump_group_info(NULL);
+                }
+                else if ("capabilities" == info_type)
+                {
+                        handle_dump_capabilities_info(NULL);
+                }
+                return true;
+        }
+};
+
+
+
+///////////////////////////////
+// RELOAD SETTINGS OVERRIDES //
+///////////////////////////////
+
+
+class LLAdvancedReloadSettingsOverrides : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                reload_personal_settings_overrides(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////
+// HUD INFO //
+//////////////
+
+
+class LLAdvancedToggleHUDInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString info_type = userdata.asString();
+                if ("velocity" == info_type)
+                {
+                        toggle_visibility( (void*)gVelocityBar );
+                }
+                else if ("camera" == info_type)
+                {
+                        gDisplayCameraPos = !(gDisplayCameraPos);
+                }
+                else if ("wind" == info_type)
+                {
+                        gDisplayWindInfo = !(gDisplayWindInfo);
+                }
+                else if ("fov" == info_type)
+                {
+                        gDisplayFOV = !(gDisplayFOV);
+                }
+                return true;
+        }
+};
+
+class LLAdvancedCheckHUDInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString info_type = userdata["data"].asString();
+                bool new_value = false;
+                if ("velocity" == info_type)
+                {
+                        new_value = get_visibility( (void*)gVelocityBar );
+                }
+                else if ("camera" == info_type)
+                {
+                        new_value = gDisplayCameraPos;
+                }
+                else if ("wind" == info_type)
+                {
+                        new_value = gDisplayWindInfo;
+                }
+                else if ("fov" == info_type)
+                {
+                        new_value = gDisplayFOV;
+                }
+
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// CLEAR GROUP CACHE //
+///////////////////////
+
+
+class LLAdvancedClearGroupCache : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLGroupMgr::debugClearAllGroups(NULL);
+                return true;
+        }
+};
+
+
+
+
+/////////////////
+// RENDER TYPE //
+/////////////////
+
+
+U32 render_type_from_string(LLString render_type)
+{
+        if ("simple" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_SIMPLE;
+        }
+        else if ("alpha" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_ALPHA;
+        }
+        else if ("tree" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_TREE;
+        }
+        else if ("avatar" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_AVATAR;
+        }
+        else if ("terrain" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_TERRAIN;
+        }
+        else if ("sky" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_SKY;
+        }
+        else if ("water" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_WATER;
+        }
+        else if ("ground" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_GROUND;
+        }
+        else if ("volume" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_VOLUME;
+        }
+        else if ("grass" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_GRASS;
+        }
+        else if ("clouds" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_CLOUDS;
+        }
+        else if ("particles" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_PARTICLES;
+        }
+        else if ("bump" == render_type)
+        {
+                return LLPipeline::RENDER_TYPE_BUMP;
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+
+class LLAdvancedToggleRenderType : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 render_type = render_type_from_string( userdata.asString() );
+                if ( render_type != 0 )
+                {
+                        LLPipeline::toggleRenderTypeControl( (void*)render_type );
+                }
+                return true;
+        }
+};
+
+
+class LLAdvancedCheckRenderType : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 render_type = render_type_from_string( userdata["data"].asString() );
+                bool new_value = false;
+
+                if ( render_type != 0 )
+                {
+                        new_value = LLPipeline::hasRenderTypeControl( (void*)render_type );
+                }
+                
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////
+// FEATURE //
+/////////////
+
+
+U32 feature_from_string(LLString feature)
+{
+        if ("ui" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_UI;
+        }
+        else if ("selected" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_SELECTED;
+        }
+        else if ("highlighted" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_HIGHLIGHTED;
+        }
+        else if ("dynamic textures" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_DYNAMIC_TEXTURES;
+        }
+        else if ("foot shadows" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_FOOT_SHADOWS;
+        }
+        else if ("fog" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_FOG;
+        }
+        else if ("palette" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_PALETTE;
+        }
+        else if ("fr info" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_FR_INFO;
+        }
+        else if ("flexible" == feature)
+        {
+                return LLPipeline::RENDER_DEBUG_FEATURE_FLEXIBLE;
+        }
+        else
+        {
+                return 0;
+        }
+};
+
+
+class LLAdvancedToggleFeature : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 feature = feature_from_string( userdata.asString() );
+
+                if ( feature != 0 )
+                {
+                        LLPipeline::toggleRenderDebugFeature( (void*)feature );
+                }
+
+                return true;
+        }
+};
+
+
+class LLAdvancedCheckFeature : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 feature = feature_from_string( userdata["data"].asString() );
+                bool new_value = false;
+
+                if ( feature != 0 )
+                {
+                        new_value = LLPipeline::toggleRenderDebugFeatureControl( (void*)feature );
+                }
+                
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////
+// INFO DISPLAY //
+//////////////////
+
+
+U32 info_display_from_string(LLString info_display)
+{
+        if ("verify" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_VERIFY;
+        }
+        else if ("bboxes" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_BBOXES;
+        }
+        else if ("points" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_POINTS;
+        }
+        else if ("octree" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_OCTREE;
+        }
+        else if ("occlusion" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_OCCLUSION;
+        }
+        else if ("render batches" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_BATCH_SIZE;
+        }
+        else if ("texture anim" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_TEXTURE_ANIM;
+        }
+        else if ("texture priority" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY;
+        }
+        else if ("shame" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_SHAME;
+        }
+        else if ("texture area" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_TEXTURE_AREA;
+        }
+        else if ("face area" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_FACE_AREA;
+        }
+        else if ("picking" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_PICKING;
+        }
+        else if ("lights" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_LIGHTS;
+        }
+        else if ("particles" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_PARTICLES;
+        }
+        else if ("composition" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_COMPOSITION;
+        }
+        else if ("glow" == info_display)
+        {
+                return LLPipeline::RENDER_DEBUG_GLOW;
+        }
+        else
+        {
+                return 0;
+        }
+};
+
+
+class LLAdvancedToggleInfoDisplay : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 info_display = info_display_from_string( userdata.asString() );
+
+                if ( info_display != 0 )
+                {
+                        LLPipeline::toggleRenderDebug( (void*)info_display );
+                }
+
+                return true;
+        }
+};
+
+
+class LLAdvancedCheckInfoDisplay : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                U32 info_display = info_display_from_string( userdata["data"].asString() );
+                bool new_value = false;
+
+                if ( info_display != 0 )
+                {
+                        new_value = LLPipeline::toggleRenderDebugControl( (void*)info_display );
+                }
+                
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////
+// SELECT BUFFER //
+///////////////////
+
+
+class LLAdvancedToggleSelectBuffer : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugSelect = !(gDebugSelect);
+                return true;
+        }
+};
+
+class LLAdvancedCheckSelectBuffer : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugSelect;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// RANDOMIZE FRAMERATE //
+/////////////////////////
+
+
+class LLAdvancedToggleRandomizeFramerate : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gRandomizeFramerate = !(gRandomizeFramerate);
+                return true;
+        }
+};
+
+class LLAdvancedCheckRandomizeFramerate : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gRandomizeFramerate;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// PERIODIC SLOW FRAME //
+/////////////////////////
+
+
+class LLAdvancedTogglePeriodicSlowFrame : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gPeriodicSlowFrame = !(gPeriodicSlowFrame);
+                return true;
+        }
+};
+
+class LLAdvancedCheckPeriodicSlowFrame : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gPeriodicSlowFrame;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////
+// FRAME TEST //
+////////////////
+
+
+class LLAdvancedToggleFrameTest : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLPipeline::sRenderFrameTest = !(LLPipeline::sRenderFrameTest);
+                return true;
+        }
+};
+
+class LLAdvancedCheckFrameTest : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLPipeline::sRenderFrameTest;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////////
+// HIDE SELECTED OBJECTS //
+///////////////////////////
+
+
+class LLAdvancedToggleHideSelectedObjects : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gHideSelectedObjects = !(gHideSelectedObjects);
+                return true;
+        }
+};
+
+class LLAdvancedCheckHideSelectedObjects : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gHideSelectedObjects;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////////
+// SELECTED TEXTURE INFO //
+///////////////////////////
+
+
+class LLAdvancedSelectedTextureInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_selected_texture_info(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// TOGGLE WIREFRAME //
+//////////////////////
+
+
+class LLAdvancedToggleWireframe : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gUseWireframe = !(gUseWireframe);
+                return true;
+        }
+};
+
+class LLAdvancedCheckWireframe : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gUseWireframe;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// DISABLE TEXTURES //
+//////////////////////
+
+
+class LLAdvancedToggleDisableTextures : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                menu_toggle_variable((void*)&LLViewerImage::sDontLoadVolumeTextures);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDisableTextures : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = menu_check_variable((void*)&LLViewerImage::sDontLoadVolumeTextures);
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////////
+// DUMP SCRIPTED CAMERA //
+//////////////////////////
+
+
+class LLAdvancedDumpScriptedCamera : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_dump_followcam(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////////////
+// DUMP REGION OBJECT CACHE //
+//////////////////////////////
+
+
+class LLAdvancedDumpRegionObjectCache : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_dump_region_object_cache(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////
+// SLURL TEST //
+////////////////
+
+
+class LLAdvancedSLURLTest : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_slurl_test(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////////
+// TOGGLE EDITABLE UI //
+////////////////////////
+
+
+class LLAdvancedToggleEditableUI : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                edit_ui(NULL);
+                return true;
+        }
+};
+
+// *TODO: Add corresponding "Check" for EditableUI, so it can
+// become a menu_item_check. Need to add check_edit_ui(void*)
+// or functional equivalent to do that.
+
+
+
+//////////////////////
+// ASYNC KEYSTROKES //
+//////////////////////
+
+
+class LLAdvancedToggleAsyncKeystrokes : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gHandleKeysAsync = !(gHandleKeysAsync);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAsyncKeystrokes : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gHandleKeysAsync;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////
+// DUMP SELECT MGR //
+/////////////////////
+
+
+class LLAdvancedDumpSelectMgr : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                dump_select_mgr(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////
+// DUMP INVENTORY //
+////////////////////
+
+
+class LLAdvancedDumpInventory : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                dump_inventory(NULL);
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// DUMP FOCUS HOLDER //
+///////////////////////
+
+
+class LLAdvancedDumpFocusHolder : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_dump_focus(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////////////////
+// PRINT SELECTED OBJECT INFO //
+////////////////////////////////
+
+
+class LLAdvancedPrintSelectedObjectInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                print_object_info(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// PRINT AGENT INFO //
+//////////////////////
+
+
+class LLAdvancedPrintAgentInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                print_agent_nvpairs(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////////////////
+// PRINT TEXTURE MEMORY STATS //
+////////////////////////////////
+
+
+class LLAdvancedPrintTextureMemoryStats : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                output_statistics(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// DEBUG SELECT MGR //
+//////////////////////
+
+
+class LLAdvancedToggleDebugSelectMgr : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugSelectMgr = !(gDebugSelectMgr);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugSelectMgr : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugSelectMgr;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////
+// DEBUG CLICKS //
+//////////////////
+
+
+class LLAdvancedToggleDebugClicks : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugClicks = !(gDebugClicks);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugClicks : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugClicks;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////
+// DEBUG VIEWS //
+/////////////////
+
+
+class LLAdvancedToggleDebugViews : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLView::sDebugRects = !(LLView::sDebugRects);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugViews : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLView::sDebugRects;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// XUI NAME TOOLTIPS //
+///////////////////////
+
+
+class LLAdvancedToggleXUINameTooltips : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                toggle_show_xui_names(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedCheckXUINameTooltips : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = check_show_xui_names(NULL);
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////////
+// DEBUG MOUSE EVENTS //
+////////////////////////
+
+
+class LLAdvancedToggleDebugMouseEvents : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLView::sDebugMouseHandling = !(LLView::sDebugMouseHandling);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugMouseEvents : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLView::sDebugMouseHandling;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////
+// DEBUG KEYS //
+////////////////
+
+
+class LLAdvancedToggleDebugKeys : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLView::sDebugKeys = !(LLView::sDebugKeys);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugKeys : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLView::sDebugKeys;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// DEBUG WINDOW PROC //
+///////////////////////
+
+
+class LLAdvancedToggleDebugWindowProc : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugWindowProc = !(gDebugWindowProc);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugWindowProc : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugWindowProc;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////////////
+// DEBUG TEXT EDITOR TIPS //
+////////////////////////////
+
+
+class LLAdvancedToggleDebugTextEditorTips : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugTextEditorTips = !(gDebugTextEditorTips);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugTextEditorTips : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugTextEditorTips;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// SHOW FLOATER TEST //
+///////////////////////
+
+
+class LLAdvancedShowFloaterTest : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLFloaterTest::show(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// EXPORT MENUS TO XML //
+/////////////////////////
+
+
+class LLAdvancedExportMenusToXML : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_export_menus_to_xml(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////
+// EDIT UI //
+/////////////
+
+
+class LLAdvancedEditUI : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLFloaterEditUI::show(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// LOAD UI FROM XML //
+//////////////////////
+
+
+class LLAdvancedLoadUIFromXML : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_load_from_xml(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////
+// SAVE UI TO XML //
+////////////////////
+
+
+class LLAdvancedSaveUIToXML : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_save_to_xml(NULL);
+                return true;
+        }
+};
+
+
+
+///////////////
+// XUI NAMES //
+///////////////
+
+
+class LLAdvancedToggleXUINames : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                toggle_show_xui_names(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedCheckXUINames : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = check_show_xui_names(NULL);
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////////
+// GRAB BAKED TEXTURE //
+////////////////////////
+
+
+class LLAdvancedGrabBakedTexture : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString texture_type = userdata.asString();
+                if ("eyes" == texture_type)
+                {
+                        handle_grab_texture( (void*)LLVOAvatar::TEX_EYES_BAKED );
+                }
+                else if ("head" == texture_type)
+                {
+                        handle_grab_texture( (void*)LLVOAvatar::TEX_HEAD_BAKED );
+                }
+                else if ("upper" == texture_type)
+                {
+                        handle_grab_texture( (void*)LLVOAvatar::TEX_UPPER_BAKED );
+                }
+                else if ("lower" == texture_type)
+                {
+                        handle_grab_texture( (void*)LLVOAvatar::TEX_SKIRT_BAKED );
+                }
+                else if ("skirt" == texture_type)
+                {
+                        handle_grab_texture( (void*)LLVOAvatar::TEX_SKIRT_BAKED );
+                }
+
+                return true;
+        }
+};
+
+class LLAdvancedEnableGrabBakedTexture : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString texture_type = userdata["data"].asString();
+                bool new_value = false;
+
+                if ("iris" == texture_type)
+                {
+                        new_value = enable_grab_texture( (void*)LLVOAvatar::TEX_EYES_BAKED );
+                }
+                else if ("head" == texture_type)
+                {
+                        new_value = enable_grab_texture( (void*)LLVOAvatar::TEX_HEAD_BAKED );
+                }
+                else if ("upper" == texture_type)
+                {
+                        new_value = enable_grab_texture( (void*)LLVOAvatar::TEX_UPPER_BAKED );
+                }
+                else if ("lower" == texture_type)
+                {
+                        new_value = enable_grab_texture( (void*)LLVOAvatar::TEX_LOWER_BAKED );
+                }
+                else if ("skirt" == texture_type)
+                {
+                        new_value = enable_grab_texture( (void*)LLVOAvatar::TEX_SKIRT_BAKED );
+                }
+                
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// ALLOW IDLE / AFK //
+//////////////////////
+
+
+class LLAdvancedToggleAllowIdleAFK : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gAllowIdleAFK = !(gAllowIdleAFK);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAllowIdleAFK : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gAllowIdleAFK;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////
+// APPEARANCE TO XML //
+///////////////////////
+
+
+class LLAdvancedAppearanceToXML : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::dumpArchetypeXML(NULL);
+                return true;
+        }
+};
+
+
+
+///////////////////////////////
+// TOGGLE CHARACTER GEOMETRY //
+///////////////////////////////
+
+
+class LLAdvancedToggleCharacterGeometry : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_god_request_avatar_geometry(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedEnableCharacterGeometry : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                enable_god_customer_service(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////////////////
+// TEST MALE / TEST FEMALE //
+/////////////////////////////
+
+
+class LLAdvancedTestMale : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_test_male(NULL);
+                return true;
+        }
+};
+
+
+class LLAdvancedTestFemale : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_test_female(NULL);
+                return true;
+        }
+};
+
+
+
+///////////////
+// TOGGLE PG //
+///////////////
+
+
+class LLAdvancedTogglePG : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_toggle_pg(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// ALLOW SELECT AVATAR //
+/////////////////////////
+
+
+class LLAdvancedToggleAllowSelectAvatar : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gAllowSelectAvatar = !(gAllowSelectAvatar);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAllowSelectAvatar : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gAllowSelectAvatar;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////////////
+// ALLOW TAP-TAP-HOLD RUN //
+////////////////////////////
+
+
+class LLAdvancedToggleAllowTapTapHoldRun : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gAllowTapTapHoldRun = !(gAllowTapTapHoldRun);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAllowTapTapHoldRun : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gAllowTapTapHoldRun;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////////
+// FORCE PARAMS TO DEFAULT //
+/////////////////////////////
+
+
+class LLAdvancedForceParamsToDefault : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLAgent::clearVisualParams(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////////
+// RELOAD VERTEX SHADER //
+//////////////////////////
+
+
+class LLAdvancedReloadVertexShader : public view_listener_t
+{
+  bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+  {
+    reload_vertex_shader(NULL);
+    return true;
+  }
+};
+
+
+
+////////////////////
+// ANIMATION INFO //
+////////////////////
+
+
+class LLAdvancedToggleAnimationInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::sShowAnimationDebug = !(LLVOAvatar::sShowAnimationDebug);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAnimationInfo : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLVOAvatar::sShowAnimationDebug;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////////////
+// SLOW MOTION ANIMATIONS //
+////////////////////////////
+
+
+class LLAdvancedToggleSlowMotionAnimations : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                slow_mo_animations(NULL);
+                return true;
+        }
+};
+
+// *TODO: Add a corresponding "Check" event for SlowMotionAnimations,
+// so that it can become a menu_item_check with the "X" indicator.
+// See indra/newview/skins/xui/en_us/menu_viewer.xml
+
+
+
+//////////////////
+// SHOW LOOK AT //
+//////////////////
+
+
+class LLAdvancedToggleShowLookAt : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLHUDEffectLookAt::sDebugLookAt = !(LLHUDEffectLookAt::sDebugLookAt);
+                return true;
+        }
+};
+
+class LLAdvancedCheckShowLookAt : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLHUDEffectLookAt::sDebugLookAt;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////
+// SHOW POINT AT //
+///////////////////
+
+
+class LLAdvancedToggleShowPointAt : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLHUDEffectPointAt::sDebugPointAt = !(LLHUDEffectPointAt::sDebugPointAt);
+                return true;
+        }
+};
+
+class LLAdvancedCheckShowPointAt : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLHUDEffectPointAt::sDebugPointAt;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// DEBUG JOINT UPDATES //
+/////////////////////////
+
+
+class LLAdvancedToggleDebugJointUpdates : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::sJointDebug = !(LLVOAvatar::sJointDebug);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugJointUpdates : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLVOAvatar::sJointDebug;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////
+// DISABLE LOD //
+/////////////////
+
+
+class LLAdvancedToggleDisableLOD : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLViewerJoint::sDisableLOD = !(LLViewerJoint::sDisableLOD);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDisableLOD : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLViewerJoint::sDisableLOD;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// DEBUG CHARACTER VIS //
+/////////////////////////
+
+
+class LLAdvancedToggleDebugCharacterVis : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::sDebugInvisible = !(LLVOAvatar::sDebugInvisible);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugCharacterVis : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLVOAvatar::sDebugInvisible;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////////
+// SHOW COLLISION PLANE //
+//////////////////////////
+
+/***************************
+ *
+ *  Disabled. See DEV-14477
+ *
+ ***************************
+
+class LLAdvancedToggleShowCollisionPlane : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::sShowFootPlane = !(LLVOAvatar::sShowFootPlane);
+                return true;
+        }
+};
+
+class LLAdvancedCheckShowCollisionPlane : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLVOAvatar::sShowFootPlane;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+***************************/
+
+
+/////////////////////////////
+// SHOW COLLISION SKELETON //
+/////////////////////////////
+
+
+class LLAdvancedToggleShowCollisionSkeleton : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLVOAvatar::sShowCollisionVolumes = !(LLVOAvatar::sShowCollisionVolumes);
+                return true;
+        }
+};
+
+class LLAdvancedCheckShowCollisionSkeleton : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLVOAvatar::sShowCollisionVolumes;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////////
+// DISPLAY AGENT TARGET //
+//////////////////////////
+
+
+class LLAdvancedToggleDisplayAgentTarget : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLAgent::sDebugDisplayTarget = !(LLAgent::sDebugDisplayTarget);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDisplayAgentTarget : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLAgent::sDebugDisplayTarget;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+///////////////////////////
+// DEBUG AVATAR ROTATION //
+///////////////////////////
+
+
+class LLAdvancedToggleDebugAvatarRotation : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gDebugAvatarRotation = !(gDebugAvatarRotation);
+                return true;
+        }
+};
+
+class LLAdvancedCheckDebugAvatarRotation : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gDebugAvatarRotation;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// DUMP ATTACHMENTS //
+//////////////////////
+
+
+class LLAdvancedDumpAttachments : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_dump_attachments(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////////
+// REBAKE TEXTURES //
+/////////////////////
+
+
+class LLAdvancedRebakeTextures : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_rebake_textures(NULL);
+                return true;
+        }
+};
+
+
+
+///////////////////////////
+// DEBUG AVATAR TEXTURES //
+///////////////////////////
+
+
+class LLAdvancedDebugAvatarTextures : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_debug_avatar_textures(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////////////////
+// DUMP AVATAR LOCAL TEXTURES //
+////////////////////////////////
+
+
+class LLAdvancedDumpAvatarLocalTextures : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_dump_avatar_local_textures(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////
+// MESSAGE LOG //
+/////////////////
+
+
+class LLAdvancedEnableMessageLog : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_viewer_enable_message_log(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedDisableMessageLog : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_viewer_disable_message_log(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////
+// DROP PACKET //
+/////////////////
+
+
+class LLAdvancedDropPacket : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                drop_packet(NULL);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// FRAME STATS LOGGING //
+/////////////////////////
+
+
+class LLAdvancedFrameStatsLogging : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString command = userdata.asString();
+                if ("start logging" == command)
+                {
+                        LLFrameStats::startLogging(NULL);
+                }
+                else if ("stop logging" == command)
+                {
+                        LLFrameStats::stopLogging(NULL);
+                }
+                else if ("timed logging 10" == command)
+                {
+                        LLFrameStats::timedLogging10(NULL);
+                }
+                else if ("timed logging 30" == command)
+                {
+                        LLFrameStats::timedLogging30(NULL);
+                }
+                else if ("timed logging 60" == command)
+                {
+                        LLFrameStats::timedLogging60(NULL);
+                }
+
+                return true;
+        }               
+};
+
+
+
+/////////////////
+// AGENT PILOT //
+/////////////////
+
+
+class LLAdvancedAgentPilot : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLString command = userdata.asString();
+                if ("start playback" == command)
+                {
+                        LLAgentPilot::startPlayback(NULL);
+                }
+                else if ("stop playback" == command)
+                {
+                        LLAgentPilot::stopPlayback(NULL);
+                }
+                else if ("start record" == command)
+                {
+                        LLAgentPilot::startRecord(NULL);
+                }
+                else if ("stop record" == command)
+                {
+                        LLAgentPilot::saveRecord(NULL);
+                }
+
+                return true;
+        }               
+};
+
+
+
+//////////////////////
+// AGENT PILOT LOOP //
+//////////////////////
+
+
+class LLAdvancedToggleAgentPilotLoop : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLAgentPilot::sLoop = !(LLAgentPilot::sLoop);
+                return true;
+        }
+};
+
+class LLAdvancedCheckAgentPilotLoop : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = LLAgentPilot::sLoop;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+/////////////////////////
+// SHOW OBJECT UPDATES //
+/////////////////////////
+
+
+class LLAdvancedToggleShowObjectUpdates : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                gShowObjectUpdates = !(gShowObjectUpdates);
+                return true;
+        }
+};
+
+class LLAdvancedCheckShowObjectUpdates : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = gShowObjectUpdates;
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+////////////////////
+// COMPRESS IMAGE //
+////////////////////
+
+
+class LLAdvancedCompressImage : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_compress_image(NULL);
+                return true;
+        }
+};
+
+
+
+//////////////////////
+// CLOTHING FLOATER //
+//////////////////////
+
+
+class LLAdvancedToggleClothingFloater : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_clothing(NULL);
+                return true;
+        }
+};
+
+// There is no LLAdvancedCheckClothingFloater.
+
+
+
+/////////////////////////
+// SHOW DEBUG SETTINGS //
+/////////////////////////
+
+
+class LLAdvancedShowDebugSettings : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                LLFloaterSettingsDebug::show(NULL);
+                return true;
+        }
+};
+
+
+
+////////////////////////
+// VIEW ADMIN OPTIONS //
+////////////////////////
+
+
+class LLAdvancedToggleViewAdminOptions : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_admin_override_toggle(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedCheckViewAdminOptions : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                bool new_value = check_admin_override(NULL);
+                LLString control_name = userdata["control"].asString();
+                gMenuHolder->findControl(control_name)->setValue(new_value);
+                return true;
+        }
+};
+
+
+
+//////////////////
+// ADMIN STATUS //
+//////////////////
+
+
+class LLAdvancedRequestAdminStatus : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_god_mode(NULL);
+                return true;
+        }
+};
+
+class LLAdvancedLeaveAdminStatus : public view_listener_t
+{
+        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
+        {
+                handle_leave_god_mode(NULL);
+                return true;
+        }
+};
+
+
+
 static void addMenu(view_listener_t *menu, const char *name)
 {
         sMenus.push_back(menu);
@@ -7928,4 +10043,155 @@ void initialize_menus()
         addMenu(new LLSomethingSelected(), "SomethingSelected");
         addMenu(new LLSomethingSelectedNoHUD(), "SomethingSelectedNoHUD");
         addMenu(new LLEditableSelected(), "EditableSelected");
+
+
+        // Advanced (top level menu)
+        addMenu(new LLAdvancedToggleConsole(), "Advanced.ToggleConsole");
+        addMenu(new LLAdvancedCheckConsole(), "Advanced.CheckConsole");
+        addMenu(new LLAdvancedDumpInfoToConsole(), "Advanced.DumpInfoToConsole");
+        addMenu(new LLAdvancedReloadSettingsOverrides(), "Advanced.ReloadSettingsOverrides");
+
+        // Advanced > HUD Info
+        addMenu(new LLAdvancedToggleHUDInfo(), "Advanced.ToggleHUDInfo");
+        addMenu(new LLAdvancedCheckHUDInfo(), "Advanced.CheckHUDInfo");
+
+        addMenu(new LLAdvancedClearGroupCache(), "Advanced.ClearGroupCache");
+
+        // Advanced > Render > Types
+        addMenu(new LLAdvancedToggleRenderType(), "Advanced.ToggleRenderType");
+        addMenu(new LLAdvancedCheckRenderType(), "Advanced.CheckRenderType");
+
+        // Advanced > Render > Features
+        addMenu(new LLAdvancedToggleFeature(), "Advanced.ToggleFeature");
+        addMenu(new LLAdvancedCheckFeature(), "Advanced.CheckFeature");
+
+        // Advanced > Render > Info Displays
+        addMenu(new LLAdvancedToggleInfoDisplay(), "Advanced.ToggleInfoDisplay");
+        addMenu(new LLAdvancedCheckInfoDisplay(), "Advanced.CheckInfoDisplay");
+        addMenu(new LLAdvancedToggleSelectBuffer(), "Advanced.ToggleSelectBuffer");
+        addMenu(new LLAdvancedCheckSelectBuffer(), "Advanced.CheckSelectBuffer");
+        addMenu(new LLAdvancedToggleRandomizeFramerate(), "Advanced.ToggleRandomizeFramerate");
+        addMenu(new LLAdvancedCheckRandomizeFramerate(), "Advanced.CheckRandomizeFramerate");
+        addMenu(new LLAdvancedTogglePeriodicSlowFrame(), "Advanced.TogglePeriodicSlowFrame");
+        addMenu(new LLAdvancedCheckPeriodicSlowFrame(), "Advanced.CheckPeriodicSlowFrame");
+        addMenu(new LLAdvancedToggleFrameTest(), "Advanced.ToggleFrameTest");
+        addMenu(new LLAdvancedCheckFrameTest(), "Advanced.CheckFrameTest");
+        addMenu(new LLAdvancedToggleHideSelectedObjects(), "Advanced.ToggleHideSelectedObjects");
+        addMenu(new LLAdvancedCheckHideSelectedObjects(), "Advanced.CheckHideSelectedObjects");
+        addMenu(new LLAdvancedSelectedTextureInfo(), "Advanced.SelectedTextureInfo");
+        addMenu(new LLAdvancedToggleWireframe(), "Advanced.ToggleWireframe");
+        addMenu(new LLAdvancedCheckWireframe(), "Advanced.CheckWireframe");
+        addMenu(new LLAdvancedToggleDisableTextures(), "Advanced.ToggleDisableTextures");
+        addMenu(new LLAdvancedCheckDisableTextures(), "Advanced.CheckDisableTextures");
+
+        // Advanced > World
+        addMenu(new LLAdvancedDumpScriptedCamera(), "Advanced.DumpScriptedCamera");
+        addMenu(new LLAdvancedDumpRegionObjectCache(), "Advanced.DumpRegionObjectCache");
+
+        // Advanced > UI
+        addMenu(new LLAdvancedSLURLTest(), "Advanced.SLURLTest");
+        addMenu(new LLAdvancedToggleEditableUI(), "Advanced.ToggleEditableUI");
+        //addMenu(new LLAdvancedCheckEditableUI(), "Advanced.CheckEditableUI");
+        addMenu(new LLAdvancedToggleAsyncKeystrokes(), "Advanced.ToggleAsyncKeystrokes");
+        addMenu(new LLAdvancedCheckAsyncKeystrokes(), "Advanced.CheckAsyncKeystrokes");
+        addMenu(new LLAdvancedDumpSelectMgr(), "Advanced.DumpSelectMgr");
+        addMenu(new LLAdvancedDumpInventory(), "Advanced.DumpInventory");
+        addMenu(new LLAdvancedDumpFocusHolder(), "Advanced.DumpFocusHolder");
+        addMenu(new LLAdvancedPrintSelectedObjectInfo(), "Advanced.PrintSelectedObjectInfo");
+        addMenu(new LLAdvancedPrintAgentInfo(), "Advanced.PrintAgentInfo");
+        addMenu(new LLAdvancedPrintTextureMemoryStats(), "Advanced.PrintTextureMemoryStats");
+        addMenu(new LLAdvancedToggleDebugSelectMgr(), "Advanced.ToggleDebugSelectMgr");
+        addMenu(new LLAdvancedCheckDebugSelectMgr(), "Advanced.CheckDebugSelectMgr");
+        addMenu(new LLAdvancedToggleDebugClicks(), "Advanced.ToggleDebugClicks");
+        addMenu(new LLAdvancedCheckDebugClicks(), "Advanced.CheckDebugClicks");
+        addMenu(new LLAdvancedCheckDebugViews(), "Advanced.CheckDebugViews");
+        addMenu(new LLAdvancedToggleDebugViews(), "Advanced.ToggleDebugViews");
+        addMenu(new LLAdvancedToggleXUINameTooltips(), "Advanced.ToggleXUINameTooltips");
+        addMenu(new LLAdvancedCheckXUINameTooltips(), "Advanced.CheckXUINameTooltips");
+        addMenu(new LLAdvancedToggleDebugMouseEvents(), "Advanced.ToggleDebugMouseEvents");
+        addMenu(new LLAdvancedCheckDebugMouseEvents(), "Advanced.CheckDebugMouseEvents");
+        addMenu(new LLAdvancedToggleDebugKeys(), "Advanced.ToggleDebugKeys");
+        addMenu(new LLAdvancedCheckDebugKeys(), "Advanced.CheckDebugKeys");
+        addMenu(new LLAdvancedToggleDebugWindowProc(), "Advanced.ToggleDebugWindowProc");
+        addMenu(new LLAdvancedCheckDebugWindowProc(), "Advanced.CheckDebugWindowProc");
+        addMenu(new LLAdvancedToggleDebugTextEditorTips(), "Advanced.ToggleDebugTextEditorTips");
+        addMenu(new LLAdvancedCheckDebugTextEditorTips(), "Advanced.CheckDebugTextEditorTips");
+
+        // Advanced > XUI
+        addMenu(new LLAdvancedShowFloaterTest(), "Advanced.ShowFloaterTest");
+        addMenu(new LLAdvancedExportMenusToXML(), "Advanced.ExportMenusToXML");
+        addMenu(new LLAdvancedEditUI(), "Advanced.EditUI");
+        addMenu(new LLAdvancedLoadUIFromXML(), "Advanced.LoadUIFromXML");
+        addMenu(new LLAdvancedSaveUIToXML(), "Advanced.SaveUIToXML");
+        addMenu(new LLAdvancedToggleXUINames(), "Advanced.ToggleXUINames");
+        addMenu(new LLAdvancedCheckXUINames(), "Advanced.CheckXUINames");
+
+        // Advanced > Character > Grab Baked Texture
+        addMenu(new LLAdvancedGrabBakedTexture(), "Advanced.GrabBakedTexture");
+        addMenu(new LLAdvancedEnableGrabBakedTexture(), "Advanced.EnableGrabBakedTexture");
+
+        // Advanced > Character > Character Tests
+        addMenu(new LLAdvancedToggleAllowIdleAFK(), "Advanced.ToggleAllowIdleAFK");
+        addMenu(new LLAdvancedCheckAllowIdleAFK(), "Advanced.CheckAllowIdleAFK");
+        addMenu(new LLAdvancedAppearanceToXML(), "Advanced.AppearanceToXML");
+        addMenu(new LLAdvancedToggleCharacterGeometry(), "Advanced.ToggleCharacterGeometry");
+        addMenu(new LLAdvancedTestMale(), "Advanced.TestMale");
+        addMenu(new LLAdvancedTestFemale(), "Advanced.TestFemale");
+        addMenu(new LLAdvancedTogglePG(), "Advanced.TogglePG");
+        addMenu(new LLAdvancedToggleAllowSelectAvatar(), "Advanced.ToggleAllowSelectAvatar");
+        addMenu(new LLAdvancedCheckAllowSelectAvatar(), "Advanced.CheckAllowSelectAvatar");
+
+        // Advanced > Character (toplevel)
+        addMenu(new LLAdvancedToggleAllowTapTapHoldRun(), "Advanced.ToggleAllowTapTapHoldRun");
+        addMenu(new LLAdvancedCheckAllowTapTapHoldRun(), "Advanced.CheckAllowTapTapHoldRun");
+        addMenu(new LLAdvancedForceParamsToDefault(), "Advanced.ForceParamsToDefault");
+        addMenu(new LLAdvancedReloadVertexShader(), "Advanced.ReloadVertexShader");
+        addMenu(new LLAdvancedToggleAnimationInfo(), "Advanced.ToggleAnimationInfo");
+        addMenu(new LLAdvancedCheckAnimationInfo(), "Advanced.CheckAnimationInfo");
+        addMenu(new LLAdvancedToggleSlowMotionAnimations(), "Advanced.ToggleSlowMotionAnimations");
+        //addMenu(new LLAdvancedCheckSlowMotionAnimations(), "Advanced.CheckSlowMotionAnimations");
+        addMenu(new LLAdvancedToggleShowLookAt(), "Advanced.ToggleShowLookAt");
+        addMenu(new LLAdvancedCheckShowLookAt(), "Advanced.CheckShowLookAt");
+        addMenu(new LLAdvancedToggleShowPointAt(), "Advanced.ToggleShowPointAt");
+        addMenu(new LLAdvancedCheckShowPointAt(), "Advanced.CheckShowPointAt");
+        addMenu(new LLAdvancedToggleDebugJointUpdates(), "Advanced.ToggleDebugJointUpdates");
+        addMenu(new LLAdvancedCheckDebugJointUpdates(), "Advanced.CheckDebugJointUpdates");
+        addMenu(new LLAdvancedToggleDisableLOD(), "Advanced.ToggleDisableLOD");
+        addMenu(new LLAdvancedCheckDisableLOD(), "Advanced.CheckDisableLOD");
+        addMenu(new LLAdvancedToggleDebugCharacterVis(), "Advanced.ToggleDebugCharacterVis");
+        addMenu(new LLAdvancedCheckDebugCharacterVis(), "Advanced.CheckDebugCharacterVis");
+//      addMenu(new LLAdvancedToggleShowCollisionPlane(), "Advanced.ToggleShowCollisionPlane");
+//      addMenu(new LLAdvancedCheckShowCollisionPlane(), "Advanced.CheckShowCollisionPlane");
+        addMenu(new LLAdvancedToggleShowCollisionSkeleton(), "Advanced.ToggleShowCollisionSkeleton");
+        addMenu(new LLAdvancedCheckShowCollisionSkeleton(), "Advanced.CheckShowCollisionSkeleton");
+        addMenu(new LLAdvancedToggleDisplayAgentTarget(), "Advanced.ToggleDisplayAgentTarget");
+        addMenu(new LLAdvancedCheckDisplayAgentTarget(), "Advanced.CheckDisplayAgentTarget");
+        addMenu(new LLAdvancedToggleDebugAvatarRotation(), "Advanced.ToggleDebugAvatarRotation");
+        addMenu(new LLAdvancedCheckDebugAvatarRotation(), "Advanced.CheckDebugAvatarRotation");
+        addMenu(new LLAdvancedDumpAttachments(), "Advanced.DumpAttachments");
+        addMenu(new LLAdvancedRebakeTextures(), "Advanced.RebakeTextures");
+        addMenu(new LLAdvancedDebugAvatarTextures(), "Advanced.DebugAvatarTextures");
+        addMenu(new LLAdvancedDumpAvatarLocalTextures(), "Advanced.DumpAvatarLocalTextures");
+
+        // Advanced > Network
+        addMenu(new LLAdvancedEnableMessageLog(), "Advanced.EnableMessageLog");
+        addMenu(new LLAdvancedDisableMessageLog(), "Advanced.DisableMessageLog");
+        addMenu(new LLAdvancedDropPacket(), "Advanced.DropPacket");
+
+        // Advanced > Recorder
+        addMenu(new LLAdvancedFrameStatsLogging(), "Advanced.FrameStatsLogging");
+        addMenu(new LLAdvancedAgentPilot(), "Advanced.AgentPilot");
+        addMenu(new LLAdvancedToggleAgentPilotLoop(), "Advanced.ToggleAgentPilotLoop");
+        addMenu(new LLAdvancedCheckAgentPilotLoop(), "Advanced.CheckAgentPilotLoop");
+
+        // Advanced (toplevel)
+        addMenu(new LLAdvancedToggleShowObjectUpdates(), "Advanced.ToggleShowObjectUpdates");
+        addMenu(new LLAdvancedCheckShowObjectUpdates(), "Advanced.CheckShowObjectUpdates");
+        addMenu(new LLAdvancedCompressImage(), "Advanced.CompressImage");
+        addMenu(new LLAdvancedToggleClothingFloater(), "Advanced.ToggleClothingFloater");
+        addMenu(new LLAdvancedShowDebugSettings(), "Advanced.ShowDebugSettings");
+        addMenu(new LLAdvancedToggleViewAdminOptions(), "Advanced.ToggleViewAdminOptions");
+        addMenu(new LLAdvancedCheckViewAdminOptions(), "Advanced.CheckViewAdminOptions");
+        addMenu(new LLAdvancedRequestAdminStatus(), "Advanced.RequestAdminStatus");
+        addMenu(new LLAdvancedLeaveAdminStatus(), "Advanced.LeaveAdminStatus");
 }
diff --git a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
index acdb963..e5a32ec 100644
--- a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml
@@ -708,4 +708,947 @@
         </menu>
 
 
+    <!-- ADVANCED -->
+  
+    <menu name="Advanced" drop_shadow="true" opaque="true" tear_off="true">
+  
+  
+  
+      <!-- CONSOLES -->
+  
+      <menu name="Consoles" drop_shadow="true" opaque="true" tear_off="true">
+        <menu_item_check name="Frame Console" label="Frame Console"
+                         shortcut="control|shift|2">
+          <on_click function="Advanced.ToggleConsole" userdata="frame" />
+          <on_check function="Advanced.CheckConsole" userdata="frame" />
+        </menu_item_check>
+        <menu_item_check name="Texture Console" label="Texture Console"
+                         shortcut="control|shift|3">
+          <on_click function="Advanced.ToggleConsole" userdata="texture" />
+          <on_check function="Advanced.CheckConsole" userdata="texture" />
+        </menu_item_check>
+        <menu_item_check name="Debug Console" label="Debug Console"
+                         shortcut="control|shift|4">
+          <on_click function="Advanced.ToggleConsole" userdata="debug" />
+          <on_check function="Advanced.CheckConsole" userdata="debug" />
+        </menu_item_check>
+        <menu_item_check name="Fast Timers" label="Fast Timers"
+                         shortcut="control|shift|9">
+          <on_click function="Advanced.ToggleConsole" userdata="fast timers" />
+          <on_check function="Advanced.CheckConsole" userdata="fast timers" />
+        </menu_item_check>
+        <!-- Requires compiled-in support, I think?
+        <menu_item_check name="Memory" label="Memory"
+                         shortcut="control|shift|0">
+          <on_click function="Advanced.ToggleConsole" userdata="memory" />
+          <on_check function="Advanced.CheckConsole" userdata="memory" />
+        </menu_item_check>
+        -->
+        <menu_item_separator />
+        <menu_item_call name="Region Info to Debug Console"
+                        label="Region Info to Debug Console">
+          <on_click function="Advanced.DumpInfoToConsole" userdata="region" />
+        </menu_item_call>
+        <menu_item_call name="Group Info to Debug Console"
+                        label="Group Info to Debug Console">
+          <on_click function="Advanced.DumpInfoToConsole" userdata="group" />
+        </menu_item_call>
+        <menu_item_call name="Capabilities Info to Debug Console"
+                        label="Capabilities Info to Debug Console">
+          <on_click function="Advanced.DumpInfoToConsole" 
+                    userdata="capabilities" />
+        </menu_item_call>
+      </menu>
+  
+  
+      <menu_item_call name="Reload personal setting overrides"
+                      label="Reload personal settings overrides"
+                      shortcut="control|shift|F2">
+        <on_click function="Advanced.ReloadSettingsOverrides" userdata="" />
+      </menu_item_call>
+  
+  
+  
+      <!-- HUD INFO -->
+  
+      <menu name="HUD Info" drop_shadow="true" opaque="true" tear_off="true">
+        <menu_item_check name="Velocity" label="Velocity">
+          <on_click function="Advanced.ToggleHUDInfo" userdata="velocity" />
+          <on_check function="Advanced.CheckHUDInfo" userdata="velocity" />
+        </menu_item_check>
+        <menu_item_check name="Camera" label="Camera">
+          <on_click function="Advanced.ToggleHUDInfo" userdata="camera" />
+          <on_check function="Advanced.CheckHUDInfo" userdata="camera" />
+        </menu_item_check>
+        <menu_item_check name="Wind" label="Wind">
+          <on_click function="Advanced.ToggleHUDInfo" userdata="wind" />
+          <on_check function="Advanced.CheckHUDInfo" userdata="wind" />
+        </menu_item_check>
+        <menu_item_check name="FOV" label="FOV">
+          <on_click function="Advanced.ToggleHUDInfo" userdata="fov" />
+          <on_check function="Advanced.CheckHUDInfo" userdata="fov" />
+        </menu_item_check>
+      </menu>
+  
+  
+      <menu_item_separator />
+  
+      <menu_item_check name="High-res Snapshot" label="High-res Snapshot">
+        <on_click function="ToggleControl" userdata="HighResSnapshot" />
+        <on_check control="HighResSnapshot" />
+      </menu_item_check>
+      <menu_item_check name="Quiet Snapshots to Disk"
+                       label="Quiet Snapshots to Disk">
+        <on_click function="ToggleControl" userdata="QuietSnapshotsToDisk" />
+        <on_check control="QuietSnapshotsToDisk" />
+      </menu_item_check>
+      <menu_item_check name="Compress Snapshots to Disk"
+                       label="Compress Snapshots to Disk">
+        <on_click function="ToggleControl" userdata="CompressSnapshotsToDisk" />
+        <on_check control="CompressSnapshotsToDisk" />
+      </menu_item_check>
+      <menu_item_check name="Show Mouselook Crosshairs"
+                       label="Show Mouselook Crosshairs">
+        <on_click function="ToggleControl" userdata="ShowCrosshairs" />
+        <on_check control="ShowCrosshairs" />
+      </menu_item_check>
+      <menu_item_check name="Debug Permissions" label="Debug Permissions">
+        <on_click function="ToggleControl" userdata="DebugPermissions" />
+        <on_check control="DebugPermissions" />
+      </menu_item_check>
+      <menu_item_call name="Clear Group Cache" label="Clear Group Cache">
+        <on_click function="Advanced.ClearGroupCache" userdata="" />
+      </menu_item_call>
+      <menu_item_separator />
+  
+  
+  
+      <!-- RENDERING -->
+  
+      <menu name="Rendering" drop_shadow="true" opaque="true" tear_off="true">
+  
+        <!-- TYPES -->
+        <menu name="Types" drop_shadow="true" opaque="true" tear_off="true">
+          <menu_item_check name="Simple" label="Simple"
+                           shortcut="control|alt|shift|1">
+            <on_click function="Advanced.ToggleRenderType" userdata="simple" />
+            <on_check function="Advanced.CheckRenderType" userdata="simple" />
+          </menu_item_check>
+          <menu_item_check name="Alpha" label="Alpha"
+                           shortcut="control|alt|shift|2">
+            <on_click function="Advanced.ToggleRenderType" userdata="alpha" />
+            <on_check function="Advanced.CheckRenderType" userdata="alpha" />
+          </menu_item_check>
+          <menu_item_check name="Tree" label="Tree"
+                           shortcut="control|alt|shift|3">
+            <on_click function="Advanced.ToggleRenderType" userdata="tree" />
+            <on_check function="Advanced.CheckRenderType" userdata="tree" />
+          </menu_item_check>
+          <menu_item_check name="Character" label="Character"
+                           shortcut="control|alt|shift|4">
+            <on_click function="Advanced.ToggleRenderType" userdata="avatar" />
+            <on_check function="Advanced.CheckRenderType" userdata="avatar" />
+          </menu_item_check>
+          <menu_item_check name="SurfacePatch" label="SurfacePatch"
+                           shortcut="control|alt|shift|5">
+            <on_click function="Advanced.ToggleRenderType" userdata="terrain" />
+            <on_check function="Advanced.CheckRenderType" userdata="terrain" />
+          </menu_item_check>
+          <menu_item_check name="Sky" label="Sky"
+                           shortcut="control|alt|shift|6">
+            <on_click function="Advanced.ToggleRenderType" userdata="sky" />
+            <on_check function="Advanced.CheckRenderType" userdata="sky" />
+          </menu_item_check>
+          <menu_item_check name="Water" label="Water"
+                           shortcut="control|alt|shift|7">
+            <on_click function="Advanced.ToggleRenderType" userdata="water" />
+            <on_check function="Advanced.CheckRenderType" userdata="water" />
+          </menu_item_check>
+          <menu_item_check name="Ground" label="Ground"
+                           shortcut="control|alt|shift|8">
+            <on_click function="Advanced.ToggleRenderType" userdata="ground" />
+            <on_check function="Advanced.CheckRenderType" userdata="ground" />
+          </menu_item_check>
+          <menu_item_check name="Volume" label="Volume"
+                           shortcut="control|alt|shift|9">
+            <on_click function="Advanced.ToggleRenderType" userdata="volume" />
+            <on_check function="Advanced.CheckRenderType" userdata="volume" />
+          </menu_item_check>
+          <menu_item_check name="Grass" label="Grass"
+                           shortcut="control|alt|shift|0">
+            <on_click function="Advanced.ToggleRenderType" userdata="grass" />
+            <on_check function="Advanced.CheckRenderType" userdata="grass" />
+          </menu_item_check>
+          <menu_item_check name="Clouds" label="Clouds"
+                           shortcut="control|alt|shift|-">
+            <on_click function="Advanced.ToggleRenderType" userdata="clouds" />
+            <on_check function="Advanced.CheckRenderType" userdata="clouds" />
+          </menu_item_check>
+          <menu_item_check name="Particles" label="Particles"
+                           shortcut="control|alt|shift|=">
+            <on_click function="Advanced.ToggleRenderType" 
+                      userdata="particles" />
+            <on_check function="Advanced.CheckRenderType" 
+                      userdata="particles" />
+          </menu_item_check>
+          <menu_item_check name="Bump" label="Bump"
+                           shortcut="control|alt|shift|\">
+            <on_click function="Advanced.ToggleRenderType" userdata="bump" />
+            <on_check function="Advanced.CheckRenderType" userdata="bump" />
+          </menu_item_check>
+        </menu>
+  
+  
+        <!-- FEATURES -->
+        <menu drop_shadow="true" name="Features" opaque="true" tear_off="true">
+          <menu_item_check name="UI" label="UI" shortcut="control|alt|F1">
+            <on_click function="Advanced.ToggleFeature" userdata="ui" />
+            <on_check function="Advanced.CheckFeature" userdata="ui" />
+          </menu_item_check>
+          <menu_item_check name="Selected" label="Selected"
+                           shortcut="control|alt|F2">
+            <on_click function="Advanced.ToggleFeature" userdata="selected" />
+            <on_check function="Advanced.CheckFeature" userdata="selected" />
+          </menu_item_check>
+          <menu_item_check name="Highlighted" label="Highlighted"
+                           shortcut="control|alt|F3">
+            <on_click function="Advanced.ToggleFeature" userdata="highlighted" />
+            <on_check function="Advanced.CheckFeature" userdata="highlighted" />
+          </menu_item_check>
+          <menu_item_check name="Dynamic Textures" label="Dynamic Textures"
+                           shortcut="control|alt|F4">
+            <on_click function="Advanced.ToggleFeature"
+                      userdata="dynamic textures" />
+            <on_check function="Advanced.CheckFeature"
+                      userdata="dynamic textures" />
+          </menu_item_check>
+          <menu_item_check name="Foot Shadows" label="Foot Shadows" 
+                           shortcut="control|alt|F5">
+            <on_click function="Advanced.ToggleFeature" 
+                      userdata="foot shadows" />
+            <on_check function="Advanced.CheckFeature" 
+                      userdata="foot shadows" />
+          </menu_item_check>
+          <menu_item_check name="Fog" label="Fog" shortcut="control|alt|F6">
+            <on_click function="Advanced.ToggleFeature" userdata="fog" />
+            <on_check function="Advanced.CheckFeature" userdata="fog" />
+          </menu_item_check>
+          <menu_item_check name="Palletized Textures"
+                           label="Palletized Textures"
+                           shortcut="control|alt|F7">
+            <on_click function="Advanced.ToggleFeature" userdata="palette" />
+            <on_check function="Advanced.CheckFeature" userdata="palette" />
+          </menu_item_check>
+          <menu_item_check name="Test FRInfo" label="Test FRInfo"
+                           shortcut="control|alt|F8">
+            <on_click function="Advanced.ToggleFeature" userdata="fr info" />
+            <on_check function="Advanced.CheckFeature" userdata="fr info" />
+          </menu_item_check>
+          <menu_item_check name="Flexible Objects" label="Flexible Objects"
+                           shortcut="control|alt|F9">
+            <on_click function="Advanced.ToggleFeature" userdata="flexible" />
+            <on_check function="Advanced.CheckFeature" userdata="flexible" />
+          </menu_item_check>
+        </menu>
+  
+  
+        <!-- INFO DISPLAYS -->
+        <menu drop_shadow="true" name="Info Displays"
+              opaque="true" tear_off="true">
+          <menu_item_check name="Verify" label="Verify">
+            <on_click function="Advanced.ToggleInfoDisplay" userdata="verify" />
+            <on_check function="Advanced.CheckInfoDisplay" userdata="verify" />
+          </menu_item_check>
+          <menu_item_check name="BBoxes" label="BBoxes">
+            <on_click function="Advanced.ToggleInfoDisplay" userdata="bboxes" />
+            <on_check function="Advanced.CheckInfoDisplay" userdata="bboxes" />
+          </menu_item_check>
+          <menu_item_check name="Points" label="Points">
+            <on_click function="Advanced.ToggleInfoDisplay" userdata="points" />
+            <on_check function="Advanced.CheckInfoDisplay" userdata="points" />
+          </menu_item_check>
+          <menu_item_check name="Octree" label="Octree">
+            <on_click function="Advanced.ToggleInfoDisplay" userdata="octree" />
+            <on_check function="Advanced.CheckInfoDisplay" userdata="octree" />
+          </menu_item_check>
+          <menu_item_check name="Occlusion" label="Occlusion">
+            <on_click function="Advanced.ToggleInfoDisplay" 
+                      userdata="occlusion" />
+            <on_check function="Advanced.CheckInfoDisplay" 
+                      userdata="occlusion" />
+          </menu_item_check>
+          <menu_item_check name="Render Batches" label="Render Batches">
+            <on_click function="Advanced.ToggleInfoDisplay" 
+                      userdata="render batches" />
+            <on_check function="Advanced.CheckInfoDisplay" 
+                      userdata="render batches" />
+          </menu_item_check>
+          <menu_item_check name="Animated Textures" label="Animated Textures">
+            <on_click function="Advanced.ToggleInfoDisplay" 
+                      userdata="texture anim" />
+            <on_check function="Advanced.CheckInfoDisplay" 
+                      userdata="texture anim" />
+          </menu_item_check>
+          <menu_item_check name="Texture Priority" label="Texture Priority">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="texture priority" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="texture priority" />
+          </menu_item_check>
+          <menu_item_check name="Avatar Rendering Cost"
+                           label="Avatar Rendering Cost">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="shame" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="shame" />
+          </menu_item_check>
+          <menu_item_check name="Texture Area (sqrt(A))"
+                           label="Texture Area (sqrt(A))">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="texture area" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="texture area" />
+          </menu_item_check>
+          <menu_item_check name="Face Area (sqrt(A))"
+                           label="Face Area (sqrt(A))">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="face area" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="face area" />
+          </menu_item_check>
+          <menu_item_check name="Pick Render" label="Pick Render">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="picking" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="picking" />
+          </menu_item_check>
+          <menu_item_check name="Lights" label="Lights">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="lights" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="lights" />
+          </menu_item_check>
+          <menu_item_check name="Particles" label="Particles">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="particles" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="particles" />
+          </menu_item_check>
+          <menu_item_check name="Composition" label="Composition">
+            <on_click function="Advanced.ToggleInfoDisplay"
+                      userdata="composition" />
+            <on_check function="Advanced.CheckInfoDisplay"
+                      userdata="composition" />
+          </menu_item_check>
+          <menu_item_check name="Glow" label="Glow">
+            <on_click function="Advanced.ToggleInfoDisplay" 
+                      userdata="glow" />
+            <on_check function="Advanced.CheckInfoDisplay" 
+                      userdata="glow" />
+          </menu_item_check>
+          <menu_item_check name="Show Depth Buffer" label="Show Depth Buffer">
+            <on_click function="ToggleControl" userdata="ShowDepthBuffer" />
+            <on_check control="ShowDepthBuffer" />
+          </menu_item_check>
+          <menu_item_check name="Show Select Buffer" label="Show Select Buffer">
+            <on_click function="Advanced.ToggleSelectBuffer" userdata="" />
+            <on_check function="Advanced.CheckSelectBuffer" userdata="" />
+          </menu_item_check>
+          <menu_item_check name="Vectorize Perf Test"
+                           label="Vectorize Perf Test">
+            <on_click function="ToggleControl" userdata="VectorizePerfTest" />
+            <on_check control="VectorizePerfTest" />
+          </menu_item_check>
+        </menu>
+  
+  
+        <!-- RENDER TESTS -->
+        <menu drop_shadow="true" name="Render Tests" opaque="true"
+              tear_off="true">
+          <menu_item_check name="Camera Offset" label="Camera Offset">
+            <on_click function="ToggleControl" userdata="CameraOffset" />
+            <on_check control="CameraOffset" />
+          </menu_item_check>
+          <menu_item_check name="Randomize Framerate"
+                           label="Randomize Framerate">
+            <on_click function="Advanced.ToggleRandomizeFramerate" 
+                      userdata="" />
+            <on_check function="Advanced.CheckRandomizeFramerate"
+                      userdata="" />
+          </menu_item_check>
+          <menu_item_check name="Periodic Slow Frame" 
+                           label="Periodic Slow Frame">
+            <on_click function="Advanced.TogglePeriodicSlowFrame" 
+                      userdata="" />
+            <on_check function="Advanced.CheckPeriodicSlowFrame" 
+                      userdata="" />
+          </menu_item_check>
+          <menu_item_check name="Frame Test" label="Frame Test">
+            <on_click function="Advanced.ToggleFrameTest" userdata="" />
+            <on_check function="Advanced.CheckFrameTest" userdata="" />
+          </menu_item_check>
+        </menu>
+  
+  
+        <menu_item_separator />
+  
+        <menu_item_check name="Axes" label="Axes">
+          <on_click function="ToggleControl" userdata="ShowAxes" />
+          <on_check control="ShowAxes" />
+        </menu_item_check>
+  
+        <menu_item_separator />
+  
+        <menu_item_check name="Hide Selected" label="Hide Selected">
+          <on_click function="Advanced.ToggleHideSelectedObjects" 
+                    userdata="" />
+          <on_check function="Advanced.CheckHideSelectedObjects"
+                    userdata="" />
+        </menu_item_check>
+  
+        <menu_item_separator />
+  
+        <menu_item_check name="Tangent Basis" label="Tangent Basis">
+          <on_click function="ToggleControl" userdata="ShowTangentBasis" />
+          <on_check control="ShowTangentBasis" />
+        </menu_item_check>
+        <menu_item_call name="Selected Texture Info" 
+                        label="Selected Texture Info"
+                        shortcut="control|alt|shift|T">
+          <on_click function="Advanced.SelectedTextureInfo" userdata="" />
+        </menu_item_call>
+        <menu_item_check name="Wireframe" label="Wireframe"
+                         shortcut="control|shift|R">
+          <on_click function="Advanced.ToggleWireframe" userdata="" />
+          <on_check function="Advanced.CheckWireframe" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Object-Object Occlusion"
+                         label="Object-Object Occlusion"
+                         shortcut="control|shift|O">
+          <on_click function="ToggleControl" userdata="UseOcclusion" />
+          <on_check control="UseOcclusion" />
+        </menu_item_check>
+        <menu_item_check name="Debug GL" label="Debug GL">
+          <on_click function="ToggleControl" userdata="RenderDebugGL" />
+          <on_check control="RenderDebugGL" />
+        </menu_item_check>
+        <menu_item_check name="Debug Pipeline" label="Debug Pipeline">
+          <on_click function="ToggleControl" userdata="RenderDebugPipeline" />
+          <on_check control="RenderDebugPipeline" />
+        </menu_item_check>
+        <menu_item_check name="Fast Alpha" label="Fast Alpha">
+          <on_click function="ToggleControl" userdata="RenderFastAlpha" />
+          <on_check control="RenderFastAlpha" />
+        </menu_item_check>
+        <menu_item_check name="Animate Textures" label="Animate Textures">
+          <on_click function="ToggleControl" userdata="AnimateTextures" />
+          <on_check control="AnimateTextures" />
+        </menu_item_check>
+        <menu_item_check name="Disable Textures" label="Disable Textures">
+          <on_click function="Advanced.ToggleDisableTextures" userdata="" />
+          <on_check function="Advanced.CheckDisableTextures" userdata="" />
+        </menu_item_check>
+        <!-- Disabled because it doesn't seem to be used anymore.
+        <menu_item_check name="HTTP Get Textures" label="HTTP Get Textures">
+          <on_click function="ToggleControl" 
+                    userdata="ImagePipelineUseHTTP" />
+          <on_check control="ImagePipelineUseHTTP" />
+        </menu_item_check>
+        -->
+        <menu_item_check name="Run Multiple Threads"
+                         label="Run Multiple Threads">
+          <on_click function="ToggleControl" 
+                    userdata="RunMultipleThreads" />
+          <on_check control="RunMultipleThreads" />
+        </menu_item_check>
+        <!-- Disabled because it doesn't work very well?
+        <menu_item_check name="Dynamic Reflections" 
+                         label="Dynamic Reflections">
+          <on_click function="ToggleControl"
+                    userdata="RenderDynamicReflections" />
+          <on_check control="RenderDynamicReflections" />
+        </menu_item_check>
+        -->
+        <menu_item_check name="Cheesy Beacon" label="Cheesy Beacon">
+          <on_click function="ToggleControl" 
+                    userdata="CheesyBeacon" />
+          <on_check control="CheesyBeacon" />
+        </menu_item_check>
+      </menu>
+  
+  
+  
+      <!-- WORLD -->
+  
+      <menu drop_shadow="true" name="World" opaque="true" tear_off="true">
+        <!-- Disabled because you can't do this in Windlight.
+        <menu_item_check name="Mouse Moves Sun" label="Mouse Moves Sun"
+                         shortcut="control|alt|M">
+          <on_click function="ToggleControl" userdata="MouseSun" />
+          <on_check control="MouseSun" />
+        </menu_item_check>
+        -->
+        <menu_item_check name="Sim Sun Override" label="Sim Sun Override">
+          <on_click function="ToggleControl"
+                    userdata="SkyOverrideSimSunPosition" />
+          <on_check control="SkyOverrideSimSunPosition" />
+        </menu_item_check>
+        <menu_item_call name="Dump Scripted Camera" 
+                        label="Dump Scripted Camera">
+          <on_click function="Advanced.DumpScriptedCamera" userdata="" />
+        </menu_item_call>
+        <menu_item_check name="Fixed Weather" label="Fixed Weather">
+          <on_click function="ToggleControl" userdata="FixedWeather" />
+          <on_check control="FixedWeather" />
+        </menu_item_check>
+        <menu_item_call name="Dump Region Object Cache"
+                        label="Dump Region Object Cache">
+          <on_click function="Advanced.DumpRegionObjectCache" userdata="" />
+        </menu_item_call>
+      </menu>
+  
+  
+  
+      <!-- UI -->
+  
+      <menu drop_shadow="true" name="UI" opaque="true" tear_off="true">
+        <menu_item_call name="SLURL Test" label="SLURL Test">
+          <on_click function="Advanced.SLURLTest" userdata="" />
+        </menu_item_call>
+  
+        <!-- 
+             *TODO: Make this a proper toggle item with the "X" indicator.
+             1. Add a "Advanced.CheckEditableUI" function in llviewermenu.cpp.
+             2. Change this surrounding menu_item_call to a menu_item_check.
+             3. Uncomment the "on_check" line below.
+          -->
+        <menu_item_call name="Editable UI" label="Editable UI">
+          <on_click function="Advanced.ToggleEditableUI" userdata="" />
+          <!--
+          <on_check function="Advanced.CheckEditableUI" userdata="" />
+          -->
+        </menu_item_call>
+  
+        <menu_item_check name="Async Keystrokes" label="Async Keystrokes">
+          <on_click function="Advanced.ToggleAsyncKeystrokes" userdata="" />
+          <on_check function="Advanced.CheckAsyncKeystrokes" userdata="" />
+        </menu_item_check>
+        <menu_item_call name="Dump SelectMgr" label="Dump SelectMgr">
+          <on_click function="Advanced.DumpSelectMgr" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Dump Inventory" label="Dump Inventory">
+          <on_click function="Advanced.DumpInventory" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Dump Focus Holder"
+                        label="Dump Focus Holder" shortcut="control|alt|F">
+          <on_click function="Advanced.DumpFocusHolder" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Print Selected Object Info"
+                        label="Print Selected Object Info"
+                        shortcut="control|shift|P">
+          <on_click function="Advanced.PrintSelectedObjectInfo" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Print Agent Info" label="Print Agent Info" 
+                        shortcut="shift|P">
+          <on_click function="Advanced.PrintAgentInfo" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Memory Stats" label="Memory Stats"
+                        shortcut="control|alt|shift|M">
+          <on_click function="Advanced.PrintTextureMemoryStats" userdata="" />
+        </menu_item_call>
+        <menu_item_check name="Double-Click Auto-Pilot"
+                         label="Double-Click Auto-Pilot">
+          <on_click function="ToggleControl" userdata="DoubleClickAutoPilot" />
+          <on_check control="DoubleClickAutoPilot" />
+        </menu_item_check>
+        <menu_item_separator />
+        <menu_item_check name="Debug SelectMgr" label="Debug SelectMgr">
+          <on_click function="Advanced.ToggleDebugSelectMgr" userdata="" />
+          <on_check function="Advanced.CheckDebugSelectMgr" userdata="" />
+        </menu_item_check>
+        <menu_item_check label="Debug Click" name="Debug Clicks">
+          <on_click function="Advanced.ToggleDebugClicks" userdata="" />
+          <on_check function="Advanced.CheckDebugClicks" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Views" label="Debug Views">
+          <on_click function="Advanced.ToggleDebugViews" userdata="" />
+          <on_check function="Advanced.CheckDebugViews" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Show Name Tooltips" label="Show Name Tooltips">
+          <on_click function="Advanced.ToggleXUINameTooltips" userdata="" />
+          <on_check function="Advanced.CheckXUINameTooltips" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Mouse Events" label="Debug Mouse Events">
+          <on_click function="Advanced.ToggleDebugMouseEvents" userdata="" />
+          <on_check function="Advanced.CheckDebugMouseEvents" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Keys" label="Debug Keys">
+          <on_click function="Advanced.ToggleDebugKeys" userdata="" />
+          <on_check function="Advanced.CheckDebugKeys" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug WindowProc" label="Debug WindowProc">
+          <on_click function="Advanced.ToggleDebugWindowProc" userdata="" />
+          <on_check function="Advanced.CheckDebugWindowProc" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Text Editor Tips"
+                         label="Debug Text Editor Tips">
+          <on_click function="Advanced.ToggleDebugTextEditorTips" userdata="" />
+          <on_check function="Advanced.CheckDebugTextEditorTips" userdata="" />
+        </menu_item_check>
+        <menu_item_separator />
+        <menu_item_check name="Show Time" label="Show Time">
+          <on_click function="ToggleControl" userdata="DebugShowTime" />
+          <on_check control="DebugShowTime" />
+        </menu_item_check>
+        <menu_item_check name="Show Render Info" label="Show Render Info">
+          <on_click function="ToggleControl" userdata="DebugShowRenderInfo" />
+          <on_check control="DebugShowRenderInfo" />
+        </menu_item_check>
+        <menu_item_check name="Show Color Under Cursor"
+                         label="Show Color Under Cursor">
+          <on_click function="ToggleControl" userdata="DebugShowColor" />
+          <on_check control="DebugShowColor" />
+        </menu_item_check>
+      </menu>
+  
+  
+  
+      <!-- XUI -->
+  
+      <menu drop_shadow="true" name="XUI" opaque="true" tear_off="true">
+        <menu_item_call name="Floater Test..." label="Floater Test...">
+          <on_click function="Advanced.ShowFloaterTest" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Export Menus to XML..."
+                        label="Export Menus to XML...">
+          <on_click function="Advanced.ExportMenusToXML" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Edit UI..." label="Edit UI...">
+          <on_click function="Advanced.EditUI" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Load from XML..." label="Load from XML...">
+          <on_click function="Advanced.LoadUIFromXML" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Save to XML..." label="Save to XML...">
+          <on_click function="Advanced.SaveUIToXML" userdata="" />
+        </menu_item_call>
+        <menu_item_check name="Show XUI Names" label="Show XUI Names">
+          <on_click function="Advanced.ToggleXUINames" userdata="" />
+          <on_check function="Advanced.CheckXUINames" userdata="" />
+        </menu_item_check>
+      </menu>
+  
+  
+  
+      <!-- CHARACTER -->
+  
+      <menu name="Character" drop_shadow="true" opaque="true" tear_off="true">
+  
+        <menu name="Grab Baked Texture" drop_shadow="true"
+              opaque="true" tear_off="true">
+          <menu_item_call enabled="false" name="Iris" label="Iris">
+            <on_click function="Advanced.GrabBakedTexture" userdata="eyes" />
+            <on_enable function="Advanced.EnableGrabBakedTexture"
+                       userdata="eyes" />
+          </menu_item_call>
+          <menu_item_call enabled="false" name="Head" label="Head">
+            <on_click function="Advanced.GrabBakedTexture" userdata="head" />
+            <on_enable function="Advanced.EnableGrabBakedTexture"
+                       userdata="head" />
+          </menu_item_call>
+          <menu_item_call enabled="false" name="Upper Body" label="Upper Body">
+            <on_click function="Advanced.GrabBakedTexture" userdata="upper" />
+            <on_enable function="Advanced.EnableGrabBakedTexture"
+                       userdata="upper" />
+          </menu_item_call>
+          <menu_item_call enabled="false" name="Lower Body" label="Lower Body">
+            <on_click function="Advanced.GrabBakedTexture" userdata="lower" />
+            <on_enable function="Advanced.EnableGrabBakedTexture"
+                       userdata="lower" />
+          </menu_item_call>
+          <menu_item_call enabled="false" name="Skirt" label="Skirt">
+            <on_click function="Advanced.GrabBakedTexture" userdata="skirt" />
+            <on_enable function="Advanced.EnableGrabBakedTexture"
+                       userdata="skirt" />
+          </menu_item_call>
+        </menu>
+  
+        <!-- CHARACTER TESTS -->
+        <menu drop_shadow="true" name="Character Tests"
+              opaque="true" tear_off="true">
+          <menu_item_check name="Go Away/AFK When Idle"
+                           label="Go Away/AFK When Idle">
+            <on_click function="Advanced.ToggleAllowIdleAFK" userdata="" />
+            <on_check function="Advanced.CheckAllowIdleAFK" userdata="" />
+          </menu_item_check>
+          <menu_item_call name="Appearance To XML" label="Appearance To XML">
+            <on_click function="Advanced.ToggleAppearanceToXML" userdata="" />
+          </menu_item_call>
+          <menu_item_call name="Toggle Character Geometry" enabled="false"
+                          label="Toggle Character Geometry">
+            <on_click function="Advanced.ToggleCharacterGeometry" userdata="" />
+            <on_enable function="EnableGodCustomerService" userdata="" />
+          </menu_item_call>
+          <menu_item_call name="Test Male" label="Test Male">
+            <on_click function="Advanced.TestMale" userdata="" />
+          </menu_item_call>
+          <menu_item_call name="Test Female" label="Test Female">
+            <on_click function="Advanced.TestFemale" userdata="" />
+          </menu_item_call>
+          <menu_item_call name="Toggle PG" label="Toggle PG">
+            <on_click function="Advanced.TogglePG" userdata="" />
+          </menu_item_call>
+          <menu_item_check name="Allow Select Avatar"
+                           label="Allow Select Avatar">
+            <on_click function="Advanced.ToggleAllowSelectAvatar" userdata="" />
+            <on_check function="Advanced.CheckAllowSelectAvatar" userdata="" />
+          </menu_item_check>
+        </menu>
+  
+        <menu_item_check name="Enable Lip Sync (Beta)" 
+                         label="Enable Lip Sync (Beta)">
+          <on_click function="ToggleControl" userdata="LipSyncEnabled" />
+          <on_check control="LipSyncEnabled" />
+        </menu_item_check>
+        <menu_item_check name="Tap-Tap-Hold To Run" 
+                         label="Tap-Tap-Hold To Run">
+          <on_click function="Advanced.ToggleAllowTapTapHoldRun" userdata="" />
+          <on_check function="Advanced.CheckAllowTapTapHoldRun" userdata="" />
+        </menu_item_check>
+        <menu_item_call name="Force Params to Default"
+                        label="Force Params to Default">
+          <on_click function="Advanced.ForceParamsToDefault" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Reload Vertex Shader"
+                        label="Reload Vertex Shader">
+          <on_click function="Advanced.ReloadVertexShader" userdata="" />
+        </menu_item_call>
+        <menu_item_check label="Animation Info"
+                         name="Animation Info">
+          <on_click function="Advanced.ToggleAnimationInfo" userdata="" />
+          <on_check function="Advanced.CheckAnimationInfo" userdata="" />
+        </menu_item_check>
+  
+        <!-- 
+             *TODO: Make this a proper toggle item with the "X" indicator.
+             1. Add a "Advanced.CheckSlowmotionAnimation" function in 
+             llviewermenu.cpp.
+             2. Change this surrounding menu_item_call to a menu_item_check.
+             3. Uncomment the "on_check" line below.
+          -->
+        <menu_item_call name="Slow Motion Animations"
+                        label="Slow Motion Animations">
+          <on_click function="Advanced.ToggleSlowMotionAnimations" userdata="" />
+          <!-- 
+          <on_check function="Advanced.CheckSlowMotionAnimations"
+                    userdata="" /> 
+          -->
+        </menu_item_call>
+  
+        <menu_item_check name="Show Look At" label="Show Look At">
+          <on_click function="Advanced.ToggleShowLookAt" userdata="" />
+          <on_check function="Advanced.CheckShowLookAt" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Show Point At" label="Show Point At">
+          <on_click function="Advanced.ToggleShowPointAt" userdata="" />
+          <on_check function="Advanced.CheckShowPointAt" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Joint Updates" label="Debug Joint Updates">
+          <on_click function="Advanced.ToggleDebugJointUpdates" userdata="" />
+          <on_check function="Advanced.CheckDebugJointUpdates" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Disable LOD" label="Disable LOD">
+          <on_click function="Advanced.ToggleDisableLOD" userdata="" />
+          <on_check function="Advanced.CheckDisableLOD" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Character Vis" label="Debug Character Vis">
+          <on_click function="Advanced.ToggleDebugCharacterVis" userdata="" />
+          <on_check function="Advanced.CheckDebugCharacterVis" userdata="" />
+        </menu_item_check>
+  
+        <!--  Disabled. See DEV-14477
+        <menu_item_check name="Show Collision Plane"
+                         label="Show Collision Plane">
+          <on_click function="Advanced.ToggleShowCollisionPlane"
+                    userdata="" />
+          <on_check function="Advanced.CheckShowCollisionPlane"
+                    userdata="" />
+        </menu_item_check>
+        -->
+  
+        <menu_item_check name="Show Collision Skeleton"
+                         label="Show Collision Skeleton">
+          <on_click function="Advanced.ToggleShowCollisionSkeleton"
+                    userdata="" />
+          <on_check function="Advanced.CheckShowCollisionSkeleton"
+                    userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Display Agent Target"
+                         label="Display Agent Target">
+          <on_click function="Advanced.ToggleDisplayAgentTarget" userdata="" />
+          <on_check function="Advanced.CheckDisplayAgentTarget" userdata="" />
+        </menu_item_check>
+        <menu_item_check name="Debug Rotation" label="Debug Rotation">
+          <on_click function="Advanced.ToggleDebugAvatarRotation" userdata="" />
+          <on_check function="Advanced.CheckDebugAvatarRotation" userdata="" />
+        </menu_item_check>
+        <menu_item_call name="Dump Attachments" label="Dump Attachments">
+          <on_click function="Advanced.DumpAttachments" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Rebake Textures" label="Rebake Textures"
+                        shortcut="control|alt|R">
+          <on_click function="Advanced.RebakeTextures" userdata="" />
+        </menu_item_call>
+      </menu>
+  
+  
+  
+      <!-- NETWORK -->
+  
+      <menu drop_shadow="true" name="Network" opaque="true" tear_off="true">
+        <menu_item_call name="Enable Message Log" label="Enable Message Log">
+          <on_click function="Advanced.EnableMessageLog" userdata="" />
+        </menu_item_call>
+        <menu_item_call name="Disable Message Log" label="Disable Message Log">
+          <on_click function="Advanced.DisableMessageLog" userdata="" />
+        </menu_item_call>
+        <menu_item_separator />
+        <menu_item_check name="Velocity Interpolate Objects"
+                         label="Velocity Interpolate Objects">
+          <on_click function="ToggleControl" userdata="VelocityInterpolate" />
+          <on_check control="VelocityInterpolate" />
+        </menu_item_check>
+        <menu_item_check name="Ping Interpolate Object Positions"
+                         label="Ping Interpolate Object Positions">
+          <on_click function="ToggleControl" userdata="PingInterpolate" />
+          <on_check control="PingInterpolate" />
+        </menu_item_check>
+        <menu_item_separator />
+        <menu_item_call name="Drop a Packet" label="Drop a Packet"
+                        shortcut="control|alt|L">
+          <on_click function="Advanced.DropPacket" userdata="" />
+        </menu_item_call>
+      </menu>
+  
+  
+  
+      <!-- RECORDER -->
+  
+      <menu name="Recorder" drop_shadow="true" opaque="true" tear_off="true">
+        <menu_item_check name="Full Session Logging"
+                         label="Full Session Logging">
+          <on_click function="ToggleControl"
+                    userdata="StatsSessionTrackFrameStats" />
+          <on_check control="StatsSessionTrackFrameStats" />
+        </menu_item_check>
+        <menu_item_call name="Start Logging" label="Start Logging">
+          <on_click function="Advanced.FrameStatsLogging" 
+                    userdata="start logging" />
+        </menu_item_call>
+        <menu_item_call name="Stop Logging" label="Stop Logging">
+          <on_click function="Advanced.FrameStatsLogging"
+                    userdata="stop logging" />
+        </menu_item_call>
+        <menu_item_call name="Log 10 Seconds" label="Log 10 Seconds">
+          <on_click function="Advanced.FrameStatsLogging"
+                    userdata="timed logging 10" />
+        </menu_item_call>
+        <menu_item_call name="Log 30 Seconds" label="Log 30 Seconds">
+          <on_click function="Advanced.FrameStatsLogging"
+                    userdata="timed logging 30" />
+        </menu_item_call>
+        <menu_item_call name="Log 60 Seconds" label="Log 60 Seconds">
+          <on_click function="Advanced.FrameStatsLogging"
+                    userdata="timed logging 60" />
+        </menu_item_call>
+  
+        <menu_item_separator />
+  
+        <menu_item_call name="Start Playback" label="Start Playback">
+          <on_click function="Advanced.AgentPilot" userdata="start playback" />
+        </menu_item_call>
+        <menu_item_call name="Stop Playback" label="Stop Playback">
+          <on_click function="Advanced.AgentPilot" userdata="stop playback" />
+        </menu_item_call>
+        <menu_item_check name="Loop Playback" label="Loop Playback">
+          <on_click function="Advanced.ToggleAgentPilotLoop" userdata="" />
+          <on_check function="Advanced.CheckAgentPilotLoop" userdata="" />
+        </menu_item_check>
+        <menu_item_call name="Start Record" label="Start Record">
+          <on_click function="Advanced.AgentPilot" userdata="start record" />
+        </menu_item_call>
+        <menu_item_call name="Stop Record" label="Stop Record">
+          <on_click function="Advanced.AgentPilot" userdata="stop record" />
+        </menu_item_call>
+      </menu>
+  
+  
+      <menu_item_separator />
+  
+  
+      <menu_item_check name="Show Updates" label="Show Updates"
+                       shortcut="control|alt|shift|U">
+        <on_click function="Advanced.ToggleShowObjectUpdates" userdata="" />
+        <on_check function="Advanced.CheckShowObjectUpdates" userdata="" />
+      </menu_item_check>
+  
+      <menu_item_separator />
+  
+      <menu_item_call name="Compress Image..."
+                      label="Compress Image...">
+        <on_click function="Advanced.CompressImage" userdata="" />
+      </menu_item_call>
+      <menu_item_check name="Limit Select Distance"
+                       label="Limit Select Distance">
+        <on_click function="ToggleControl"
+                  userdata="LimitSelectDistance" />
+        <on_check control="LimitSelectDistance" />
+      </menu_item_check>
+      <menu_item_check name="Disable Camera Constraints"
+                       label="Disable Camera Constraints">
+        <on_click function="ToggleControl"
+                  userdata="DisableCameraConstraints" />
+        <on_check control="DisableCameraConstraints" />
+      </menu_item_check>
+      <menu_item_check name="Mouse Smoothing" label="Mouse Smoothing">
+        <on_click function="ToggleControl"
+                  userdata="MouseSmooth" />
+        <on_check control="MouseSmooth" />
+      </menu_item_check>
+  
+      <menu_item_separator />
+  
+      <menu_item_check name="Console Window" label="Console Window">
+        <on_click function="ToggleControl" 
+                  userdata="ShowConsoleWindow" />
+        <on_check control="ShowConsoleWindow" />
+      </menu_item_check>
+      <menu_item_check name="Output Debug Minidump"
+                       label="Output Debug Minidump">
+        <on_click function="ToggleControl" 
+                  userdata="SaveMiniDump" />
+        <on_check control="SaveMiniDump" />
+      </menu_item_check>
+      <menu_item_check name="Clothing..." label="Clothing...">
+        <on_click function="Advanced.ToggleClothingFloater" userdata="" />
+      </menu_item_check>
+      <menu_item_call name="Debug Settings" label="Debug Settings">
+        <on_click function="Advanced.ShowDebugSettings" userdata="" />
+      </menu_item_call>
+      <menu_item_check name="View Admin Options" label="View Admin Options"
+                       shortcut="control|alt|V">
+        <on_click function="Advanced.ToggleViewAdminOptions" userdata="" />
+        <on_check function="Advanced.CheckViewAdminOptions" userdata="" />
+      </menu_item_check>
+      <menu_item_call name="Request Admin Status" label="Request Admin Status"
+                      shortcut="control|alt|G">
+        <on_click function="Advanced.RequestAdminStatus" userdata="" />
+      </menu_item_call>
+      <menu_item_call name="Leave Admin Status" label="Leave Admin Status"
+                      shortcut="control|alt|shift|G">
+        <on_click function="Advanced.LeaveAdminStatus" userdata="" />
+      </menu_item_call>
+  
+    </menu>
+  
 </menu_bar>