Index: linden/doc/contributions.txt =================================================================== --- linden/doc/contributions.txt (revision 56) +++ linden/doc/contributions.txt (revision 58) @@ -135,6 +135,7 @@ VWR-188 VWR-427 VWR-597 + VWR-2947 Joghert LeSabre VWR-64 Kage Pixel Index: linden/indra/newview/llviewermenu.cpp =================================================================== --- linden/indra/newview/llviewermenu.cpp (revision 56) +++ linden/indra/newview/llviewermenu.cpp (revision 58) @@ -7293,6 +7293,1692 @@ } }; +//------------------------------------------------------------------- +// Client debug menu +//------------------------------------------------------------------- + +class LLClientToggleConsole : public view_listener_t +{ + bool handleEvent(LLPointer 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 LLClientCheckConsole : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientDumpInfoToConsole : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientReloadSettingsOverrides : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + reload_personal_settings_overrides(NULL); + return true; + } +}; + +class LLClientToggleHUDInfo : public view_listener_t +{ + bool handleEvent(LLPointer 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 LLClientCheckHUDInfo : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientClearGroupCache : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLGroupMgr::debugClearAllGroups(NULL); + return true; + } +}; + +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 LLClientToggleRenderType : public view_listener_t +{ + bool handleEvent(LLPointer 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 LLClientCheckRenderType : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +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 LLClientToggleFeature : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + U32 feature = feature_from_string( userdata.asString() ); + + if ( feature != 0 ) + { + LLPipeline::toggleRenderDebugFeature( (void*)feature ); + } + + return true; + } +}; + +class LLClientCheckFeature : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +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 ("texture anim" == info_display) + { + return LLPipeline::RENDER_DEBUG_TEXTURE_ANIM; + } + else if ("texture priority" == info_display) + { + return LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY; + } + 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 ("particles" == info_display) + { + return LLPipeline::RENDER_DEBUG_PARTICLES; + } + else if ("composition" == info_display) + { + return LLPipeline::RENDER_DEBUG_COMPOSITION; + } + else if ("shadow map" == info_display) + { + return LLPipeline::RENDER_DEBUG_SHADOW_MAP; + } + else if ("light trace" == info_display) + { + return LLPipeline::RENDER_DEBUG_LIGHT_TRACE; + } + else if ("glow" == info_display) + { + return LLPipeline::RENDER_DEBUG_GLOW; + } + else + { + return 0; + } +}; + +class LLClientToggleInfoDisplay : public view_listener_t +{ + bool handleEvent(LLPointer 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 LLClientCheckInfoDisplay : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientToggleSelectBuffer : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugSelect = !(gDebugSelect); + return true; + } +}; + +class LLClientCheckSelectBuffer : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugSelect; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleVectorizePerfTest : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gVectorizePerfTest = !(gVectorizePerfTest); + return true; + } +}; + +class LLClientCheckVectorizePerfTest : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gVectorizePerfTest; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleRandomizeFramerate : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gRandomizeFramerate = !(gRandomizeFramerate); + return true; + } +}; + +class LLClientCheckRandomizeFramerate : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gRandomizeFramerate; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientTogglePeriodicSlowFrame : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gPeriodicSlowFrame = !(gPeriodicSlowFrame); + return true; + } +}; + +class LLClientCheckPeriodicSlowFrame : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gPeriodicSlowFrame; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleHideSelectedObjects : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gHideSelectedObjects = !(gHideSelectedObjects); + return true; + } +}; + +class LLClientCheckHideSelectedObjects : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gHideSelectedObjects; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientSelectedTextureInfo : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_selected_texture_info(NULL); + return true; + } +}; + +class LLClientToggleWireframe : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gUseWireframe = !(gUseWireframe); + return true; + } +}; + +class LLClientCheckWireframe : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gUseWireframe; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDisableTextures : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + menu_toggle_variable((void*)&LLViewerImage::sDontLoadVolumeTextures); + return true; + } +}; + +class LLClientCheckDisableTextures : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientDumpScriptedCamera : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_dump_followcam(NULL); + return true; + } +}; + +class LLClientDumpRegionObjectCache : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_dump_region_object_cache(NULL); + return true; + } +}; + +class LLClientSLURLTest : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_slurl_test(NULL); + return true; + } +}; + +class LLClientToggleEditableUI : public view_listener_t +{ + bool handleEvent(LLPointer 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. + +class LLClientToggleAsyncKeystrokes : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gHandleKeysAsync = !(gHandleKeysAsync); + return true; + } +}; + +class LLClientCheckAsyncKeystrokes : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gHandleKeysAsync; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientDumpSelectMgr : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + dump_select_mgr(NULL); + return true; + } +}; + +class LLClientDumpInventory : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + dump_inventory(NULL); + return true; + } +}; + +class LLClientDumpFocusHolder : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_dump_focus(NULL); + return true; + } +}; + +class LLClientDumpVolumeMgr : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + dump_volume_mgr(NULL); + return true; + } +}; + +class LLClientPrintSelectedObjectInfo : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + print_object_info(NULL); + return true; + } +}; + +class LLClientPrintAgentInfo : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + print_agent_nvpairs(NULL); + return true; + } +}; + +class LLClientPrintTextureMemoryStats : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + output_statistics(NULL); + return true; + } +}; + +class LLClientToggleDebugSelectMgr : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugSelectMgr = !(gDebugSelectMgr); + return true; + } +}; + +class LLClientCheckDebugSelectMgr : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugSelectMgr; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugClicks : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugClicks = !(gDebugClicks); + return true; + } +}; + +class LLClientCheckDebugClicks : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugClicks; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugViews : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLView::sDebugRects = !(LLView::sDebugRects); + return true; + } +}; + +class LLClientCheckDebugViews : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLView::sDebugRects; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleNameTooltips : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + toggle_show_xui_names(NULL); + return true; + } +}; + +class LLClientCheckNameTooltips : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientToggleDebugMouseEvents : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLView::sDebugMouseHandling = !(LLView::sDebugMouseHandling); + return true; + } +}; + +class LLClientCheckDebugMouseEvents : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLView::sDebugMouseHandling; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugKeys : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLView::sDebugKeys = !(LLView::sDebugKeys); + return true; + } +}; + +class LLClientCheckDebugKeys : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLView::sDebugKeys; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugWindowProc : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugWindowProc = !(gDebugWindowProc); + return true; + } +}; + +class LLClientCheckDebugWindowProc : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugWindowProc; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugTextEditorTips : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugTextEditorTips = !(gDebugTextEditorTips); + return true; + } +}; + +class LLClientCheckDebugTextEditorTips : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugTextEditorTips; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientShowFloaterTest : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLFloaterTest::show(NULL); + return true; + } +}; + +class LLClientExportMenusToXML : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_export_menus_to_xml(NULL); + return true; + } +}; + +class LLClientEditUI : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLFloaterEditUI::show(NULL); + return true; + } +}; + +class LLClientLoadUIFromXML : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_load_from_xml(NULL); + return true; + } +}; + +class LLClientSaveUIToXML : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_save_to_xml(NULL); + return true; + } +}; + +class LLClientToggleXUINames : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + toggle_show_xui_names(NULL); + return true; + } +}; + +class LLClientCheckXUINames : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientGrabBakedTexture : public view_listener_t +{ + bool handleEvent(LLPointer 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 LLClientEnableGrabBakedTexture : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientToggleAllowIdleAFK : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gAllowIdleAFK = !(gAllowIdleAFK); + return true; + } +}; + +class LLClientCheckAllowIdleAFK : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gAllowIdleAFK; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientAppearanceToXML : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::dumpArchetypeXML(NULL); + return true; + } +}; + +class LLClientToggleCharacterGeometry : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_god_request_avatar_geometry(NULL); + return true; + } +}; + +class LLClientTestMale : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_test_male(NULL); + return true; + } +}; + +class LLClientTestFemale : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_test_female(NULL); + return true; + } +}; + +class LLClientTogglePG : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_toggle_pg(NULL); + return true; + } +}; + +class LLClientToggleAllowSelectAvatar : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gAllowSelectAvatar = !(gAllowSelectAvatar); + return true; + } +}; + +class LLClientCheckAllowSelectAvatar : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gAllowSelectAvatar; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientForceParamsToDefault : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLAgent::clearVisualParams(NULL); + return true; + } +}; + +class LLClientReloadVertexShader : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + reload_vertex_shader(NULL); + return true; + } +}; + +class LLClientToggleAnimationInfo : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::sShowAnimationDebug = !(LLVOAvatar::sShowAnimationDebug); + return true; + } +}; + +class LLClientCheckAnimationInfo : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLVOAvatar::sShowAnimationDebug; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleSlowMotionAnimations : public view_listener_t +{ + bool handleEvent(LLPointer 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 + +class LLClientToggleShowLookAt : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLHUDEffectLookAt::sDebugLookAt = !(LLHUDEffectLookAt::sDebugLookAt); + return true; + } +}; + +class LLClientCheckShowLookAt : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLHUDEffectLookAt::sDebugLookAt; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleShowPointAt : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLHUDEffectPointAt::sDebugPointAt = !(LLHUDEffectPointAt::sDebugPointAt); + return true; + } +}; + +class LLClientCheckShowPointAt : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLHUDEffectPointAt::sDebugPointAt; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugJointUpdates : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::sJointDebug = !(LLVOAvatar::sJointDebug); + return true; + } +}; + +class LLClientCheckDebugJointUpdates : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLVOAvatar::sJointDebug; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDisableLOD : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLViewerJoint::sDisableLOD = !(LLViewerJoint::sDisableLOD); + return true; + } +}; + +class LLClientCheckDisableLOD : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLViewerJoint::sDisableLOD; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugCharacterVis : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::sDebugInvisible = !(LLVOAvatar::sDebugInvisible); + return true; + } +}; + +class LLClientCheckDebugCharacterVis : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLVOAvatar::sDebugInvisible; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleShowCollisionPlane : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::sShowFootPlane = !(LLVOAvatar::sShowFootPlane); + return true; + } +}; + +class LLClientCheckShowCollisionPlane : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLVOAvatar::sShowFootPlane; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleShowCollisionSkeleton : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLVOAvatar::sShowCollisionVolumes = !(LLVOAvatar::sShowCollisionVolumes); + return true; + } +}; + +class LLClientCheckShowCollisionSkeleton : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLVOAvatar::sShowCollisionVolumes; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDisplayAgentTarget : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLAgent::sDebugDisplayTarget = !(LLAgent::sDebugDisplayTarget); + return true; + } +}; + +class LLClientCheckDisplayAgentTarget : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLAgent::sDebugDisplayTarget; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleDebugAvatarRotation : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gDebugAvatarRotation = !(gDebugAvatarRotation); + return true; + } +}; + +class LLClientCheckDebugAvatarRotation : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gDebugAvatarRotation; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientDumpAttachments : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_dump_attachments(NULL); + return true; + } +}; + +class LLClientRebakeTextures : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_rebake_textures(NULL); + return true; + } +}; + +class LLClientDebugAvatarTextures : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_debug_avatar_textures(NULL); + return true; + } +}; + +class LLClientDumpAvatarLocalTextures : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_dump_avatar_local_textures(NULL); + return true; + } +}; + +class LLClientEnableMessageLog : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_viewer_enable_message_log(NULL); + return true; + } +}; + +class LLClientDisableMessageLog : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_viewer_disable_message_log(NULL); + return true; + } +}; + +class LLClientDropPacket : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + drop_packet(NULL); + return true; + } +}; + +class LLClientFrameStatsLogging : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientAgentPilot : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +class LLClientToggleAgentPilotLoop : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLAgentPilot::sLoop = !(LLAgentPilot::sLoop); + return true; + } +}; + +class LLClientCheckAgentPilotLoop : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = LLAgentPilot::sLoop; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleShowObjectUpdates : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + gShowObjectUpdates = !(gShowObjectUpdates); + return true; + } +}; + +class LLClientCheckShowObjectUpdates : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = gShowObjectUpdates; + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientCompressImage : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_compress_image(NULL); + return true; + } +}; + +class LLClientToggleJoystickFlycam : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_toggle_flycam(NULL); + return true; + } +}; + +class LLClientCheckJoystickFlycam : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = check_flycam(NULL); + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLClientToggleClothingFloater : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_clothing(NULL); + return true; + } +}; + +// There is no LLClientCheckClothingFloater. + +class LLClientShowDebugSettings : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLFloaterSettingsDebug::show(NULL); + return true; + } +}; + +class LLClientToggleViewAdminOptions : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_admin_override_toggle(NULL); + return true; + } +}; + +class LLClientCheckViewAdminOptions : public view_listener_t +{ + bool handleEvent(LLPointer 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; + } +}; + +//------------------------------------------------------------------- +// Server debug menu +//------------------------------------------------------------------- + +class LLEnableGodCustomerService : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = enable_god_customer_service(NULL); + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + +class LLEnableGodBasic : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + bool new_value = enable_god_basic(NULL); + LLString control_name = userdata["control"].asString(); + gMenuHolder->findControl(control_name)->setValue(new_value); + return true; + } +}; + + +class LLServerForceTakeCopy : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + force_take_copy(NULL); + return true; + } +}; + +class LLServerForceOwnerToMe : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_object_owner_self(NULL); + return true; + } +}; + +class LLServerForceOwnerPermissive : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_object_owner_permissive(NULL); + return true; + } +}; + +class LLServerForceDelete : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_force_delete(NULL); + return true; + } +}; + +class LLServerForceLock : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_object_lock(NULL); + return true; + } +}; + +class LLServerGetAssetIDs : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_object_asset_ids(NULL); + return true; + } +}; + +class LLServerForceParcelOwnerToMe : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_force_parcel_owner_to_me(NULL); + return true; + } +}; + +class LLServerForceParcelLindenContent : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_force_parcel_to_content(NULL); + return true; + } +}; + +class LLServerClaimPublicLand : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_claim_public_land(NULL); + return true; + } +}; + +class LLServerRegionDumpTempAssetData : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_region_dump_temp_asset_data(NULL); + return true; + } +}; + +class LLServerShowGodTools : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLFloaterGodTools::show(NULL); + return true; + } +}; + +class LLServerSaveRegionState : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLPanelRegionTools::onSaveState(NULL); + return true; + } +}; + +class LLServerRequestAdminStatus : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + handle_god_mode(NULL); + return true; + } +}; + +class LLServerLeaveAdminStatus : public view_listener_t +{ + bool handleEvent(LLPointer 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); @@ -7496,4 +9182,183 @@ addMenu(new LLSomethingSelected(), "SomethingSelected"); addMenu(new LLSomethingSelectedNoHUD(), "SomethingSelectedNoHUD"); addMenu(new LLEditableSelected(), "EditableSelected"); + + + // Client (top level menu) + addMenu(new LLClientToggleConsole(), "Client.ToggleConsole"); + addMenu(new LLClientCheckConsole(), "Client.CheckConsole"); + addMenu(new LLClientDumpInfoToConsole(), "Client.DumpInfoToConsole"); + addMenu(new LLClientReloadSettingsOverrides(), "Client.ReloadSettingsOverrides"); + + // Client > HUD Info + addMenu(new LLClientToggleHUDInfo(), "Client.ToggleHUDInfo"); + addMenu(new LLClientCheckHUDInfo(), "Client.CheckHUDInfo"); + + addMenu(new LLClientClearGroupCache(), "Client.ClearGroupCache"); + + // Client > Render > Types + addMenu(new LLClientToggleRenderType(), "Client.ToggleRenderType"); + addMenu(new LLClientCheckRenderType(), "Client.CheckRenderType"); + + // Client > Render > Features + addMenu(new LLClientToggleFeature(), "Client.ToggleFeature"); + addMenu(new LLClientCheckFeature(), "Client.CheckFeature"); + + // Client > Render > Info Displays + addMenu(new LLClientToggleInfoDisplay(), "Client.ToggleInfoDisplay"); + addMenu(new LLClientCheckInfoDisplay(), "Client.CheckInfoDisplay"); + addMenu(new LLClientToggleSelectBuffer(), "Client.ToggleSelectBuffer"); + addMenu(new LLClientCheckSelectBuffer(), "Client.CheckSelectBuffer"); + addMenu(new LLClientToggleVectorizePerfTest(), "Client.ToggleVectorizePerfTest"); + addMenu(new LLClientCheckVectorizePerfTest(), "Client.CheckVectorizePerfTest"); + addMenu(new LLClientToggleRandomizeFramerate(), "Client.ToggleRandomizeFramerate"); + addMenu(new LLClientCheckRandomizeFramerate(), "Client.CheckRandomizeFramerate"); + addMenu(new LLClientTogglePeriodicSlowFrame(), "Client.TogglePeriodicSlowFrame"); + addMenu(new LLClientCheckPeriodicSlowFrame(), "Client.CheckPeriodicSlowFrame"); + addMenu(new LLClientToggleHideSelectedObjects(), "Client.ToggleHideSelectedObjects"); + addMenu(new LLClientCheckHideSelectedObjects(), "Client.CheckHideSelectedObjects"); + addMenu(new LLClientSelectedTextureInfo(), "Client.SelectedTextureInfo"); + addMenu(new LLClientToggleWireframe(), "Client.ToggleWireframe"); + addMenu(new LLClientCheckWireframe(), "Client.CheckWireframe"); + addMenu(new LLClientToggleDisableTextures(), "Client.ToggleDisableTextures"); + addMenu(new LLClientCheckDisableTextures(), "Client.CheckDisableTextures"); + + // Client > World + addMenu(new LLClientDumpScriptedCamera(), "Client.DumpScriptedCamera"); + addMenu(new LLClientDumpRegionObjectCache(), "Client.DumpRegionObjectCache"); + + // Client > UI + addMenu(new LLClientSLURLTest(), "Client.SLURLTest"); + addMenu(new LLClientToggleEditableUI(), "Client.ToggleEditableUI"); + //addMenu(new LLClientCheckEditableUI(), "Client.CheckEditableUI"); + addMenu(new LLClientToggleAsyncKeystrokes(), "Client.ToggleAsyncKeystrokes"); + addMenu(new LLClientCheckAsyncKeystrokes(), "Client.CheckAsyncKeystrokes"); + addMenu(new LLClientDumpSelectMgr(), "Client.DumpSelectMgr"); + addMenu(new LLClientDumpInventory(), "Client.DumpInventory"); + addMenu(new LLClientDumpFocusHolder(), "Client.DumpFocusHolder"); + addMenu(new LLClientDumpVolumeMgr(), "Client.DumpVolumeMgr"); + addMenu(new LLClientPrintSelectedObjectInfo(), "Client.PrintSelectedObjectInfo"); + addMenu(new LLClientPrintAgentInfo(), "Client.PrintAgentInfo"); + addMenu(new LLClientPrintTextureMemoryStats(), "Client.PrintTextureMemoryStats"); + addMenu(new LLClientToggleDebugSelectMgr(), "Client.ToggleDebugSelectMgr"); + addMenu(new LLClientCheckDebugSelectMgr(), "Client.CheckDebugSelectMgr"); + addMenu(new LLClientToggleDebugClicks(), "Client.ToggleDebugClicks"); + addMenu(new LLClientCheckDebugClicks(), "Client.CheckDebugClicks"); + addMenu(new LLClientCheckDebugViews(), "Client.CheckDebugViews"); + addMenu(new LLClientToggleDebugViews(), "Client.ToggleDebugViews"); + addMenu(new LLClientToggleNameTooltips(), "Client.ToggleNameTooltips"); + addMenu(new LLClientCheckNameTooltips(), "Client.CheckNameTooltips"); + addMenu(new LLClientToggleDebugMouseEvents(), "Client.ToggleDebugMouseEvents"); + addMenu(new LLClientCheckDebugMouseEvents(), "Client.CheckDebugMouseEvents"); + addMenu(new LLClientToggleDebugKeys(), "Client.ToggleDebugKeys"); + addMenu(new LLClientCheckDebugKeys(), "Client.CheckDebugKeys"); + addMenu(new LLClientToggleDebugWindowProc(), "Client.ToggleDebugWindowProc"); + addMenu(new LLClientCheckDebugWindowProc(), "Client.CheckDebugWindowProc"); + addMenu(new LLClientToggleDebugTextEditorTips(), "Client.ToggleDebugTextEditorTips"); + addMenu(new LLClientCheckDebugTextEditorTips(), "Client.CheckDebugTextEditorTips"); + + addMenu(new LLClientCheckDebugTextEditorTips(), "Client.CheckDebugTextEditorTips"); + + // Client > XUI + addMenu(new LLClientShowFloaterTest(), "Client.ShowFloaterTest"); + addMenu(new LLClientExportMenusToXML(), "Client.ExportMenusToXML"); + addMenu(new LLClientEditUI(), "Client.EditUI"); + addMenu(new LLClientLoadUIFromXML(), "Client.LoadUIFromXML"); + addMenu(new LLClientSaveUIToXML(), "Client.SaveUIToXML"); + addMenu(new LLClientToggleXUINames(), "Client.ToggleXUINames"); + addMenu(new LLClientCheckXUINames(), "Client.CheckXUINames"); + + // Client > Character > Grab Baked Texture + addMenu(new LLClientGrabBakedTexture(), "Client.GrabBakedTexture"); + addMenu(new LLClientEnableGrabBakedTexture(), "Client.EnableGrabBakedTexture"); + + // Client > Character > Character Tests + addMenu(new LLClientToggleAllowIdleAFK(), "Client.ToggleAllowIdleAFK"); + addMenu(new LLClientCheckAllowIdleAFK(), "Client.CheckAllowIdleAFK"); + addMenu(new LLClientAppearanceToXML(), "Client.AppearanceToXML"); + addMenu(new LLClientToggleCharacterGeometry(), "Client.ToggleCharacterGeometry"); + addMenu(new LLClientTestMale(), "Client.TestMale"); + addMenu(new LLClientTestFemale(), "Client.TestFemale"); + addMenu(new LLClientTogglePG(), "Client.TogglePG"); + addMenu(new LLClientToggleAllowSelectAvatar(), "Client.ToggleAllowSelectAvatar"); + addMenu(new LLClientCheckAllowSelectAvatar(), "Client.CheckAllowSelectAvatar"); + + // Client > Character (toplevel) + addMenu(new LLClientForceParamsToDefault(), "Client.ForceParamsToDefault"); + addMenu(new LLClientReloadVertexShader(), "Client.ReloadVertexShader"); + addMenu(new LLClientToggleAnimationInfo(), "Client.ToggleAnimationInfo"); + addMenu(new LLClientCheckAnimationInfo(), "Client.CheckAnimationInfo"); + addMenu(new LLClientToggleSlowMotionAnimations(), "Client.ToggleSlowMotionAnimations"); + //addMenu(new LLClientCheckSlowMotionAnimations(), "Client.CheckSlowMotionAnimations"); + addMenu(new LLClientToggleShowLookAt(), "Client.ToggleShowLookAt"); + addMenu(new LLClientCheckShowLookAt(), "Client.CheckShowLookAt"); + addMenu(new LLClientToggleShowPointAt(), "Client.ToggleShowPointAt"); + addMenu(new LLClientCheckShowPointAt(), "Client.CheckShowPointAt"); + addMenu(new LLClientToggleDebugJointUpdates(), "Client.ToggleDebugJointUpdates"); + addMenu(new LLClientCheckDebugJointUpdates(), "Client.CheckDebugJointUpdates"); + addMenu(new LLClientToggleDisableLOD(), "Client.ToggleDisableLOD"); + addMenu(new LLClientCheckDisableLOD(), "Client.CheckDisableLOD"); + addMenu(new LLClientToggleDebugCharacterVis(), "Client.ToggleDebugCharacterVis"); + addMenu(new LLClientCheckDebugCharacterVis(), "Client.CheckDebugCharacterVis"); + addMenu(new LLClientToggleShowCollisionPlane(), "Client.ToggleShowCollisionPlane"); + addMenu(new LLClientCheckShowCollisionPlane(), "Client.CheckShowCollisionPlane"); + addMenu(new LLClientToggleShowCollisionSkeleton(), "Client.ToggleShowCollisionSkeleton"); + addMenu(new LLClientCheckShowCollisionSkeleton(), "Client.CheckShowCollisionSkeleton"); + addMenu(new LLClientToggleDisplayAgentTarget(), "Client.ToggleDisplayAgentTarget"); + addMenu(new LLClientCheckDisplayAgentTarget(), "Client.CheckDisplayAgentTarget"); + addMenu(new LLClientToggleDebugAvatarRotation(), "Client.ToggleDebugAvatarRotation"); + addMenu(new LLClientCheckDebugAvatarRotation(), "Client.CheckDebugAvatarRotation"); + addMenu(new LLClientDumpAttachments(), "Client.DumpAttachments"); + addMenu(new LLClientRebakeTextures(), "Client.RebakeTextures"); + addMenu(new LLClientDebugAvatarTextures(), "Client.DebugAvatarTextures"); + addMenu(new LLClientDumpAvatarLocalTextures(), "Client.DumpAvatarLocalTextures"); + + // Client > Network + addMenu(new LLClientEnableMessageLog(), "Client.EnableMessageLog"); + addMenu(new LLClientDisableMessageLog(), "Client.DisableMessageLog"); + addMenu(new LLClientDropPacket(), "Client.DropPacket"); + + // Client > Recorder + addMenu(new LLClientFrameStatsLogging(), "Client.FrameStatsLogging"); + addMenu(new LLClientAgentPilot(), "Client.AgentPilot"); + addMenu(new LLClientToggleAgentPilotLoop(), "Client.ToggleAgentPilotLoop"); + addMenu(new LLClientCheckAgentPilotLoop(), "Client.CheckAgentPilotLoop"); + + // Client (toplevel) + addMenu(new LLClientToggleShowObjectUpdates(), "Client.ToggleShowObjectUpdates"); + addMenu(new LLClientCheckShowObjectUpdates(), "Client.CheckShowObjectUpdates"); + addMenu(new LLClientCompressImage(), "Client.CompressImage"); + addMenu(new LLClientToggleJoystickFlycam(), "Client.ToggleJoystickFlycam"); + addMenu(new LLClientCheckJoystickFlycam(), "Client.CheckJoystickFlycam"); + addMenu(new LLClientToggleClothingFloater(), "Client.ToggleClothingFloater"); + addMenu(new LLClientShowDebugSettings(), "Client.ShowDebugSettings"); + addMenu(new LLClientToggleViewAdminOptions(), "Client.ToggleViewAdminOptions"); + addMenu(new LLClientCheckViewAdminOptions(), "Client.CheckViewAdminOptions"); + + // Server + addMenu(new LLEnableGodCustomerService(), "EnableGodCustomerService"); + addMenu(new LLEnableGodBasic(), "EnableGodBasic"); + + // Server > Object + addMenu(new LLServerForceTakeCopy(), "Server.ForceTakeCopy"); + addMenu(new LLServerForceOwnerToMe(), "Server.ForceOwnerToMe"); + addMenu(new LLServerForceOwnerPermissive(), "Server.ForceOwnerPermissive"); + addMenu(new LLServerForceDelete(), "Server.ForceDelete"); + addMenu(new LLServerForceLock(), "Server.ForceLock"); + addMenu(new LLServerGetAssetIDs(), "Server.GetAssetIDs"); + + // Server > Parcel + addMenu(new LLServerForceParcelOwnerToMe(), "Server.ForceParcelOwnerToMe"); + addMenu(new LLServerForceParcelLindenContent(), "Server.ForceParcelLindenContent"); + addMenu(new LLServerClaimPublicLand(), "Server.ClaimPublicLand"); + + // Server > Region + addMenu(new LLServerRegionDumpTempAssetData(), "Server.RegionDumpTempAssetData"); + + // Server (top level) + addMenu(new LLServerShowGodTools(), "Server.ShowGodTools"); + addMenu(new LLServerSaveRegionState(), "Server.SaveRegionState"); + + addMenu(new LLServerRequestAdminStatus(), "Server.RequestAdminStatus"); + addMenu(new LLServerLeaveAdminStatus(), "Server.LeaveAdminStatus"); }