/** * @file llviewermenu.cpp * @brief Builds menus out of items. * * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc. * $License$ */ #include "llviewerprecompiledheaders.h" #include "llviewermenu.h" // system library includes #include #include #include // linden library includes #include "audioengine.h" #include "indra_constants.h" #include "llassetstorage.h" #include "llchat.h" #include "llfeaturemanager.h" #include "llfocusmgr.h" #include "llfontgl.h" #include "llinstantmessage.h" #include "llpermissionsflags.h" #include "llrect.h" #include "llsecondlifeurls.h" #include "lltransactiontypes.h" #include "llui.h" #include "llview.h" #include "llxfermanager.h" #include "message.h" #include "raytrace.h" #include "llsdserialize.h" #include "lltimer.h" #include "llvfile.h" #include "llvolumemgr.h" #include "llwindow.h" // for shell_open() // newview includes #include "llagent.h" #include "llagentpilot.h" #include "llbox.h" #include "llcallingcard.h" #include "llcameraview.h" #include "llclipboard.h" #include "llcompilequeue.h" #include "llconsole.h" #include "llviewercontrol.h" #include "lldebugview.h" #include "lldir.h" #include "lldrawable.h" #include "lldrawpoolalpha.h" #include "lldrawpooltree.h" #include "llface.h" #include "llfirstuse.h" #include "llfloater.h" #include "llfloaterabout.h" #include "llfloaterbuycurrency.h" #include "llfloateractivespeakers.h" #include "llfloateranimpreview.h" #include "llfloateravatarinfo.h" #include "llfloateravatartextures.h" #include "llfloaterbuildoptions.h" #include "llfloaterbump.h" #include "llfloaterbuy.h" #include "llfloaterbuycontents.h" #include "llfloaterbuycurrency.h" #include "llfloaterbuyland.h" #include "llfloaterchat.h" #include "llfloatercustomize.h" #include "llfloaterdirectory.h" #include "llfloatereditui.h" #include "llfloaterchatterbox.h" #include "llfloaterfriends.h" #include "llfloatergesture.h" #include "llfloatergodtools.h" #include "llfloatergroupinfo.h" #include "llfloatergroupinvite.h" #include "llfloatergroups.h" #include "llfloaterhtml.h" #include "llfloaterhtmlhelp.h" #include "llfloaterhtmlfind.h" #include "llfloaterinspect.h" #include "llfloaterland.h" #include "llfloaterlandholdings.h" #include "llfloatermap.h" #include "llfloatermute.h" #include "llfloateropenobject.h" #include "llfloaterpermissionsmgr.h" #include "llfloaterpreference.h" #include "llfloaterregioninfo.h" #include "llfloaterreporter.h" #include "llfloaterscriptdebug.h" #include "llfloatertest.h" #include "llfloatertools.h" #include "llfloaterworldmap.h" #include "llframestats.h" #include "llframestatview.h" #include "llfasttimerview.h" #include "llmemoryview.h" #include "llgivemoney.h" #include "llgroupmgr.h" #include "llhoverview.h" #include "llhudeffecttrail.h" #include "llhudmanager.h" #include "llimage.h" #include "llimagebmp.h" #include "llimagej2c.h" #include "llimagetga.h" #include "llinventorymodel.h" #include "llinventoryview.h" #include "llkeyboard.h" #include "llpanellogin.h" #include "llmenucommands.h" #include "llmenugl.h" #include "llmorphview.h" #include "llmoveview.h" #include "llmutelist.h" #include "llnotify.h" #include "llpanelobject.h" #include "llparcel.h" #include "llprimitive.h" #include "llresmgr.h" #include "llselectmgr.h" #include "llsky.h" #include "llstatusbar.h" #include "llstatview.h" #include "llstring.h" #include "llsurfacepatch.h" #include "llimview.h" #include "lltextureview.h" #include "lltool.h" #include "lltoolbar.h" #include "lltoolcomp.h" #include "lltoolfocus.h" #include "lltoolgrab.h" #include "lltoolmgr.h" #include "lltoolpie.h" #include "lltoolplacer.h" #include "lltoolselectland.h" #include "llvieweruictrlfactory.h" #include "lluploaddialog.h" #include "lluserauth.h" #include "lluuid.h" #include "llvelocitybar.h" #include "llviewercamera.h" #include "llviewergenericmessage.h" #include "llviewergesture.h" #include "llviewerinventory.h" #include "llviewermenufile.h" // init_menu_file() #include "llviewermessage.h" #include "llviewernetwork.h" #include "llviewerobjectlist.h" #include "llviewerparcelmgr.h" #include "llviewerparceloverlay.h" #include "llviewerregion.h" #include "llviewerstats.h" #include "llviewerwindow.h" #include "llvoavatar.h" #include "llvolume.h" #include "llweb.h" #include "llworld.h" #include "llworldmap.h" #include "object_flags.h" #include "pipeline.h" #include "viewer.h" #include "roles_constants.h" #include "llviewerjoystick.h" #include "lltexlayer.h" void init_client_menu(LLMenuGL* menu); void init_server_menu(LLMenuGL* menu); void init_debug_world_menu(LLMenuGL* menu); void init_debug_rendering_menu(LLMenuGL* menu); void init_debug_ui_menu(LLMenuGL* menu); void init_debug_xui_menu(LLMenuGL* menu); void init_debug_avatar_menu(LLMenuGL* menu); void init_debug_baked_texture_menu(LLMenuGL* menu); BOOL enable_land_build(void*); BOOL enable_object_build(void*); LLVOAvatar* find_avatar_from_object( LLViewerObject* object ); LLVOAvatar* find_avatar_from_object( const LLUUID& object_id ); void handle_test_load_url(void*); extern void disconnect_viewer(void *); // // Evil hackish imported globals // extern BOOL gRenderLightGlows; extern BOOL gRenderAvatar; extern BOOL gHideSelectedObjects; extern BOOL gShowOverlayTitle; extern BOOL gRandomizeFramerate; extern BOOL gPeriodicSlowFrame; extern BOOL gOcclusionCull; extern BOOL gAllowSelectAvatar; // // Globals // LLMenuBarGL *gMenuBarView = NULL; LLViewerMenuHolderGL *gMenuHolder = NULL; LLMenuGL *gPopupMenuView = NULL; // Pie menus LLPieMenu *gPieSelf = NULL; LLPieMenu *gPieAvatar = NULL; LLPieMenu *gPieObject = NULL; LLPieMenu *gPieAttachment = NULL; LLPieMenu *gPieLand = NULL; // local constants const LLString CLIENT_MENU_NAME("Client"); const LLString SERVER_MENU_NAME("Server"); const LLString SAVE_INTO_INVENTORY("Save Object Back to My Inventory"); const LLString SAVE_INTO_TASK_INVENTORY("Save Object Back to Object Contents"); #if LL_WINDOWS static const char* SOUND_EXTENSIONS = ".wav"; static const char* IMAGE_EXTENSIONS = ".tga .bmp .jpg .jpeg .png"; static const char* ANIM_EXTENSIONS = ".bvh"; #ifdef _CORY_TESTING static const char* GEOMETRY_EXTENSIONS = ".slg"; #endif static const char* XML_EXTENSIONS = ".xml"; static const char* SLOBJECT_EXTENSIONS = ".slobject"; #endif static const char* ALL_FILE_EXTENSIONS = "*.*"; LLMenuGL* gAttachSubMenu = NULL; LLMenuGL* gDetachSubMenu = NULL; LLMenuGL* gTakeOffClothes = NULL; LLPieMenu* gPieRate = NULL; LLPieMenu* gAttachScreenPieMenu = NULL; LLPieMenu* gAttachPieMenu = NULL; LLPieMenu* gAttachBodyPartPieMenus[8]; LLPieMenu* gDetachPieMenu = NULL; LLPieMenu* gDetachScreenPieMenu = NULL; LLPieMenu* gDetachBodyPartPieMenus[8]; LLMenuItemCallGL* gAFKMenu = NULL; LLMenuItemCallGL* gBusyMenu = NULL; typedef LLMemberListener view_listener_t; // // Local prototypes // void handle_leave_group(void *); // File Menu const char* upload_pick(void* data); void handle_upload(void* data); //void handle_upload_object(void* data); void handle_compress_image(void*); BOOL enable_save_as(void *); // Edit menu void handle_dump_group_info(void *); void handle_dump_capabilities_info(void *); void handle_dump_focus(void*); void handle_region_dump_settings(void*); void handle_region_dump_temp_asset_data(void*); void handle_region_clear_temp_asset_data(void*); // Object pie menu BOOL sitting_on_selection(); void near_sit_object(); void label_sit_or_stand(LLString& label, void*); // buy and take alias into the same UI positions, so these // declarations handle this mess. BOOL is_selection_buy_not_take(); S32 selection_price(); BOOL enable_take(); void handle_take(); void confirm_take(S32 option, void* data); BOOL enable_buy(void*); void handle_buy(void *); void handle_buy_object(LLSaleInfo sale_info); void handle_buy_contents(LLSaleInfo sale_info); void label_touch(LLString& label, void*); // Land pie menu void near_sit_down_point(BOOL success, void *); // Avatar pie menu void handle_follow(void *userdata); void handle_talk_to(void *userdata); // Debug menu void show_permissions_control(void*); void load_url_local_file(const char* file_name); void toggle_build_options(void* user_data); #if 0 // Unused void handle_audio_status_1(void*); void handle_audio_status_2(void*); void handle_audio_status_3(void*); void handle_audio_status_4(void*); #endif void reload_ui(void*); void handle_agent_stop_moving(void*); void print_packets_lost(void*); void drop_packet(void*); void velocity_interpolate( void* data ); void update_fov(S32 increments); void toggle_wind_audio(void); void toggle_water_audio(void); void handle_rebake_textures(void*); BOOL check_admin_override(void*); void handle_admin_override_toggle(void*); #ifdef TOGGLE_HACKED_GODLIKE_VIEWER void handle_toggle_hacked_godmode(void*); BOOL check_toggle_hacked_godmode(void*); #endif void toggle_glow(void *); BOOL check_glow(void *); void toggle_vertex_shaders(void *); BOOL check_vertex_shaders(void *); void toggle_cull_small(void *); void toggle_show_xui_names(void *); BOOL check_show_xui_names(void *); // Debug UI void handle_save_to_xml(void*); void handle_load_from_xml(void*); void handle_god_mode(void*); // God menu void handle_leave_god_mode(void*); BOOL is_inventory_visible( void* user_data ); void handle_reset_view(); void disabled_duplicate(void*); void handle_duplicate_in_place(void*); void handle_repeat_duplicate(void*); void handle_export(void*); void handle_deed_object_to_group(void*); BOOL enable_deed_object_to_group(void*); void handle_object_owner_self(void*); void handle_object_owner_permissive(void*); void handle_object_lock(void*); void handle_object_asset_ids(void*); void force_take_copy(void*); #ifdef _CORY_TESTING void force_export_copy(void*); void force_import_geometry(void*); #endif void handle_force_parcel_owner_to_me(void*); void handle_force_parcel_to_content(void*); void handle_claim_public_land(void*); void handle_god_request_havok(void *); void handle_god_request_avatar_geometry(void *); // Hack for easy testing of new avatar geometry void reload_personal_settings_overrides(void *); void force_breakpoint(void *); void reload_vertex_shader(void *); void slow_mo_animations(void *); void handle_disconnect_viewer(void *); void handle_stopall(void*); //void handle_hinge(void*); //void handle_ptop(void*); //void handle_lptop(void*); //void handle_wheel(void*); //void handle_dehinge(void*); BOOL enable_dehinge(void*); void handle_force_delete(void*); void print_object_info(void*); void show_debug_menus(); void toggle_debug_menus(void*); void toggle_map( void* user_data ); void export_info_callback(LLAssetInfo *info, void **user_data, S32 result); void export_data_callback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type, void **user_data, S32 result); void upload_done_callback(const LLUUID& uuid, void* user_data, S32 result, LLExtStat ext_status); BOOL menu_check_build_tool( void* user_data ); void handle_reload_settings(void*); void focus_here(void*); void dump_select_mgr(void*); void dump_volume_mgr(void*); void dump_inventory(void*); void edit_ui(void*); void toggle_visibility(void*); BOOL get_visibility(void*); // Avatar Pie menu void request_friendship(const LLUUID& agent_id); // Tools menu void handle_force_unlock(void*); void handle_selected_texture_info(void*); void handle_dump_image_list(void*); void handle_fullscreen_debug(void*); void handle_crash(void*); void handle_dump_followcam(void*); void handle_toggle_flycam(void*); BOOL check_flycam(void*); void handle_viewer_enable_message_log(void*); void handle_viewer_disable_message_log(void*); void handle_send_postcard(void*); void handle_gestures_old(void*); void handle_focus(void *); BOOL enable_buy_land(void*); void handle_move(void*); void handle_show_inventory(void*); void handle_activate(void*); BOOL enable_activate(void*); // Help menu void handle_buy_currency(void*); void handle_test_male(void *); void handle_test_female(void *); void handle_toggle_pg(void*); void handle_dump_attachments(void *); void handle_show_overlay_title(void*); void handle_dump_avatar_local_textures(void*); void handle_debug_avatar_textures(void*); void handle_grab_texture(void*); BOOL enable_grab_texture(void*); void handle_dump_region_object_cache(void*); BOOL menu_ui_enabled(void *user_data); void check_toggle_control( LLUICtrl *, void* user_data ); BOOL menu_check_control( void* user_data); void menu_toggle_variable( void* user_data ); BOOL menu_check_variable( void* user_data); BOOL enable_land_selected( void* ); BOOL enable_more_than_one_selected(void* ); BOOL enable_selection_you_own_all(void*); BOOL enable_selection_you_own_one(void*); BOOL enable_save_into_inventory(void*); BOOL enable_save_into_task_inventory(void*); BOOL enable_not_thirdperson(void*); BOOL enable_export_selected(void *); BOOL enable_have_card(void*); BOOL enable_detach(void*); BOOL enable_region_owner(void*); class LLMenuParcelObserver : public LLParcelObserver { public: LLMenuParcelObserver(); ~LLMenuParcelObserver(); virtual void changed(); }; static LLMenuParcelObserver* gMenuParcelObserver = NULL; LLMenuParcelObserver::LLMenuParcelObserver() { gParcelMgr->addObserver(this); } LLMenuParcelObserver::~LLMenuParcelObserver() { gParcelMgr->removeObserver(this); } void LLMenuParcelObserver::changed() { gMenuHolder->childSetEnabled("Land Buy Pass", LLPanelLandGeneral::enableBuyPass(NULL)); BOOL buyable = enable_buy_land(NULL); gMenuHolder->childSetEnabled("Land Buy", buyable); gMenuHolder->childSetEnabled("Buy Land...", buyable); } //----------------------------------------------------------------------------- // Menu Construction //----------------------------------------------------------------------------- // code required to calculate anything about the menus void pre_init_menus() { // static information LLColor4 color; color = gColors.getColor( "MenuDefaultBgColor" ); LLMenuGL::setDefaultBackgroundColor( color ); color = gColors.getColor( "MenuItemEnabledColor" ); LLMenuItemGL::setEnabledColor( color ); color = gColors.getColor( "MenuItemDisabledColor" ); LLMenuItemGL::setDisabledColor( color ); color = gColors.getColor( "MenuItemHighlightBgColor" ); LLMenuItemGL::setHighlightBGColor( color ); color = gColors.getColor( "MenuItemHighlightFgColor" ); LLMenuItemGL::setHighlightFGColor( color ); } void initialize_menus(); //----------------------------------------------------------------------------- // Initialize main menus // // HOW TO NAME MENUS: // // First Letter Of Each Word Is Capitalized, Even At Or And // // Items that lead to dialog boxes end in "..." // // Break up groups of more than 6 items with separators //----------------------------------------------------------------------------- void init_menus() { S32 top = gViewerWindow->getRootView()->getRect().getHeight(); S32 width = gViewerWindow->getRootView()->getRect().getWidth(); // // Main menu bar // gMenuHolder = new LLViewerMenuHolderGL(); gMenuHolder->setRect(LLRect(0, top, width, 0)); gMenuHolder->setFollowsAll(); LLMenuGL::sMenuContainer = gMenuHolder; // Initialize actions initialize_menus(); /// /// Popup menu /// /// The popup menu is now populated by the show_context_menu() /// method. gPopupMenuView = new LLMenuGL( "Popup" ); gPopupMenuView->setVisible( FALSE ); gMenuHolder->addChild( gPopupMenuView ); /// /// Pie menus /// gPieSelf = gUICtrlFactory->buildPieMenu("menu_pie_self.xml", gMenuHolder); // TomY TODO: what shall we do about these? gDetachScreenPieMenu = (LLPieMenu*)gMenuHolder->getChildByName("Object Detach HUD", true); gDetachPieMenu = (LLPieMenu*)gMenuHolder->getChildByName("Object Detach", true); if (gAgent.mAccess < SIM_ACCESS_MATURE) { gMenuHolder->getChildByName("Self Underpants", TRUE)->setVisible(FALSE); gMenuHolder->getChildByName("Self Undershirt", TRUE)->setVisible(FALSE); } gPieAvatar = gUICtrlFactory->buildPieMenu("menu_pie_avatar.xml", gMenuHolder); gPieObject = gUICtrlFactory->buildPieMenu("menu_pie_object.xml", gMenuHolder); gAttachScreenPieMenu = (LLPieMenu*)gMenuHolder->getChildByName("Object Attach HUD", true); gAttachPieMenu = (LLPieMenu*)gMenuHolder->getChildByName("Object Attach", true); gPieRate = (LLPieMenu*)gMenuHolder->getChildByName("Rate Menu", true); gPieAttachment = gUICtrlFactory->buildPieMenu("menu_pie_attachment.xml", gMenuHolder); gPieLand = gUICtrlFactory->buildPieMenu("menu_pie_land.xml", gMenuHolder); /// /// set up the colors /// LLColor4 color; LLColor4 pie_color = gColors.getColor("PieMenuBgColor"); gPieSelf->setBackgroundColor( pie_color ); gPieAvatar->setBackgroundColor( pie_color ); gPieObject->setBackgroundColor( pie_color ); gPieAttachment->setBackgroundColor( pie_color ); gPieLand->setBackgroundColor( pie_color ); color = gColors.getColor( "MenuPopupBgColor" ); gPopupMenuView->setBackgroundColor( color ); // If we are not in production, use a different color to make it apparent. if (gInProductionGrid) { color = gColors.getColor( "MenuBarBgColor" ); } else { color = gColors.getColor( "MenuNonProductionBgColor" ); } gMenuBarView = (LLMenuBarGL*)gUICtrlFactory->buildMenu("menu_viewer.xml", gMenuHolder); gMenuBarView->setRect(LLRect(0, top, 0, top - MENU_BAR_HEIGHT)); gMenuBarView->setBackgroundColor( color ); gMenuHolder->addChild(gMenuBarView); // menu holder appears on top of menu bar so you can see the menu title // flash when an item is triggered (the flash occurs in the holder) gViewerWindow->getRootView()->addChild(gMenuHolder); gMenuHolder->childSetLabelArg("Upload Image", "[COST]", "10"); gMenuHolder->childSetLabelArg("Upload Sound", "[COST]", "10"); gMenuHolder->childSetLabelArg("Upload Animation", "[COST]", "10"); gMenuHolder->childSetLabelArg("Bulk Upload", "[COST]", "10"); gAFKMenu = (LLMenuItemCallGL*)gMenuBarView->getChildByName("Set Away", TRUE); gBusyMenu = (LLMenuItemCallGL*)gMenuBarView->getChildByName("Set Busy", TRUE); gAttachSubMenu = gMenuBarView->getChildMenuByName("Attach Object", TRUE); gDetachSubMenu = gMenuBarView->getChildMenuByName("Detach Object", TRUE); if (gAgent.mAccess < SIM_ACCESS_MATURE) { gMenuBarView->getChildByName("Menu Underpants", TRUE)->setVisible(FALSE); gMenuBarView->getChildByName("Menu Undershirt", TRUE)->setVisible(FALSE); } // TomY TODO convert these two LLMenuGL*menu; 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); gMenuBarView->appendMenu( menu ); menu->updateParent(LLMenuGL::sMenuContainer); gMenuBarView->createJumpKeys(); // Let land based option enable when parcel changes gMenuParcelObserver = new LLMenuParcelObserver(); // // Debug menu visiblity // show_debug_menus(); } void init_client_menu(LLMenuGL* menu) { LLMenuGL* sub_menu = NULL; //menu->append(new LLMenuItemCallGL("Permissions Control", &show_permissions_control)); // this is now in the view menu so we don't need it here! { LLMenuGL* sub = new LLMenuGL("Consoles"); menu->appendMenu(sub); sub->append(new LLMenuItemCheckGL("Frame Console", &toggle_visibility, NULL, &get_visibility, (void*)gDebugView->mFrameStatView, '2', MASK_CONTROL|MASK_SHIFT ) ); sub->append(new LLMenuItemCheckGL("Texture Console", &toggle_visibility, NULL, &get_visibility, (void*)gTextureView, '3', MASK_CONTROL|MASK_SHIFT ) ); LLView* debugview = gDebugView->mDebugConsolep; sub->append(new LLMenuItemCheckGL("Debug Console", &toggle_visibility, NULL, &get_visibility, debugview, '4', MASK_CONTROL|MASK_SHIFT ) ); #if 0 // Unused { LLMenuGL* sub = new LLMenuGL("Audio"); menu->appendMenu(sub); sub->append(new LLMenuItemCallGL("Global Pos", &handle_audio_status_1, NULL, NULL ,'5', MASK_CONTROL|MASK_SHIFT) ); sub->append(new LLMenuItemCallGL("Cone", &handle_audio_status_2, NULL, NULL ,'6', MASK_CONTROL|MASK_SHIFT) ); sub->append(new LLMenuItemCallGL("Local Pos", &handle_audio_status_3, NULL, NULL ,'7', MASK_CONTROL|MASK_SHIFT) ); sub->append(new LLMenuItemCallGL("Duration", &handle_audio_status_4, NULL, NULL ,'8', MASK_CONTROL|MASK_SHIFT) ); sub->createJumpKeys(); } #endif sub->append(new LLMenuItemCheckGL("Fast Timers", &toggle_visibility, NULL, &get_visibility, (void*)gDebugView->mFastTimerView, '9', MASK_CONTROL|MASK_SHIFT ) ); sub->append(new LLMenuItemCheckGL("Memory", &toggle_visibility, NULL, &get_visibility, (void*)gDebugView->mMemoryView, '0', MASK_CONTROL|MASK_SHIFT ) ); sub->appendSeparator(); sub->append(new LLMenuItemCallGL("Region Info to Debug Console", &handle_region_dump_settings, NULL)); sub->append(new LLMenuItemCallGL("Group Info to Debug Console", &handle_dump_group_info, NULL, NULL)); sub->append(new LLMenuItemCallGL("Capabilities Info to Debug Console", &handle_dump_capabilities_info, NULL, NULL)); sub->createJumpKeys(); } // neither of these works particularly well at the moment /*menu->append(new LLMenuItemCallGL( "Reload UI XML", &reload_ui, NULL, NULL) );*/ /*menu->append(new LLMenuItemCallGL("Reload settings/colors", &handle_reload_settings, NULL, NULL));*/ menu->append(new LLMenuItemCallGL("Reload personal setting overrides", &reload_personal_settings_overrides, NULL, NULL, KEY_F2, MASK_CONTROL|MASK_SHIFT)); sub_menu = new LLMenuGL("HUD Info"); { sub_menu->append(new LLMenuItemCheckGL("Velocity", &toggle_visibility, NULL, &get_visibility, (void*)gVelocityBar)); sub_menu->append(new LLMenuItemToggleGL("Camera", &gDisplayCameraPos ) ); sub_menu->append(new LLMenuItemToggleGL("Wind", &gDisplayWindInfo) ); sub_menu->append(new LLMenuItemToggleGL("FOV", &gDisplayFOV ) ); sub_menu->createJumpKeys(); } menu->appendMenu(sub_menu); menu->appendSeparator(); menu->append(new LLMenuItemCheckGL( "High-res Snapshot", &menu_toggle_control, NULL, &menu_check_control, (void*)"HighResSnapshot")); menu->append(new LLMenuItemToggleGL("Quiet Snapshots to Disk", &gQuietSnapshot)); menu->append(new LLMenuItemCheckGL( "Compress Snapshots to Disk", &menu_toggle_control, NULL, &menu_check_control, (void*)"CompressSnapshotsToDisk")); menu->append(new LLMenuItemCheckGL("Show Mouselook Crosshairs", &menu_toggle_control, NULL, &menu_check_control, (void*)"ShowCrosshairs")); menu->append(new LLMenuItemCheckGL("Debug Permissions", &menu_toggle_control, NULL, &menu_check_control, (void*)"DebugPermissions")); #ifdef TOGGLE_HACKED_GODLIKE_VIEWER if (!gInProductionGrid) { menu->append(new LLMenuItemCheckGL("Hacked Godmode", &handle_toggle_hacked_godmode, NULL, &check_toggle_hacked_godmode, (void*)"HackedGodmode")); } #endif menu->append(new LLMenuItemCallGL("Clear Group Cache", LLGroupMgr::debugClearAllGroups)); menu->appendSeparator(); sub_menu = new LLMenuGL("Rendering"); init_debug_rendering_menu(sub_menu); menu->appendMenu(sub_menu); sub_menu = new LLMenuGL("World"); init_debug_world_menu(sub_menu); menu->appendMenu(sub_menu); sub_menu = new LLMenuGL("UI"); init_debug_ui_menu(sub_menu); menu->appendMenu(sub_menu); sub_menu = new LLMenuGL("XUI"); init_debug_xui_menu(sub_menu); menu->appendMenu(sub_menu); sub_menu = new LLMenuGL("Character"); init_debug_avatar_menu(sub_menu); menu->appendMenu(sub_menu); { LLMenuGL* sub = NULL; sub = new LLMenuGL("Network"); sub->append(new LLMenuItemCallGL("Enable Message Log", &handle_viewer_enable_message_log, NULL)); sub->append(new LLMenuItemCallGL("Disable Message Log", &handle_viewer_disable_message_log, NULL)); sub->appendSeparator(); sub->append(new LLMenuItemCheckGL("Velocity Interpolate Objects", &velocity_interpolate, NULL, &menu_check_control, (void*)"VelocityInterpolate")); sub->append(new LLMenuItemCheckGL("Ping Interpolate Object Positions", &menu_toggle_control, NULL, &menu_check_control, (void*)"PingInterpolate")); sub->appendSeparator(); sub->append(new LLMenuItemCallGL("Drop a Packet", &drop_packet, NULL, NULL, 'L', MASK_ALT | MASK_CONTROL)); menu->appendMenu( sub ); sub->createJumpKeys(); } { LLMenuGL* sub = NULL; sub = new LLMenuGL("Recorder"); sub->append(new LLMenuItemCheckGL("Full Session Logging", &menu_toggle_control, NULL, &menu_check_control, (void*)"StatsSessionTrackFrameStats")); sub->append(new LLMenuItemCallGL("Start Logging", &LLFrameStats::startLogging, NULL)); sub->append(new LLMenuItemCallGL("Stop Logging", &LLFrameStats::stopLogging, NULL)); sub->append(new LLMenuItemCallGL("Log 10 Seconds", &LLFrameStats::timedLogging10, NULL)); sub->append(new LLMenuItemCallGL("Log 30 Seconds", &LLFrameStats::timedLogging30, NULL)); sub->append(new LLMenuItemCallGL("Log 60 Seconds", &LLFrameStats::timedLogging60, NULL)); sub->appendSeparator(); sub->append(new LLMenuItemCallGL("Start Playback", &LLAgentPilot::startPlayback, NULL)); sub->append(new LLMenuItemCallGL("Stop Playback", &LLAgentPilot::stopPlayback, NULL)); sub->append(new LLMenuItemToggleGL("Loop Playback", &LLAgentPilot::sLoop) ); sub->append(new LLMenuItemCallGL("Start Record", &LLAgentPilot::startRecord, NULL)); sub->append(new LLMenuItemCallGL("Stop Record", &LLAgentPilot::saveRecord, NULL)); menu->appendMenu( sub ); sub->createJumpKeys(); } menu->appendSeparator(); menu->append(new LLMenuItemToggleGL("Show Updates", &gShowObjectUpdates, 'U', MASK_ALT | MASK_SHIFT | MASK_CONTROL)); menu->appendSeparator(); menu->append(new LLMenuItemCallGL("Compress Image...", &handle_compress_image, NULL, NULL)); menu->append(new LLMenuItemCheckGL("Limit Select Distance", &menu_toggle_control, NULL, &menu_check_control, (void*)"LimitSelectDistance")); menu->append(new LLMenuItemToggleGL("Disable Camera Constraints", &LLViewerCamera::sDisableCameraConstraints, 'C', MASK_ALT | MASK_CONTROL )); menu->append(new LLMenuItemCheckGL("Joystick Flycam", &handle_toggle_flycam,NULL,&check_flycam,NULL)); menu->append(new LLMenuItemCheckGL("Mouse Smoothing", &menu_toggle_control, NULL, &menu_check_control, (void*) "MouseSmooth")); menu->appendSeparator(); menu->append(new LLMenuItemCheckGL( "Console Window", &menu_toggle_control, NULL, &menu_check_control, (void*)"ShowConsoleWindow")); #ifndef LL_RELEASE_FOR_DOWNLOAD { LLMenuGL* sub = NULL; sub = new LLMenuGL("Debugging"); sub->append(new LLMenuItemCallGL("Force Breakpoint", &force_breakpoint, NULL, NULL, 'B', MASK_CONTROL | MASK_ALT)); sub->append(new LLMenuItemCallGL("LLError And Crash", &handle_crash)); sub->createJumpKeys(); menu->appendMenu(sub); } #endif // TomY Temporary menu item so we can test this floater menu->append(new LLMenuItemCheckGL("Clothing...", &handle_clothing, NULL, NULL, NULL)); menu->append(new LLMenuItemCallGL("Debug Settings", LLFloaterSettingsDebug::show, NULL, NULL)); menu->append(new LLMenuItemCheckGL("View Admin Options", &handle_admin_override_toggle, NULL, &check_admin_override, NULL, 'V', MASK_CONTROL | MASK_ALT)); menu->createJumpKeys(); } void init_debug_world_menu(LLMenuGL* menu) { menu->append(new LLMenuItemCheckGL("Mouse Moves Sun", &menu_toggle_control, NULL, &menu_check_control, (void*)"MouseSun", 'M', MASK_CONTROL|MASK_ALT)); menu->append(new LLMenuItemCheckGL("Sim Sun Override", &menu_toggle_control, NULL, &menu_check_control, (void*)"SkyOverrideSimSunPosition")); menu->append(new LLMenuItemCallGL("Dump Scripted Camera", &handle_dump_followcam, NULL, NULL)); menu->append(new LLMenuItemCheckGL("Fixed Weather", &menu_toggle_control, NULL, &menu_check_control, (void*)"FixedWeather")); menu->append(new LLMenuItemCallGL("Dump Region Object Cache", &handle_dump_region_object_cache, NULL, NULL)); menu->createJumpKeys(); } void handle_export_menus_to_xml(void*) { LLFilePicker& picker = LLFilePicker::instance(); if(!picker.getSaveFile(LLFilePicker::FFSAVE_XML)) { llwarns << "No file" << llendl; return; } const char* filename = picker.getFirstFile(); llofstream out(filename); LLXMLNodePtr node = gMenuBarView->getXML(); node->writeToOstream(out); out.close(); } extern BOOL gDebugClicks; extern BOOL gDebugWindowProc; extern BOOL gDebugTextEditorTips; extern BOOL gDebugSelectMgr; extern BOOL gVectorizePerfTest; void init_debug_ui_menu(LLMenuGL* menu) { menu->append(new LLMenuItemCallGL("Editable UI", &edit_ui)); menu->append(new LLMenuItemToggleGL("Async Keystrokes", &gHandleKeysAsync)); menu->append(new LLMenuItemCallGL( "Dump SelectMgr", &dump_select_mgr)); menu->append(new LLMenuItemCallGL( "Dump Inventory", &dump_inventory)); menu->append(new LLMenuItemCallGL( "Dump Focus Holder", &handle_dump_focus, NULL, NULL, 'F', MASK_ALT | MASK_CONTROL)); menu->append(new LLMenuItemCallGL( "Dump VolumeMgr", &dump_volume_mgr, NULL, NULL)); menu->append(new LLMenuItemCallGL( "Print Selected Object Info", &print_object_info, NULL, NULL, 'P', MASK_CONTROL|MASK_SHIFT )); menu->append(new LLMenuItemCallGL( "Print Agent Info", &print_agent_nvpairs, NULL, NULL, 'P', MASK_SHIFT )); menu->append(new LLMenuItemCallGL( "Print Texture Memory Stats", &output_statistics, NULL, NULL, 'M', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); menu->append(new LLMenuItemCheckGL("Double-Click Auto-Pilot", menu_toggle_control, NULL, menu_check_control, (void*)"DoubleClickAutoPilot")); menu->appendSeparator(); // menu->append(new LLMenuItemCallGL( "Print Packets Lost", &print_packets_lost, NULL, NULL, 'L', MASK_SHIFT )); menu->append(new LLMenuItemToggleGL("Debug SelectMgr", &gDebugSelectMgr)); menu->append(new LLMenuItemToggleGL("Debug Clicks", &gDebugClicks)); menu->append(new LLMenuItemToggleGL("Debug Views", &LLView::sDebugRects)); menu->append(new LLMenuItemCheckGL("Show Name Tooltips", toggle_show_xui_names, NULL, check_show_xui_names, NULL)); menu->append(new LLMenuItemToggleGL("Debug Mouse Events", &LLView::sDebugMouseHandling)); menu->append(new LLMenuItemToggleGL("Debug Keys", &LLView::sDebugKeys)); menu->append(new LLMenuItemToggleGL("Debug WindowProc", &gDebugWindowProc)); menu->append(new LLMenuItemToggleGL("Debug Text Editor Tips", &gDebugTextEditorTips)); menu->appendSeparator(); menu->append(new LLMenuItemCheckGL("Show Time", menu_toggle_control, NULL, menu_check_control, (void*)"DebugShowTime")); menu->append(new LLMenuItemCheckGL("Show Render Info", menu_toggle_control, NULL, menu_check_control, (void*)"DebugShowRenderInfo")); menu->createJumpKeys(); } void init_debug_xui_menu(LLMenuGL* menu) { menu->append(new LLMenuItemCallGL("Floater Test...", LLFloaterTest::show)); menu->append(new LLMenuItemCallGL("Export Menus to XML...", handle_export_menus_to_xml)); menu->append(new LLMenuItemCallGL("Edit UI...", LLFloaterEditUI::show)); menu->append(new LLMenuItemCallGL("Load from XML...", handle_load_from_xml)); menu->append(new LLMenuItemCallGL("Save to XML...", handle_save_to_xml)); menu->append(new LLMenuItemCheckGL("Show XUI Names", toggle_show_xui_names, NULL, check_show_xui_names, NULL)); //menu->append(new LLMenuItemCallGL("Buy Currency...", handle_buy_currency)); menu->createJumpKeys(); } void init_debug_rendering_menu(LLMenuGL* menu) { LLMenuGL* sub_menu = NULL; /////////////////////////// // // Debug menu for types/pools // sub_menu = new LLMenuGL("Types"); menu->appendMenu(sub_menu); sub_menu->append(new LLMenuItemCheckGL("Simple", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_SIMPLE, '1', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Alpha", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_ALPHA, '2', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Tree", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_TREE, '3', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Character", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_AVATAR, '4', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("SurfacePatch", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_TERRAIN, '5', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Sky", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_SKY, '6', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Water", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_WATER, '7', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Ground", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_GROUND, '8', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Volume", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_VOLUME, '9', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Grass", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_GRASS, '0', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Clouds", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_CLOUDS, '-', MASK_CONTROL|MASK_ALT| MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Particles", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_PARTICLES, '=', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->append(new LLMenuItemCheckGL("Bump", &LLPipeline::toggleRenderTypeControl, NULL, &LLPipeline::hasRenderTypeControl, (void*)LLPipeline::RENDER_TYPE_BUMP, '\\', MASK_CONTROL|MASK_ALT|MASK_SHIFT)); sub_menu->createJumpKeys(); sub_menu = new LLMenuGL("Features"); menu->appendMenu(sub_menu); sub_menu->append(new LLMenuItemCheckGL("UI", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_UI, KEY_F1, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Selected", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_SELECTED, KEY_F2, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Highlighted", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_HIGHLIGHTED, KEY_F3, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Dynamic Textures", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_DYNAMIC_TEXTURES, KEY_F4, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL( "Foot Shadows", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_FOOT_SHADOWS, KEY_F5, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Fog", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_FOG, KEY_F6, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Palletized Textures", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_PALETTE, KEY_F7, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL("Test FRInfo", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_FR_INFO, KEY_F8, MASK_ALT|MASK_CONTROL)); sub_menu->append(new LLMenuItemCheckGL( "Flexible Objects", &LLPipeline::toggleRenderDebugFeature, NULL, &LLPipeline::toggleRenderDebugFeatureControl, (void*)LLPipeline::RENDER_DEBUG_FEATURE_FLEXIBLE, KEY_F9, MASK_ALT|MASK_CONTROL)); sub_menu->createJumpKeys(); ///////////////////////////// // // Debug menu for info displays // sub_menu = new LLMenuGL("Info Displays"); menu->appendMenu(sub_menu); sub_menu->append(new LLMenuItemCheckGL("Verify", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_VERIFY)); sub_menu->append(new LLMenuItemCheckGL("BBoxes", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_BBOXES)); sub_menu->append(new LLMenuItemCheckGL("Points", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_POINTS)); sub_menu->append(new LLMenuItemCheckGL("Octree", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_OCTREE)); sub_menu->append(new LLMenuItemCheckGL("Occlusion", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_OCCLUSION)); sub_menu->append(new LLMenuItemCheckGL("Animated Textures", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_TEXTURE_ANIM)); sub_menu->append(new LLMenuItemCheckGL("Texture Priority", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY)); sub_menu->append(new LLMenuItemCheckGL("Texture Area (sqrt(A))",&LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_TEXTURE_AREA)); sub_menu->append(new LLMenuItemCheckGL("Face Area (sqrt(A))",&LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_FACE_AREA)); sub_menu->append(new LLMenuItemCheckGL("Pick Render", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_PICKING)); sub_menu->append(new LLMenuItemCheckGL("Particles", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_PARTICLES)); sub_menu->append(new LLMenuItemCheckGL("Composition", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_COMPOSITION)); sub_menu->append(new LLMenuItemCheckGL("ShadowMap", &LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_SHADOW_MAP)); sub_menu->append(new LLMenuItemCheckGL("LightTrace",&LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_LIGHT_TRACE)); sub_menu->append(new LLMenuItemCheckGL("Glow",&LLPipeline::toggleRenderDebug, NULL, &LLPipeline::toggleRenderDebugControl, (void*)LLPipeline::RENDER_DEBUG_GLOW)); sub_menu->append(new LLMenuItemCheckGL("Show Depth Buffer", &menu_toggle_control, NULL, &menu_check_control, (void*)"ShowDepthBuffer")); sub_menu->append(new LLMenuItemToggleGL("Show Select Buffer", &gDebugSelect)); sub_menu->append(new LLMenuItemToggleGL("Vectorize Perf Test", &gVectorizePerfTest)); sub_menu = new LLMenuGL("Render Tests"); sub_menu->append(new LLMenuItemCheckGL("Camera Offset", &menu_toggle_control, NULL, &menu_check_control, (void*)"CameraOffset")); sub_menu->append(new LLMenuItemToggleGL("Randomize Framerate", &gRandomizeFramerate)); sub_menu->append(new LLMenuItemToggleGL("Periodic Slow Frame", &gPeriodicSlowFrame)); sub_menu->createJumpKeys(); menu->appendMenu( sub_menu ); menu->appendSeparator(); menu->append(new LLMenuItemCheckGL("Axes", menu_toggle_control, NULL, menu_check_control, (void*)"ShowAxes")); // menu->append(new LLMenuItemCheckGL("Cull Small Objects", toggle_cull_small, NULL, menu_check_control, (void*)"RenderCullBySize")); menu->appendSeparator(); menu->append(new LLMenuItemToggleGL("Hide Selected", &gHideSelectedObjects)); menu->appendSeparator(); menu->append(new LLMenuItemCheckGL("Tangent Basis", menu_toggle_control, NULL, menu_check_control, (void*)"ShowTangentBasis")); menu->append(new LLMenuItemCallGL("Selected Texture Info", handle_selected_texture_info, NULL, NULL, 'T', MASK_CONTROL|MASK_SHIFT|MASK_ALT)); //menu->append(new LLMenuItemCallGL("Dump Image List", handle_dump_image_list, NULL, NULL, 'I', MASK_CONTROL|MASK_SHIFT)); menu->append(new LLMenuItemToggleGL("Wireframe", &gUseWireframe, 'R', MASK_CONTROL|MASK_SHIFT)); LLMenuItemCheckGL* item; item = new LLMenuItemCheckGL("Object-Object Occlusion", menu_toggle_control, NULL, menu_check_control, (void*)"UseOcclusion", 'O', MASK_CONTROL|MASK_SHIFT); item->setEnabled(gGLManager.mHasOcclusionQuery && gFeatureManagerp->isFeatureAvailable("UseOcclusion")); menu->append(item); item = new LLMenuItemCheckGL("Animate Textures", menu_toggle_control, NULL, menu_check_control, (void*)"AnimateTextures"); menu->append(item); item = new LLMenuItemCheckGL("Disable Textures", menu_toggle_variable, NULL, menu_check_variable, (void*)&LLViewerImage::sDontLoadVolumeTextures); menu->append(item); #ifndef LL_RELEASE_FOR_DOWNLOAD item = new LLMenuItemCheckGL("HTTP Get Textures", menu_toggle_control, NULL, menu_check_control, (void*)"ImagePipelineUseHTTP"); menu->append(item); #endif item = new LLMenuItemCheckGL("Run Multiple Threads", menu_toggle_control, NULL, menu_check_control, (void*)"RunMultipleThreads"); menu->append(item); #ifndef LL_RELEASE_FOR_DOWNLOAD item = new LLMenuItemCheckGL("Dynamic Reflections", menu_toggle_control, NULL, menu_check_control, (void*)"RenderDynamicReflections"); menu->append(item); #endif item = new LLMenuItemCheckGL("Cheesy Beacon", menu_toggle_control, NULL, menu_check_control, (void*)"CheesyBeacon"); menu->append(item); menu->createJumpKeys(); } extern BOOL gDebugAvatarRotation; void init_debug_avatar_menu(LLMenuGL* menu) { LLMenuGL* sub_menu = new LLMenuGL("Grab Baked Texture"); init_debug_baked_texture_menu(sub_menu); menu->appendMenu(sub_menu); sub_menu = new LLMenuGL("Character Tests"); sub_menu->append(new LLMenuItemToggleGL("Go Away/AFK When Idle", &gAllowIdleAFK)); sub_menu->append(new LLMenuItemCallGL("Appearance To XML", &LLVOAvatar::dumpArchetypeXML)); // HACK for easy testing of avatar geometry sub_menu->append(new LLMenuItemCallGL( "Toggle Character Geometry", &handle_god_request_avatar_geometry, &enable_god_customer_service, NULL)); sub_menu->append(new LLMenuItemCallGL("Test Male", handle_test_male)); sub_menu->append(new LLMenuItemCallGL("Test Female", handle_test_female)); sub_menu->append(new LLMenuItemCallGL("Toggle PG", handle_toggle_pg)); sub_menu->append(new LLMenuItemToggleGL("Allow Select Avatar", &gAllowSelectAvatar)); sub_menu->createJumpKeys(); menu->appendMenu(sub_menu); menu->append(new LLMenuItemCallGL("Force Params to Default", &LLAgent::clearVisualParams, NULL)); menu->append(new LLMenuItemCallGL("Reload Vertex Shader", &reload_vertex_shader, NULL)); menu->append(new LLMenuItemToggleGL("Animation Info", &LLVOAvatar::sShowAnimationDebug)); menu->append(new LLMenuItemCallGL("Slow Motion Animations", &slow_mo_animations, NULL)); menu->append(new LLMenuItemToggleGL("Show Look At", &LLHUDEffectLookAt::sDebugLookAt)); menu->append(new LLMenuItemToggleGL("Show Point At", &LLHUDEffectPointAt::sDebugPointAt)); menu->append(new LLMenuItemToggleGL("Debug Joint Updates", &LLVOAvatar::sJointDebug)); menu->append(new LLMenuItemToggleGL("Disable LOD", &LLViewerJoint::sDisableLOD)); menu->append(new LLMenuItemToggleGL("Debug Character Vis", &LLVOAvatar::sDebugInvisible)); //menu->append(new LLMenuItemToggleGL("Show Attachment Points", &LLVOAvatar::sShowAttachmentPoints)); menu->append(new LLMenuItemToggleGL("Show Collision Plane", &LLVOAvatar::sShowFootPlane)); menu->append(new LLMenuItemToggleGL("Show Collision Skeleton", &LLVOAvatar::sShowCollisionVolumes)); menu->append(new LLMenuItemToggleGL( "Display Agent Target", &LLAgent::sDebugDisplayTarget)); menu->append(new LLMenuItemToggleGL( "Debug Rotation", &gDebugAvatarRotation)); menu->append(new LLMenuItemCallGL("Dump Attachments", handle_dump_attachments)); menu->append(new LLMenuItemCallGL("Rebake Textures", handle_rebake_textures, NULL, NULL, 'R', MASK_ALT | MASK_CONTROL )); #ifndef LL_RELEASE_FOR_DOWNLOAD menu->append(new LLMenuItemCallGL("Debug Avatar Textures", handle_debug_avatar_textures, NULL, NULL, 'A', MASK_SHIFT|MASK_CONTROL|MASK_ALT)); menu->append(new LLMenuItemCallGL("Dump Local Textures", handle_dump_avatar_local_textures, NULL, NULL, 'M', MASK_SHIFT|MASK_ALT )); #endif menu->createJumpKeys(); } void init_debug_baked_texture_menu(LLMenuGL* menu) { menu->append(new LLMenuItemCallGL("Iris", handle_grab_texture, enable_grab_texture, (void*) LLVOAvatar::TEX_EYES_BAKED)); menu->append(new LLMenuItemCallGL("Head", handle_grab_texture, enable_grab_texture, (void*) LLVOAvatar::TEX_HEAD_BAKED)); menu->append(new LLMenuItemCallGL("Upper Body", handle_grab_texture, enable_grab_texture, (void*) LLVOAvatar::TEX_UPPER_BAKED)); menu->append(new LLMenuItemCallGL("Lower Body", handle_grab_texture, enable_grab_texture, (void*) LLVOAvatar::TEX_LOWER_BAKED)); menu->append(new LLMenuItemCallGL("Skirt", handle_grab_texture, enable_grab_texture, (void*) LLVOAvatar::TEX_SKIRT_BAKED)); menu->createJumpKeys(); } void init_server_menu(LLMenuGL* menu) { /* { // These messages are now trusted. We can write scripts to do // this, and the message is unchecked for source. LLMenuGL* sub_menu = NULL; sub_menu = new LLMenuGL("Sim Logging"); sub_menu->append(new LLMenuItemCallGL("Turn off llinfos Log", &handle_reduce_llinfo_log, &enable_god_customer_service)); sub_menu->append(new LLMenuItemCallGL("Normal Logging", &handle_normal_llinfo_log, &enable_god_customer_service)); sub_menu->appendSeparator(); sub_menu->append(new LLMenuItemCallGL("Enable Message Log", &handle_sim_enable_message_log, &enable_god_customer_service)); sub_menu->append(new LLMenuItemCallGL("Disable Message Log", &handle_sim_disable_message_log, &enable_god_customer_service)); sub_menu->appendSeparator(); sub_menu->append(new LLMenuItemCallGL("Fetch Message Log", &handle_sim_fetch_message_log, &enable_god_customer_service)); sub_menu->append(new LLMenuItemCallGL("Fetch Log", &handle_sim_fetch_log, &enable_god_customer_service)); menu->appendMenu( sub_menu ); } */ { LLMenuGL* sub = new LLMenuGL("Object"); menu->appendMenu(sub); sub->append(new LLMenuItemCallGL( "Take Copy", &force_take_copy, &enable_god_customer_service, NULL, 'O', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); #ifdef _CORY_TESTING sub->append(new LLMenuItemCallGL( "Export Copy", &force_export_copy, NULL, NULL)); sub->append(new LLMenuItemCallGL( "Import Geometry", &force_import_geometry, NULL, NULL)); #endif //sub->append(new LLMenuItemCallGL( "Force Public", // &handle_object_owner_none, NULL, NULL)); //sub->append(new LLMenuItemCallGL( "Force Ownership/Permissive", // &handle_object_owner_self_and_permissive, NULL, NULL, 'K', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); sub->append(new LLMenuItemCallGL( "Force Owner To Me", &handle_object_owner_self, &enable_god_customer_service)); sub->append(new LLMenuItemCallGL( "Force Owner Permissive", &handle_object_owner_permissive, &enable_god_customer_service)); //sub->append(new LLMenuItemCallGL( "Force Totally Permissive", // &handle_object_permissive)); sub->append(new LLMenuItemCallGL( "Delete", &handle_force_delete, &enable_god_customer_service, NULL, KEY_DELETE, MASK_SHIFT | MASK_ALT | MASK_CONTROL)); sub->append(new LLMenuItemCallGL( "Lock", &handle_object_lock, &enable_god_customer_service, NULL, 'L', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); sub->append(new LLMenuItemCallGL( "Get Asset IDs", &handle_object_asset_ids, &enable_god_customer_service, NULL, 'I', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); sub->createJumpKeys(); } { LLMenuGL* sub = new LLMenuGL("Parcel"); menu->appendMenu(sub); sub->append(new LLMenuItemCallGL("Owner To Me", &handle_force_parcel_owner_to_me, &enable_god_customer_service, NULL)); sub->append(new LLMenuItemCallGL("Set to Linden Content", &handle_force_parcel_to_content, &enable_god_customer_service, NULL, 'C', MASK_SHIFT | MASK_ALT | MASK_CONTROL)); sub->appendSeparator(); sub->append(new LLMenuItemCallGL("Claim Public Land", &handle_claim_public_land, &enable_god_customer_service)); sub->createJumpKeys(); } { LLMenuGL* sub = new LLMenuGL("Region"); menu->appendMenu(sub); sub->append(new LLMenuItemCallGL("Dump Temp Asset Data", &handle_region_dump_temp_asset_data, &enable_god_customer_service, NULL)); sub->createJumpKeys(); } menu->append(new LLMenuItemCallGL( "God Tools...", &LLFloaterGodTools::show, &enable_god_basic, NULL)); menu->appendSeparator(); menu->append(new LLMenuItemCallGL("Save Region State", &LLPanelRegionTools::onSaveState, &enable_god_customer_service, NULL)); // menu->append(new LLMenuItemCallGL("Force Join Group", handle_force_join_group)); menu->appendSeparator(); // // menu->append(new LLMenuItemCallGL( "OverlayTitle", // &handle_show_overlay_title, &enable_god_customer_service, NULL)); menu->append(new LLMenuItemCallGL("Request Admin Status", &handle_god_mode, NULL, NULL, 'G', MASK_ALT | MASK_CONTROL)); menu->append(new LLMenuItemCallGL("Leave Admin Status", &handle_leave_god_mode, NULL, NULL, 'G', MASK_ALT | MASK_SHIFT | MASK_CONTROL)); menu->createJumpKeys(); } static std::vector > sMenus; //----------------------------------------------------------------------------- // cleanup_menus() //----------------------------------------------------------------------------- void cleanup_menus() { delete gMenuParcelObserver; gMenuParcelObserver = NULL; delete gPieSelf; gPieSelf = NULL; delete gPieAvatar; gPieAvatar = NULL; delete gPieObject; gPieObject = NULL; delete gPieAttachment; gPieAttachment = NULL; delete gPieLand; gPieLand = NULL; delete gMenuBarView; gMenuBarView = NULL; delete gPopupMenuView; gPopupMenuView = NULL; delete gMenuHolder; gMenuHolder = NULL; sMenus.clear(); } //----------------------------------------------------------------------------- // Object pie menu //----------------------------------------------------------------------------- class LLObjectReportAbuse : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLFloaterReporter::showFromObject(gLastHitObjectID); return true; } }; // Enabled it you clicked an object class LLObjectEnableReportAbuse : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = !gLastHitObjectID.isNull(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLObjectTouch : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerObject* object = gObjectList.findObject(gLastHitObjectID); if (!object) return true; LLMessageSystem *msg = gMessageSystem; msg->newMessageFast(_PREHASH_ObjectGrab); msg->nextBlockFast( _PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast( _PREHASH_ObjectData); msg->addU32Fast( _PREHASH_LocalID, object->mLocalID); msg->addVector3Fast(_PREHASH_GrabOffset, LLVector3::zero ); msg->sendMessage( object->getRegion()->getHost()); // *NOTE: Hope the packets arrive safely and in order or else // there will be some problems. // *TODO: Just fix this bad assumption. msg->newMessageFast(_PREHASH_ObjectDeGrab); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast(_PREHASH_ObjectData); msg->addU32Fast(_PREHASH_LocalID, object->mLocalID); msg->sendMessage(object->getRegion()->getHost()); return true; } }; // One object must have touch sensor class LLObjectEnableTouch : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerObject* obj = gObjectList.findObject(gLastHitObjectID); bool new_value = obj && obj->flagHandleTouch(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); // Update label based on the node touch name if available. LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if (node && node->mValid && !node->mTouchName.empty()) { gMenuHolder->childSetText("Object Touch", node->mTouchName); } else { gMenuHolder->childSetText("Object Touch", userdata["data"].asString()); } return true; } }; void label_touch(LLString& label, void*) { LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if (node && node->mValid && !node->mTouchName.empty()) { label.assign(node->mTouchName); } else { label.assign("Touch"); } } bool handle_object_open() { LLViewerObject* obj = gObjectList.findObject(gLastHitObjectID); if(!obj) return true; LLFloaterOpenObject::show(); return true; } class LLObjectOpen : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return handle_object_open(); } }; class LLObjectEnableOpen : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // Look for contents in root object, which is all the LLFloaterOpenObject // understands. LLViewerObject* obj = gObjectList.findObject(gLastHitObjectID); bool new_value = (obj != NULL); if (new_value) { LLViewerObject* root = obj->getRootEdit(); if (!root) new_value = false; else new_value = root->allowOpen(); } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLViewCheckBuildMode : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gToolMgr->inEdit(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; bool toggle_build_mode() { if (gToolMgr->inEdit()) { // just reset the view, will pull us out of edit mode handle_reset_view(); } else { if (gAgent.getFocusOnAvatar() && gSavedSettings.getBOOL("EditCameraMovement") ) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gAgent.getPositionGlobal() + 2.0 * LLVector3d(gAgent.getAtAxis())); gAgent.cameraZoomIn(0.666f); gAgent.cameraOrbitOver( 30.f * DEG_TO_RAD ); } gToolMgr->setCurrentToolset(gBasicToolset); gToolMgr->getCurrentToolset()->selectTool( gToolCreate ); // Could be first use LLFirstUse::useBuild(); } return true; } class LLViewBuildMode : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return toggle_build_mode(); } }; class LLObjectBuild : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gAgent.getFocusOnAvatar() && !gToolMgr->inEdit() && gSavedSettings.getBOOL("EditCameraMovement") ) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gAgent.cameraZoomIn(0.666f); gAgent.cameraOrbitOver( 30.f * DEG_TO_RAD ); gViewerWindow->moveCursorToCenter(); } else if ( gSavedSettings.getBOOL("EditCameraMovement") ) { gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gViewerWindow->moveCursorToCenter(); } gToolMgr->setCurrentToolset(gBasicToolset); gToolMgr->getCurrentToolset()->selectTool( gToolCreate ); // Could be first use LLFirstUse::useBuild(); return true; } }; class LLObjectEdit : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gParcelMgr->deselectLand(); if (gAgent.getFocusOnAvatar() && !gToolMgr->inEdit()) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); if (selection->getSelectType() == SELECT_TYPE_HUD || !gSavedSettings.getBOOL("EditCameraMovement")) { // always freeze camera in space, even if camera doesn't move // so, for example, follow cam scripts can't affect you when in build mode gAgent.setFocusGlobal(gAgent.calcFocusPositionTargetGlobal(), LLUUID::null); gAgent.setFocusOnAvatar(FALSE, ANIMATE); } else { gAgent.setFocusOnAvatar(FALSE, ANIMATE); // zoom in on object center instead of where we clicked, as we need to see the manipulator handles gAgent.setFocusGlobal(gLastHitPosGlobal /*+ gLastHitObjectOffset*/, gLastHitObjectID); gAgent.cameraZoomIn(0.666f); gAgent.cameraOrbitOver( 30.f * DEG_TO_RAD ); gViewerWindow->moveCursorToCenter(); } } gFloaterTools->open(); /* Flawfinder: ignore */ gToolMgr->setCurrentToolset(gBasicToolset); gFloaterTools->setEditTool( gToolTranslate ); // Could be first use LLFirstUse::useBuild(); return true; } }; class LLObjectInspect : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLFloaterInspect::show(); return true; } }; //--------------------------------------------------------------------------- // Land pie menu //--------------------------------------------------------------------------- class LLLandBuild : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gParcelMgr->deselectLand(); if (gAgent.getFocusOnAvatar() && !gToolMgr->inEdit() && gSavedSettings.getBOOL("EditCameraMovement") ) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gAgent.cameraZoomIn(0.666f); gAgent.cameraOrbitOver( 30.f * DEG_TO_RAD ); gViewerWindow->moveCursorToCenter(); } else if ( gSavedSettings.getBOOL("EditCameraMovement") ) { // otherwise just move focus gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gViewerWindow->moveCursorToCenter(); } gToolMgr->setCurrentToolset(gBasicToolset); gToolMgr->getCurrentToolset()->selectTool( gToolCreate ); // Could be first use LLFirstUse::useBuild(); return true; } }; class LLLandBuyPass : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLPanelLandGeneral::onClickBuyPass((void *)FALSE); return true; } }; class LLLandEnableBuyPass : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = LLPanelLandGeneral::enableBuyPass(NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; // BUG: Should really check if CLICK POINT is in a parcel where you can build. BOOL enable_land_build(void*) { if (gAgent.isGodlike()) return TRUE; if (gAgent.inPrelude()) return FALSE; BOOL can_build = FALSE; LLParcel* agent_parcel = gParcelMgr->getAgentParcel(); if (agent_parcel) { can_build = agent_parcel->getAllowModify(); } return can_build; } // BUG: Should really check if OBJECT is in a parcel where you can build. BOOL enable_object_build(void*) { if (gAgent.isGodlike()) return TRUE; if (gAgent.inPrelude()) return FALSE; BOOL can_build = FALSE; LLParcel* agent_parcel = gParcelMgr->getAgentParcel(); if (agent_parcel) { can_build = agent_parcel->getAllowModify(); } return can_build; } class LLEnableEdit : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.isGodlike() || !gAgent.inPrelude(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLSelfRemoveAllAttachments : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLAgent::userRemoveAllAttachments(NULL); return true; } }; class LLSelfEnableRemoveAllAttachments : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = false; if (gAgent.getAvatarObject()) { LLVOAvatar* avatarp = gAgent.getAvatarObject(); for (LLViewerJointAttachment* attachmentp = avatarp->mAttachmentPoints.getFirstData(); attachmentp; attachmentp = avatarp->mAttachmentPoints.getNextData()) { if (attachmentp->getObject()) { new_value = true; break; } } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_has_attachments(void*) { return FALSE; } //--------------------------------------------------------------------------- // Avatar pie menu //--------------------------------------------------------------------------- void handle_follow(void *userdata) { // follow a given avatar, ID in gLastHitObjectID gAgent.startFollowPilot(gLastHitObjectID); } class LLObjectEnableMute : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerObject* object = gViewerWindow->lastObjectHit(); bool new_value = (object != NULL); if (new_value) { LLVOAvatar* avatar = find_avatar_from_object(object); if (avatar) { // It's an avatar LLNameValue *lastname = avatar->getNVPair("LastName"); BOOL is_linden = lastname && !LLString::compareStrings(lastname->getString(), "Linden"); BOOL is_self = avatar->isSelf(); new_value = !is_linden && !is_self; } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLObjectMute : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerObject* object = gViewerWindow->lastObjectHit(); if (!object) return true; LLUUID id; LLString name; LLMute::EType type; LLVOAvatar* avatar = find_avatar_from_object(object); if (avatar) { id = avatar->getID(); LLNameValue *firstname = avatar->getNVPair("FirstName"); LLNameValue *lastname = avatar->getNVPair("LastName"); if (firstname && lastname) { name = firstname->getString(); name += " "; name += lastname->getString(); } type = LLMute::AGENT; } else { // it's an object id = object->getID(); LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if (node) { name = node->mName; } type = LLMute::OBJECT; } LLMute mute(id, name, type); if (gMuteListp->isMuted(mute.mID, mute.mName)) { gMuteListp->remove(mute); } else { gMuteListp->add(mute); gFloaterMute->show(); } return true; } }; bool handle_go_to() { // JAMESDEBUG try simulator autopilot std::vector strings; std::string val; val = llformat("%g", gLastHitPosGlobal.mdV[VX]); strings.push_back(val); val = llformat("%g", gLastHitPosGlobal.mdV[VY]); strings.push_back(val); val = llformat("%g", gLastHitPosGlobal.mdV[VZ]); strings.push_back(val); send_generic_message("autopilot", strings); gParcelMgr->deselectLand(); if (gAgent.getAvatarObject() && !gSavedSettings.getBOOL("AutoPilotLocksCamera")) { gAgent.setFocusGlobal(gAgent.getFocusTargetGlobal(), gAgent.getAvatarObject()->getID()); } else { // Snap camera back to behind avatar gAgent.setFocusOnAvatar(TRUE, ANIMATE); } // Could be first use LLFirstUse::useGoTo(); return true; } class LLGoToObject : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return handle_go_to(); } }; //--------------------------------------------------------------------------- // Parcel freeze, eject, etc. //--------------------------------------------------------------------------- void callback_freeze(S32 option, void* data) { LLUUID* avatar_id = (LLUUID*) data; if (0 == option || 1 == option) { U32 flags = 0x0; if (1 == option) { // unfreeze flags |= 0x1; } LLMessageSystem* msg = gMessageSystem; LLViewerObject* avatar = gObjectList.findObject(*avatar_id); if (avatar) { msg->newMessage("FreezeUser"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgent.getID()); msg->addUUID("SessionID", gAgent.getSessionID()); msg->nextBlock("Data"); msg->addUUID("TargetID", *avatar_id ); msg->addU32("Flags", flags ); msg->sendReliable( avatar->getRegion()->getHost() ); } } delete avatar_id; avatar_id = NULL; } class LLAvatarFreeze : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if( avatar ) { LLUUID* avatar_id = new LLUUID( avatar->getID() ); gViewerWindow->alertXml("FreezeAvatar", callback_freeze, (void*)avatar_id); } return true; } }; class LLAvatarVisibleDebug : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.isGodlike(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLAvatarEnableDebug : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.isGodlike(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLAvatarDebug : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if( avatar ) { avatar->dumpLocalTextures(); llinfos << "Dumping temporary asset data to simulator logs for avatar " << avatar->getID() << llendl; std::vector strings; strings.push_back(avatar->getID().asString()); LLUUID invoice; send_generic_message("dumptempassetdata", strings, invoice); LLFloaterAvatarTextures::show( avatar->getID() ); } return true; } }; void callback_eject(S32 option, void* data) { LLUUID* avatar_id = (LLUUID*) data; if (0 == option || 1 == option) { LLMessageSystem* msg = gMessageSystem; LLViewerObject* avatar = gObjectList.findObject(*avatar_id); if (avatar) { U32 flags = 0x0; if (1 == option) { // eject and add to ban list flags |= 0x1; } msg->newMessage("EjectUser"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgent.getID() ); msg->addUUID("SessionID", gAgent.getSessionID() ); msg->nextBlock("Data"); msg->addUUID("TargetID", *avatar_id ); msg->addU32("Flags", flags ); msg->sendReliable( avatar->getRegion()->getHost() ); } } delete avatar_id; avatar_id = NULL; } class LLAvatarEject : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if( avatar ) { LLUUID* avatar_id = new LLUUID( avatar->getID() ); gViewerWindow->alertXml("EjectAvatar", callback_eject, (void*)avatar_id); } return true; } }; class LLAvatarEnableFreezeEject : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); bool new_value = (avatar != NULL); if (new_value) { const LLVector3& pos = avatar->getPositionRegion(); LLViewerRegion* region = avatar->getRegion(); new_value = (region != NULL); if (new_value) { new_value = (region->isOwnedSelf(pos) || region->isOwnedGroup(pos)); } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLAvatarGiveCard : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { llinfos << "handle_give_card()" << llendl; LLViewerObject* dest = gViewerWindow->lastObjectHit(); if(dest && dest->isAvatar()) { bool found_name = false; LLString::format_map_t args; LLNameValue* nvfirst = dest->getNVPair("FirstName"); LLNameValue* nvlast = dest->getNVPair("LastName"); if(nvfirst && nvlast) { args["[FIRST]"] = nvfirst->getString(); args["[LAST]"] = nvlast->getString(); found_name = true; } LLViewerRegion* region = dest->getRegion(); LLHost dest_host; if(region) { dest_host = region->getHost(); } if(found_name && dest_host.isOk()) { LLMessageSystem* msg = gMessageSystem; msg->newMessage("OfferCallingCard"); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast(_PREHASH_AgentBlock); msg->addUUIDFast(_PREHASH_DestID, dest->getID()); LLUUID transaction_id; transaction_id.generate(); msg->addUUIDFast(_PREHASH_TransactionID, transaction_id); msg->sendReliable(dest_host); LLNotifyBox::showXml("OfferedCard", args); } else { gViewerWindow->alertXml("CantOfferCallingCard", args); } } return true; } }; void login_done(S32 which, void *user) { llinfos << "Login done " << which << llendl; LLPanelLogin::close(); } void callback_leave_group(S32 option, void *userdata) { if (option == 0) { LLMessageSystem *msg = gMessageSystem; msg->newMessageFast(_PREHASH_LeaveGroupRequest); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() ); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast(_PREHASH_GroupData); msg->addUUIDFast(_PREHASH_GroupID, gAgent.mGroupID ); //msg->sendReliable( gUserServer ); gAgent.sendReliableMessage(); } } void handle_leave_group(void *) { if (gAgent.getGroupID() != LLUUID::null) { LLString::format_map_t args; args["[GROUP]"] = gAgent.mGroupName; gViewerWindow->alertXml("GroupLeaveConfirmMember", args, callback_leave_group); } } void append_aggregate(LLString& string, const LLAggregatePermissions& ag_perm, PermissionBit bit, const char* txt) { LLAggregatePermissions::EValue val = ag_perm.getValue(bit); char buffer[MAX_STRING]; /* Flawfinder: ignore */ buffer[0] = '\0'; switch(val) { case LLAggregatePermissions::AP_NONE: snprintf(buffer, MAX_STRING, "* %s None\n", txt); /* Flawfinder: ignore */ break; case LLAggregatePermissions::AP_SOME: snprintf(buffer, MAX_STRING, "* %s Some\n", txt); /* Flawfinder: ignore */ break; case LLAggregatePermissions::AP_ALL: snprintf(buffer, MAX_STRING, "* %s All\n", txt); /* Flawfinder: ignore */ break; case LLAggregatePermissions::AP_EMPTY: default: break; } string.append(buffer); } const char* build_extensions_string(LLFilePicker::ELoadFilter filter) { switch(filter) { #if LL_WINDOWS case LLFilePicker::FFLOAD_IMAGE: return IMAGE_EXTENSIONS; case LLFilePicker::FFLOAD_WAV: return SOUND_EXTENSIONS; case LLFilePicker::FFLOAD_ANIM: return ANIM_EXTENSIONS; case LLFilePicker::FFLOAD_SLOBJECT: return SLOBJECT_EXTENSIONS; #ifdef _CORY_TESTING case LLFilePicker::FFLOAD_GEOMETRY: return GEOMETRY_EXTENSIONS; #endif case LLFilePicker::FFLOAD_XML: return XML_EXTENSIONS; case LLFilePicker::FFLOAD_ALL: return ALL_FILE_EXTENSIONS; #endif default: return ALL_FILE_EXTENSIONS; } } BOOL enable_buy(void*) { // In order to buy, there must only be 1 purchaseable object in // the selection manger. if(gSelectMgr->getSelection()->getRootObjectCount() != 1) return FALSE; LLViewerObject* obj = NULL; LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if(node) { obj = node->getObject(); if(!obj) return FALSE; if(node->mSaleInfo.isForSale() && node->mPermissions->getMaskOwner() & PERM_TRANSFER && (node->mPermissions->getMaskOwner() & PERM_COPY || node->mSaleInfo.getSaleType() != LLSaleInfo::FS_COPY)) { if(obj->permAnyOwner()) return TRUE; } } return FALSE; } class LLObjectEnableBuy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = enable_buy(NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; // Note: This will only work if the selected object's data has been // received by the viewer and cached in the selection manager. void handle_buy_object(LLSaleInfo sale_info) { if(!gSelectMgr->selectGetAllRootsValid()) { LLNotifyBox::showXml("UnableToBuyWhileDownloading"); return; } LLUUID owner_id; LLString owner_name; BOOL owners_identical = gSelectMgr->selectGetOwner(owner_id, owner_name); if (!owners_identical) { LLNotifyBox::showXml("CannotBuyObjectsFromDifferentOwners"); return; } LLPermissions perm; BOOL valid = gSelectMgr->selectGetPermissions(perm); LLAggregatePermissions ag_perm; valid &= gSelectMgr->selectGetAggregatePermissions(ag_perm); if(!valid || !sale_info.isForSale() || !perm.allowTransferTo(gAgent.getID())) { LLNotifyBox::showXml("ObjectNotForSale"); return; } S32 price = sale_info.getSalePrice(); if (price > 0 && price > gStatusBar->getBalance()) { LLFloaterBuyCurrency::buyCurrency("This object costs", price); return; } LLFloaterBuy::show(sale_info); } void handle_buy_contents(LLSaleInfo sale_info) { LLFloaterBuyContents::show(sale_info); } void handle_region_dump_temp_asset_data(void*) { llinfos << "Dumping temporary asset data to simulator logs" << llendl; std::vector strings; LLUUID invoice; send_generic_message("dumptempassetdata", strings, invoice); } void handle_region_clear_temp_asset_data(void*) { llinfos << "Clearing temporary asset data" << llendl; std::vector strings; LLUUID invoice; send_generic_message("cleartempassetdata", strings, invoice); } void handle_region_dump_settings(void*) { LLViewerRegion* regionp = gAgent.getRegion(); if (regionp) { llinfos << "Damage: " << (regionp->getAllowDamage() ? "on" : "off") << llendl; llinfos << "Landmark: " << (regionp->getAllowLandmark() ? "on" : "off") << llendl; llinfos << "SetHome: " << (regionp->getAllowSetHome() ? "on" : "off") << llendl; llinfos << "ResetHome: " << (regionp->getResetHomeOnTeleport() ? "on" : "off") << llendl; llinfos << "SunFixed: " << (regionp->getSunFixed() ? "on" : "off") << llendl; llinfos << "BlockFly: " << (regionp->getBlockFly() ? "on" : "off") << llendl; llinfos << "AllowP2P: " << (regionp->getAllowDirectTeleport() ? "on" : "off") << llendl; llinfos << "Water: " << (regionp->getWaterHeight()) << llendl; } } void handle_dump_group_info(void *) { llinfos << "group " << gAgent.mGroupName << llendl; llinfos << "ID " << gAgent.mGroupID << llendl; llinfos << "powers " << gAgent.mGroupPowers << llendl; llinfos << "title " << gAgent.mGroupTitle << llendl; //llinfos << "insig " << gAgent.mGroupInsigniaID << llendl; } void handle_dump_capabilities_info(void *) { LLViewerRegion* regionp = gAgent.getRegion(); if (regionp) { regionp->logActiveCapabilities(); } } void handle_dump_region_object_cache(void*) { LLViewerRegion* regionp = gAgent.getRegion(); if (regionp) { regionp->dumpCache(); } } void handle_dump_focus(void *) { LLView *view = gFocusMgr.getKeyboardFocus(); llinfos << "Keyboard focus " << (view ? view->getName() : "(none)") << llendl; } class LLSelfStandUp : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gAgent.setControlFlags(AGENT_CONTROL_STAND_UP); return true; } }; class LLSelfEnableStandUp : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.getAvatarObject() && gAgent.getAvatarObject()->mIsSitting; gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL check_admin_override(void*) { return gAgent.getAdminOverride(); } void handle_admin_override_toggle(void*) { if(!gAgent.getAdminOverride()) { gAgent.setAdminOverride(TRUE); show_debug_menus(); } else gAgent.setAdminOverride(FALSE); } void handle_god_mode(void*) { gAgent.requestEnterGodMode(); } void handle_leave_god_mode(void*) { gAgent.requestLeaveGodMode(); } void set_god_level(U8 god_level) { U8 old_god_level = gAgent.getGodLevel(); gAgent.setGodLevel( god_level ); show_debug_menus(); gIMMgr->refresh(); gParcelMgr->notifyObservers(); // Some classifieds change visibility on god mode LLFloaterDirectory::requestClassifieds(); // God mode changes sim visibility gWorldMap->reset(); gWorldMap->setCurrentLayer(0); // inventory in items may change in god mode gObjectList.dirtyAllObjectInventory(); LLString::format_map_t args; if(god_level > GOD_NOT) { args["[LEVEL]"] = llformat("%d",(S32)god_level); if (gInProductionGrid) { gMenuBarView->setBackgroundColor( gColors.getColor( "MenuBarGodBgColor" ) ); gStatusBar->setBackgroundColor( gColors.getColor( "MenuBarGodBgColor" ) ); } else { gMenuBarView->setBackgroundColor( gColors.getColor( "MenuNonProductionGodBgColor" ) ); gStatusBar->setBackgroundColor( gColors.getColor( "MenuNonProductionGodBgColor" ) ); } LLNotifyBox::showXml("EnteringGodMode", args); } else { args["[LEVEL]"] = llformat("%d",(S32)old_god_level); if (gInProductionGrid) { gMenuBarView->setBackgroundColor( gColors.getColor( "MenuBarBgColor" ) ); gStatusBar->setBackgroundColor( gColors.getColor( "MenuBarBgColor" ) ); } else { gMenuBarView->setBackgroundColor( gColors.getColor( "MenuNonProductionBgColor" ) ); gStatusBar->setBackgroundColor( gColors.getColor( "MenuNonProductionBgColor" ) ); } LLNotifyBox::showXml("LeavingGodMode", args); } } #ifdef TOGGLE_HACKED_GODLIKE_VIEWER void handle_toggle_hacked_godmode(void*) { gHackGodmode = !gHackGodmode; set_god_level(gHackGodmode ? GOD_MAINTENANCE : GOD_NOT); } BOOL check_toggle_hacked_godmode(void*) { return gHackGodmode; } #endif void process_grant_godlike_powers(LLMessageSystem* msg, void**) { LLUUID agent_id; msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id); LLUUID session_id; msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_SessionID, session_id); if((agent_id == gAgent.getID()) && (session_id == gAgent.getSessionID())) { U8 god_level; msg->getU8Fast(_PREHASH_GrantData, _PREHASH_GodLevel, god_level); set_god_level(god_level); } else { llwarns << "Grant godlike for wrong agent " << agent_id << llendl; } } void load_url_local_file(const char* file_name) { if( gAgent.cameraMouselook() ) { gAgent.changeCameraToDefault(); } #if LL_DARWIN || LL_LINUX || LL_SOLARIS // MBW -- If the Mac client is in fullscreen mode, it needs to go windowed so the browser will be visible. if(gViewerWindow->mWindow->getFullscreen()) { gViewerWindow->toggleFullscreen(TRUE); } #endif // JC - system() blocks until IE has launched. // spawn() runs asynchronously, but opens a command prompt. // ShellExecute() just opens the damn file with the default // web browser. std::string full_path = "file:///"; full_path.append(gDirUtilp->getAppRODataDir()); full_path.append(gDirUtilp->getDirDelimiter()); full_path.append(file_name); LLWeb::loadURL(full_path.c_str()); } /* class LLHaveCallingcard : public LLInventoryCollectFunctor { public: LLHaveCallingcard(const LLUUID& agent_id); virtual ~LLHaveCallingcard() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); BOOL isThere() const { return mIsThere;} protected: LLUUID mID; BOOL mIsThere; }; LLHaveCallingcard::LLHaveCallingcard(const LLUUID& agent_id) : mID(agent_id), mIsThere(FALSE) { } bool LLHaveCallingcard::operator()(LLInventoryCategory* cat, LLInventoryItem* item) { if(item) { if((item->getType() == LLAssetType::AT_CALLINGCARD) && (item->getCreatorUUID() == mID)) { mIsThere = TRUE; } } return FALSE; } */ BOOL is_agent_friend(const LLUUID& agent_id) { return (LLAvatarTracker::instance().getBuddyInfo(agent_id) != NULL); } BOOL is_agent_mappable(const LLUUID& agent_id) { return (is_agent_friend(agent_id) && LLAvatarTracker::instance().getBuddyInfo(agent_id)->isOnline() && LLAvatarTracker::instance().getBuddyInfo(agent_id)->isRightGrantedFrom(LLRelationship::GRANT_MAP_LOCATION) ); } // Enable a menu item when you have someone's card. /* BOOL enable_have_card(void *userdata) { LLUUID* avatar_id = (LLUUID *)userdata; if (gAgent.isGodlike()) { return TRUE; } else if(avatar_id) { return is_agent_friend(*avatar_id); } else { return FALSE; } } */ // Enable a menu item when you don't have someone's card. class LLAvatarEnableAddFriend : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object(gViewerWindow->lastObjectHit()); bool new_value = avatar && !is_agent_friend(avatar->getID()); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; void request_friendship(const LLUUID& dest_id) { LLViewerObject* dest = gObjectList.findObject(dest_id); if(dest && dest->isAvatar()) { LLString fullname; LLString::format_map_t args; LLNameValue* nvfirst = dest->getNVPair("FirstName"); LLNameValue* nvlast = dest->getNVPair("LastName"); if(nvfirst && nvlast) { args["[FIRST]"] = nvfirst->getString(); args["[LAST]"] = nvlast->getString(); fullname = nvfirst->getString(); fullname += " "; fullname += nvlast->getString(); } if (!fullname.empty()) { LLPanelFriends::requestFriendship(dest_id, fullname); LLNotifyBox::showXml("OfferedFriendship", args); } else { gViewerWindow->alertXml("CantOfferFriendship"); } } } class LLEditEnableCustomizeAvatar : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.getWearablesLoaded(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; bool handle_sit_or_stand() { LLViewerObject *object = gObjectList.findObject(gLastHitNonFloraObjectID); if (!object) { return true; } if (sitting_on_selection()) { gAgent.setControlFlags(AGENT_CONTROL_STAND_UP); return true; } // get object selection offset if (object && object->getPCode() == LL_PCODE_VOLUME) { LLVector3d offset_double = gViewerWindow->lastNonFloraObjectHitOffset(); LLVector3 offset_single; offset_single.setVec(offset_double); gMessageSystem->newMessageFast(_PREHASH_AgentRequestSit); gMessageSystem->nextBlockFast(_PREHASH_AgentData); gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); gMessageSystem->nextBlockFast(_PREHASH_TargetObject); gMessageSystem->addUUIDFast(_PREHASH_TargetID, object->mID); gMessageSystem->addVector3Fast(_PREHASH_Offset, offset_single); object->getRegion()->sendReliableMessage(); } return true; } class LLObjectSitOrStand : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return handle_sit_or_stand(); } }; void near_sit_down_point(BOOL success, void *) { if (success) { gAgent.setFlying(FALSE); gAgent.setControlFlags(AGENT_CONTROL_SIT_ON_GROUND); // Might be first sit LLFirstUse::useSit(); } } class LLLandSit : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gAgent.setControlFlags(AGENT_CONTROL_STAND_UP); gParcelMgr->deselectLand(); LLVector3d posGlobal = gLastHitPosGlobal; LLQuaternion target_rot; if (gAgent.getAvatarObject()) { target_rot = gAgent.getAvatarObject()->getRotation(); } else { target_rot = gAgent.getFrameAgent().getQuaternion(); } gAgent.startAutoPilotGlobal(posGlobal, "Sit", &target_rot, near_sit_down_point, NULL, 0.7f); return true; } }; void show_permissions_control(void*) { LLFloaterPermissionsMgr* floaterp = LLFloaterPermissionsMgr::show(); floaterp->mPermissions->addPermissionsData("foo1", LLUUID::null, 0); floaterp->mPermissions->addPermissionsData("foo2", LLUUID::null, 0); floaterp->mPermissions->addPermissionsData("foo3", LLUUID::null, 0); } #if 0 // Unused (these just modify AudioInfoPage which is not used anywhere in the code void handle_audio_status_1(void*) { S32 page = gSavedSettings.getS32("AudioInfoPage"); if (1 == page) { page = 0; } else { page = 1; } gSavedSettings.setS32("AudioInfoPage", page); } void handle_audio_status_2(void*) { S32 page = gSavedSettings.getS32("AudioInfoPage"); if (2 == page) { page = 0; } else { page = 2; } gSavedSettings.setS32("AudioInfoPage", page); } void handle_audio_status_3(void*) { S32 page = gSavedSettings.getS32("AudioInfoPage"); if (3 == page) { page = 0; } else { page = 3; } gSavedSettings.setS32("AudioInfoPage", page); } void handle_audio_status_4(void*) { S32 page = gSavedSettings.getS32("AudioInfoPage"); if (4 == page) { page = 0; } else { page = 4; } gSavedSettings.setS32("AudioInfoPage", page); } #endif void reload_ui(void *) { gUICtrlFactory->rebuild(); } class LLWorldFly : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gAgent.toggleFlying(); return true; } }; void handle_agent_stop_moving(void*) { // stop agent gAgent.setControlFlags(AGENT_CONTROL_STOP); // cancel autopilot gAgent.stopAutoPilot(); } void print_packets_lost(void*) { gWorldPointer->printPacketsLost(); } void drop_packet(void*) { gMessageSystem->mPacketRing.dropPackets(1); } void velocity_interpolate( void* data ) { BOOL toggle = gSavedSettings.getBOOL("VelocityInterpolate"); LLMessageSystem* msg = gMessageSystem; if ( !toggle ) { msg->newMessageFast(_PREHASH_VelocityInterpolateOn); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); gAgent.sendReliableMessage(); llinfos << "Velocity Interpolation On" << llendl; } else { msg->newMessageFast(_PREHASH_VelocityInterpolateOff); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); gAgent.sendReliableMessage(); llinfos << "Velocity Interpolation Off" << llendl; } // BUG this is a hack because of the change in menu behavior. The // old menu system would automatically change a control's value, // but the new LLMenuGL system doesn't know what a control // is. However, it's easy to distinguish between the two callers // because LLMenuGL passes in the name of the user data (the // control name) to the callback function, and the user data goes // unused in the old menu code. Thus, if data is not null, then we // need to swap the value of the control. if( data ) { gSavedSettings.setBOOL( static_cast(data), !toggle ); } } void update_fov(S32 increments) { F32 old_fov = gCamera->getDefaultFOV(); // for each increment, FoV is 20% bigger F32 new_fov = old_fov * pow(1.2f, increments); // cap the FoV new_fov = llclamp(new_fov, MIN_FIELD_OF_VIEW, MAX_FIELD_OF_VIEW); if (new_fov != old_fov) { LLMessageSystem* msg = gMessageSystem; msg->newMessageFast(_PREHASH_AgentFOV); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->addU32Fast(_PREHASH_CircuitCode, gMessageSystem->mOurCircuitCode); msg->nextBlockFast(_PREHASH_FOVBlock); msg->addU32Fast(_PREHASH_GenCounter, 0); msg->addF32Fast(_PREHASH_VerticalAngle, new_fov); gAgent.sendReliableMessage(); // force agent to update dirty patches gCamera->setDefaultFOV(new_fov); gCamera->setView(new_fov); } } class LLViewZoomOut : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { update_fov(1); return true; } }; class LLViewZoomIn : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { update_fov(-1); return true; } }; class LLViewZoomDefault : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { F32 old_fov = gCamera->getView(); // for each increment, FoV is 20% bigger F32 new_fov = DEFAULT_FIELD_OF_VIEW; if (new_fov != old_fov) { LLMessageSystem* msg = gMessageSystem; msg->newMessageFast(_PREHASH_AgentFOV); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->addU32Fast(_PREHASH_CircuitCode, gMessageSystem->mOurCircuitCode); msg->nextBlockFast(_PREHASH_FOVBlock); msg->addU32Fast(_PREHASH_GenCounter, 0); msg->addF32Fast(_PREHASH_VerticalAngle, new_fov); gAgent.sendReliableMessage(); // force agent to update dirty patches gCamera->setDefaultFOV(new_fov); gCamera->setView(new_fov); } return true; } }; void toggle_wind_audio(void) { if (gAudiop) { gAudiop->enableWind(!(gAudiop->isWindEnabled())); } } // Callback for enablement BOOL is_inventory_visible( void* user_data ) { LLInventoryView* iv = reinterpret_cast(user_data); if( iv ) { return iv->getVisible(); } return FALSE; } void handle_show_newest_map(void*) { LLFloaterWorldMap::show(NULL, FALSE); } //------------------------------------------------------------------- // Help menu functions //------------------------------------------------------------------- class LLHelpMOTD : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString::format_map_t args; args["[MOTD]"] = gAgent.mMOTD; gViewerWindow->alertXml("MOTD", args, NULL, NULL); return true; } }; // // Major mode switching // void reset_view_final( BOOL proceed, void* ); void handle_reset_view() { if( (CAMERA_MODE_CUSTOMIZE_AVATAR == gAgent.getCameraMode()) && gFloaterCustomize ) { // Show dialog box if needed. gFloaterCustomize->askToSaveAllIfDirty( reset_view_final, NULL ); } else { reset_view_final( TRUE, NULL ); } } class LLViewResetView : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { handle_reset_view(); return true; } }; // Note: extra parameters allow this function to be called from dialog. void reset_view_final( BOOL proceed, void* ) { if( !proceed ) { return; } gAgent.changeCameraToDefault(); if (LLViewerJoystick::sOverrideCamera) { handle_toggle_flycam(NULL); } gAgent.resetView(!gFloaterTools->getVisible()); gFloaterTools->close(); gViewerWindow->showCursor(); // Switch back to basic toolset gToolMgr->setCurrentToolset(gBasicToolset); } class LLViewLookAtLastChatter : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gAgent.lookAtLastChat(); return true; } }; class LLViewMouselook : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (!gAgent.cameraMouselook()) { gAgent.changeCameraToMouselook(); } else { gAgent.changeCameraToDefault(); } return true; } }; class LLViewFullscreen : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gViewerWindow->toggleFullscreen(TRUE); return true; } }; class LLViewDefaultUISize : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gSavedSettings.setF32("UIScaleFactor", 1.0f); gSavedSettings.setBOOL("UIAutoScale", FALSE); gViewerWindow->reshape(gViewerWindow->getWindowDisplayWidth(), gViewerWindow->getWindowDisplayHeight()); return true; } }; class LLEditDuplicate : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if(gEditMenuHandler) { gEditMenuHandler->duplicate(); } return true; } }; class LLEditEnableDuplicate : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canDuplicate(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; void disabled_duplicate(void*) { if (gSelectMgr->getSelection()->getFirstObject()) { LLNotifyBox::showXml("CopyFailed"); } } void handle_duplicate_in_place(void*) { llinfos << "handle_duplicate_in_place" << llendl; LLVector3 offset(0.f, 0.f, 0.f); gSelectMgr->selectDuplicate(offset, TRUE); } void handle_repeat_duplicate(void*) { gSelectMgr->repeatDuplicate(); } void handle_deed_object_to_group(void*) { LLUUID group_id; gSelectMgr->selectGetGroup(group_id); gSelectMgr->sendOwner(LLUUID::null, group_id, FALSE); gViewerStats->incStat(LLViewerStats::ST_RELEASE_COUNT); } BOOL enable_deed_object_to_group(void*) { if(gSelectMgr->getSelection()->isEmpty()) return FALSE; LLPermissions perm; LLUUID group_id; if (gSelectMgr->selectGetGroup(group_id) && gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && gSelectMgr->selectGetPermissions(perm) && perm.deedToGroup(gAgent.getID(), group_id)) { return TRUE; } return FALSE; } /* * No longer able to support viewer side manipulations in this way * void god_force_inv_owner_permissive(LLViewerObject* object, InventoryObjectList* inventory, S32 serial_num, void*) { typedef std::vector > item_array_t; item_array_t items; InventoryObjectList::const_iterator inv_it = inventory->begin(); InventoryObjectList::const_iterator inv_end = inventory->end(); for ( ; inv_it != inv_end; ++inv_it) { if(((*inv_it)->getType() != LLAssetType::AT_CATEGORY) && ((*inv_it)->getType() != LLAssetType::AT_ROOT_CATEGORY)) { LLInventoryObject* obj = *inv_it; LLPointer new_item = new LLViewerInventoryItem((LLViewerInventoryItem*)obj); LLPermissions perm(new_item->getPermissions()); perm.setMaskBase(PERM_ALL); perm.setMaskOwner(PERM_ALL); new_item->setPermissions(perm); items.push_back(new_item); } } item_array_t::iterator end = items.end(); item_array_t::iterator it; for(it = items.begin(); it != end; ++it) { // since we have the inventory item in the callback, it should not // invalidate iteration through the selection manager. object->updateInventory((*it), TASK_INVENTORY_ITEM_KEY, false); } } */ void handle_object_owner_permissive(void*) { // only send this if they're a god. if(gAgent.isGodlike()) { // do the objects. gSelectMgr->selectionSetObjectPermissions(PERM_BASE, TRUE, PERM_ALL, TRUE); gSelectMgr->selectionSetObjectPermissions(PERM_OWNER, TRUE, PERM_ALL, TRUE); } } void handle_object_owner_self(void*) { // only send this if they're a god. if(gAgent.isGodlike()) { gSelectMgr->sendOwner(gAgent.getID(), gAgent.getGroupID(), TRUE); } } // Shortcut to set owner permissions to not editable. void handle_object_lock(void*) { gSelectMgr->selectionSetObjectPermissions(PERM_OWNER, FALSE, PERM_MODIFY); } void handle_object_asset_ids(void*) { // only send this if they're a god. if (gAgent.isGodlike()) { gSelectMgr->sendGodlikeRequest("objectinfo", "assetids"); } } void handle_force_parcel_owner_to_me(void*) { gParcelMgr->sendParcelGodForceOwner( gAgent.getID() ); } void handle_force_parcel_to_content(void*) { gParcelMgr->sendParcelGodForceToContent(); } void handle_claim_public_land(void*) { if (gParcelMgr->getSelectionRegion() != gAgent.getRegion()) { LLNotifyBox::showXml("ClaimPublicLand"); return; } LLVector3d west_south_global; LLVector3d east_north_global; gParcelMgr->getSelection(west_south_global, east_north_global); LLVector3 west_south = gAgent.getPosAgentFromGlobal(west_south_global); LLVector3 east_north = gAgent.getPosAgentFromGlobal(east_north_global); LLMessageSystem* msg = gMessageSystem; msg->newMessage("GodlikeMessage"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgent.getID()); msg->addUUID("SessionID", gAgent.getSessionID()); msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null); //not used msg->nextBlock("MethodData"); msg->addString("Method", "claimpublicland"); msg->addUUID("Invoice", LLUUID::null); char buffer[32]; /* Flawfinder: ignore */ snprintf(buffer, sizeof(buffer), "%f", west_south.mV[VX]); /* Flawfinder: ignore */ msg->nextBlock("ParamList"); msg->addString("Parameter", buffer); snprintf(buffer, sizeof(buffer), "%f", west_south.mV[VY]); /* Flawfinder: ignore */ msg->nextBlock("ParamList"); msg->addString("Parameter", buffer); snprintf(buffer, sizeof(buffer), "%f", east_north.mV[VX]); /* Flawfinder: ignore */ msg->nextBlock("ParamList"); msg->addString("Parameter", buffer); snprintf(buffer, sizeof(buffer), "%f", east_north.mV[VY]); /* Flawfinder: ignore */ msg->nextBlock("ParamList"); msg->addString("Parameter", buffer); gAgent.sendReliableMessage(); } void handle_god_request_havok(void *) { if (gAgent.isGodlike()) { gSelectMgr->sendGodlikeRequest("havok", "infoverbose"); } } //void handle_god_request_foo(void *) //{ // if (gAgent.isGodlike()) // { // gSelectMgr->sendGodlikeRequest(GOD_WANTS_FOO); // } //} //void handle_god_request_terrain_save(void *) //{ // if (gAgent.isGodlike()) // { // gSelectMgr->sendGodlikeRequest("terrain", "save"); // } //} //void handle_god_request_terrain_load(void *) //{ // if (gAgent.isGodlike()) // { // gSelectMgr->sendGodlikeRequest("terrain", "load"); // } //} // HACK for easily testing new avatar geometry void handle_god_request_avatar_geometry(void *) { if (gAgent.isGodlike()) { gSelectMgr->sendGodlikeRequest("avatar toggle", NULL); } } void handle_show_overlay_title(void*) { gShowOverlayTitle = !gShowOverlayTitle; gSavedSettings.setBOOL("ShowOverlayTitle", gShowOverlayTitle); } void derez_objects(EDeRezDestination dest, const LLUUID& dest_id) { if(gAgent.cameraMouselook()) { gAgent.changeCameraToDefault(); } //gInventoryView->setPanelOpen(TRUE); LLObjectSelectionHandle selection = gSelectMgr->getSelection(); LLViewerObject* object = NULL; LLSelectNode* node = selection->getFirstRootNode(); if(!node) return; object = node->getObject(); if(!object) return; LLViewerRegion* region = object->getRegion(); char* error = NULL; // Check conditions that we can't deal with, building a list of // everything that we'll actually be derezzing. LLDynamicArray derez_objects; BOOL can_derez_current; for( ; node != NULL; node = selection->getNextRootNode()) { object = node->getObject(); if(!object || !node->mValid) continue; if(object->getRegion() != region) { // Derez doesn't work at all if the some of the objects // are in regions besides the first object selected. // ...crosses region boundaries error = "AcquireErrorObjectSpan"; break; } if (object->isAvatar()) { // ...don't acquire avatars continue; } // If AssetContainers are being sent back, they will appear as // boxes in the owner's inventory. if (object->getNVPair("AssetContainer") && dest != DRD_RETURN_TO_OWNER) { // this object is an asset container, derez its contents, not it llwarns << "Attempt to derez deprecated AssetContainer object type not supported." << llendl; /* object->requestInventory(container_inventory_arrived, (void *)(BOOL)(DRD_TAKE_INTO_AGENT_INVENTORY == dest)); */ continue; } can_derez_current = FALSE; switch(dest) { case DRD_TAKE_INTO_AGENT_INVENTORY: case DRD_TRASH: if( (node->mPermissions->allowTransferTo(gAgent.getID()) && object->permModify()) || (node->allowOperationOnNode(PERM_OWNER, GP_OBJECT_MANIPULATE)) ) { can_derez_current = TRUE; } break; case DRD_RETURN_TO_OWNER: can_derez_current = TRUE; break; default: if((node->mPermissions->allowTransferTo(gAgent.getID()) && object->permCopy()) || gAgent.isGodlike()) { can_derez_current = TRUE; } break; } if(can_derez_current) { derez_objects.put(object); } } // This constant is based on (1200 - HEADER_SIZE) / 4 bytes per // root. I lopped off a few (33) to provide a bit // pad. HEADER_SIZE is currently 67 bytes, most of which is UUIDs. // This gives us a maximum of 63500 root objects - which should // satisfy anybody. const S32 MAX_ROOTS_PER_PACKET = 250; const S32 MAX_PACKET_COUNT = 254; F32 packets = ceil((F32)derez_objects.count() / (F32)MAX_ROOTS_PER_PACKET); if(packets > (F32)MAX_PACKET_COUNT) { error = "AcquireErrorTooManyObjects"; } if(!error && derez_objects.count() > 0) { U8 d = (U8)dest; LLUUID tid; tid.generate(); U8 packet_count = (U8)packets; S32 object_index = 0; S32 objects_in_packet = 0; LLMessageSystem* msg = gMessageSystem; for(U8 packet_number = 0; packet_number < packet_count; ++packet_number) { msg->newMessageFast(_PREHASH_DeRezObject); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->nextBlockFast(_PREHASH_AgentBlock); msg->addUUIDFast(_PREHASH_GroupID, gAgent.getGroupID()); msg->addU8Fast(_PREHASH_Destination, d); msg->addUUIDFast(_PREHASH_DestinationID, dest_id); msg->addUUIDFast(_PREHASH_TransactionID, tid); msg->addU8Fast(_PREHASH_PacketCount, packet_count); msg->addU8Fast(_PREHASH_PacketNumber, packet_number); objects_in_packet = 0; while((object_index < derez_objects.count()) && (objects_in_packet++ < MAX_ROOTS_PER_PACKET)) { object = derez_objects.get(object_index++); msg->nextBlockFast(_PREHASH_ObjectData); msg->addU32Fast(_PREHASH_ObjectLocalID, object->getLocalID()); // VEFFECT: DerezObject LLHUDEffectSpiral* effectp = (LLHUDEffectSpiral*)gHUDManager->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINT, TRUE); effectp->setPositionGlobal(object->getPositionGlobal()); effectp->setColor(LLColor4U(gAgent.getEffectColor())); } msg->sendReliable(region->getHost()); } make_ui_sound("UISndObjectRezOut"); // Busy count decremented by inventory update, so only increment // if will be causing an update. if (dest != DRD_RETURN_TO_OWNER) { gViewerWindow->getWindow()->incBusyCount(); } } else if(error) { gViewerWindow->alertXml(error); } } class LLToolsTakeCopy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gSelectMgr->getSelection()->isEmpty()) return true; const LLUUID& category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT); derez_objects(DRD_ACQUIRE_TO_AGENT_INVENTORY, category_id); return true; } }; // You can return an object to its owner if it is on your land. class LLObjectReturn : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gSelectMgr->getSelection()->isEmpty()) return true; mObjectSelection = gSelectMgr->getEditSelection(); gViewerWindow->alertXml("ReturnToOwner", onReturnToOwner, (void*)this); return true; } static void onReturnToOwner(S32 option, void* data) { LLObjectReturn* object_return = (LLObjectReturn*)data; if (0 == option) { // Ignore category ID for this derez destination. derez_objects(DRD_RETURN_TO_OWNER, LLUUID::null); } // drop reference to current selection object_return->mObjectSelection = NULL; } protected: LLObjectSelectionHandle mObjectSelection; }; // Allow return to owner if one or more of the selected items is // over land you own. class LLObjectEnableReturn : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { #ifdef HACKED_GODLIKE_VIEWER bool new_value = true; #else bool new_value = false; if (gAgent.isGodlike()) { new_value = true; } else { LLViewerRegion* region = gAgent.getRegion(); if (region) { // Estate owners and managers can always return objects. if (region->canManageEstate()) { new_value = true; } else { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); LLViewerObject* obj = NULL; for(obj = selection->getFirstRootObject(); obj; obj = selection->getNextRootObject()) { if (obj->isOverAgentOwnedLand() || obj->isOverGroupOwnedLand() || obj->permModify()) { new_value = true; break; } } } } } #endif gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; void force_take_copy(void*) { if (gSelectMgr->getSelection()->isEmpty()) return; const LLUUID& category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT); derez_objects(DRD_FORCE_TO_GOD_INVENTORY, category_id); } #ifdef _CORY_TESTING void force_export_copy(void*) { LLViewerObject* object = NULL; LLSelectNode* node = gSelectMgr->getSelection()->getFirstNode(); if(!node) return; object = node->getObject(); if(!object) return; LLString proposed_name; proposed_name.append(node->mName); proposed_name.append( ".slg" ); LLViewerRegion* region = object->getRegion(); // Check conditions that we can't deal with, building a list of // everything that we'll actually be derezzing. std::vector export_objects; std::vector export_names; std::vector export_descriptions; S32 object_index = 0; for( ; node != NULL; node = gSelectMgr->getSelection()->getNextNode()) { object = node->getObject(); if(!object || !node->mValid) { // Clicked cancel return; } if(object->getRegion() != region) { // Clicked cancel return; } if (object->isAvatar()) { continue; } if (object->getNVPair("AssetContainer")) { continue; } export_objects.push_back(node->getObject()); export_names.push_back(node->mName); export_descriptions.push_back(node->mDescription); } if (export_objects.empty()) { return; } // pick a save file LLFilePicker& picker = LLFilePicker::instance(); if (!picker.getSaveFile(LLFilePicker::FFSAVE_GEOMETRY, proposed_name)) { // Clicked cancel return; } // Copy the directory + file name char filepath[LL_MAX_PATH]; /* Flawfinder: ignore */ strncpy(filepath, picker.getFirstFile(), LL_MAX_PATH -1); /* Flawfinder: ignore */ filepath[LL_MAX_PATH -1] = '\0'; apr_file_t* fp = ll_apr_file_open(filepath, LL_APR_W); if (!fp) { return; } object = export_objects[object_index]; LLVector3 baseoffset = object->getPositionRegion(); apr_file_printf(fp, "\n"); apr_file_printf(fp, "\n"); while(object_index < export_objects.size()) { apr_file_printf(fp, "getPCode()); apr_file_printf(fp, "\tMaterial='%d'\n", object->getMaterial()); apr_file_printf(fp, "\tScale='%5f %5f %5f'\n", object->getScale().mV[VX], object->getScale().mV[VY], object->getScale().mV[VZ]); LLVector3 delta = object->getPositionRegion() - baseoffset; LLQuaternion rot = object->getRotationRegion(); apr_file_printf(fp, "\tOffset='%5f %5f %5f'\n", delta.mV[VX], delta.mV[VY], delta.mV[VZ]); apr_file_printf(fp, "\tOrientation='%5f %5f %5f %5f'\n", rot.mQ[VX], rot.mQ[VY], rot.mQ[VZ], rot.mQ[VS]); const LLProfileParams pparams = object->getVolume()->getProfile().mParams; apr_file_printf(fp, "\tShapeProfile='%d %f %f %f'\n", pparams.getCurveType(), pparams.getBegin(), pparams.getEnd(), pparams.getHollow()); const LLPathParams paparams = object->getVolume()->getPath().mParams; apr_file_printf(fp, "\tShapePath='%d %f %f %f %f %f %f %f %f %f %f %f %f %f'\n", paparams.getCurveType(), paparams.getBegin(), paparams.getEnd(), paparams.getTwist(), paparams.getTwistBegin(), paparams.getScaleX(), paparams.getScaleY(), paparams.getShearX(), paparams.getShearY(), paparams.getRadiusOffset(), paparams.getTaperX(), paparams.getTaperY(), paparams.getRevolutions(), paparams.getSkew()); S32 face, numfaces; numfaces = object->getNumTEs(); apr_file_printf(fp, "\tNumberOfFaces='%d'>\n", numfaces); for (face = 0; face < numfaces; face++) { const LLTextureEntry *te = object->getTE(face); LLColor4 color = te->getColor(); apr_file_printf(fp, "\tgetID(); texid.toString(texture); F32 sx, sy, ox, oy; te->getScale(&sx, &sy); te->getOffset(&ox, &oy); apr_file_printf(fp, "\t\tFace='%d %5f %5f %5f %5f %5f %d %s'\n\t/>\n", face, sx, sy, ox, oy, te->getRotation(), te->getBumpShinyFullbright(), texture); } apr_file_printf(fp, "\n"); object = export_objects[++object_index]; } apr_file_printf(fp, "\n"); fclose(fp); } void undo_find_local_contact_point(LLVector3 &contact, const LLVector3& surface_norm, const LLQuaternion& rot, const LLVector3& scale ) { LLVector3 local_norm = surface_norm; local_norm.rotVec( ~rot ); LLVector3 v[6]; v[0].mV[VX] = -1.f; v[1].mV[VX] = 1.f; v[2].mV[VY] = -1.f; v[3].mV[VY] = 1.f; v[4].mV[VZ] = -1.f; v[5].mV[VZ] = 1.f; contact = v[0]; F32 cur_val = 0; for( S32 i = 0; i < 6; i++ ) { F32 val = v[i] * local_norm; if( val < cur_val ) { contact = v[i]; cur_val = val; } } contact.mV[VX] *= 0.5f * scale.mV[VX]; contact.mV[VY] *= 0.5f * scale.mV[VY]; contact.mV[VZ] *= 0.5f * scale.mV[VZ]; contact.rotVec( rot ); } void force_import_geometry(void*) { LLFilePicker& picker = LLFilePicker::instance(); if (!picker.getOpenFile(LLFilePicker::FFLOAD_GEOMETRY)) { llinfos << "Couldn't import objects from file" << llendl; return; } char directory[LL_MAX_PATH]; /* Flawfinder: ignore */ strncpy(directory, picker.getFirstFile(), LL_MAX_PATH -1); /* Flawfinder: ignore */ directory[LL_MAX_PATH -1] = '\0'; llinfos << "Loading LSG file " << directory << llendl; LLXmlTree *xmlparser = new LLXmlTree(); xmlparser->parseFile(directory, TRUE); LLXmlTreeNode *root = xmlparser->getRoot(); if( !root ) { return; } // header if( !root->hasName( "LindenGeometry" ) ) { llwarns << "Invalid LindenGeometry file header: " << directory << llendl; return; } // objects for (LLXmlTreeNode *child = root->getChildByName( "Object" ); child; child = root->getNextNamedChild()) { // get object data // *NOTE: This buffer size is hard coded into scanf() below. char name[255]; /* Flawfinder: ignore */ // Shape char description[255]; /* Flawfinder: ignore */ // Description U32 material; // Material F32 sx, sy, sz; // Scale LLVector3 scale; F32 ox, oy, oz; // Offset LLVector3 offset; F32 rx, ry, rz, rs; // Orientation LLQuaternion rot; U32 curve; F32 begin; F32 end; F32 hollow; F32 twist; F32 scx, scy; F32 shx, shy; F32 twist_begin; F32 radius_offset; F32 tx, ty; F32 revolutions; F32 skew; S32 faces; U32 pcode; U32 flags = FLAGS_CREATE_SELECTED; LLString attribute; S32 count = 0; child->getAttributeString("PCode", &attribute); pcode = atoi(attribute.c_str()); child->getAttributeString("Shape", &attribute); sscanf( /* Flawfinder: ignore */ attribute.c_str(), "%254s", name); child->getAttributeString("Description", &attribute); sscanf( /* Flawfinder: ignore */ attribute.c_str(), "%254s", description); child->getAttributeString("Material", &attribute); material = atoi(attribute.c_str()); child->getAttributeString("Scale", &attribute); sscanf(attribute.c_str(), "%f %f %f", &sx, &sy, &sz); scale.setVec(sx, sy, sz); child->getAttributeString("Offset", &attribute); sscanf(attribute.c_str(), "%f %f %f", &ox, &oy, &oz); offset.setVec(ox, oy, oz); child->getAttributeString("Orientation", &attribute); sscanf(attribute.c_str(), "%f %f %f %f", &rx, &ry, &rz, &rs); rot.mQ[VX] = rx; rot.mQ[VY] = ry; rot.mQ[VZ] = rz; rot.mQ[VS] = rs; child->getAttributeString("ShapeProfile", &attribute); sscanf(attribute.c_str(), "%d %f %f %f", &curve, &begin, &end, &hollow); LLProfileParams pparams(curve, begin, end, hollow); child->getAttributeString("ShapePath", &attribute); sscanf(attribute.c_str(), "%d %f %f %f %f %f %f %f %f %f %f %f %f %f", &curve, &begin, &end, &twist, &twist_begin, &scx, &scy, &shx, ­, &radius_offset, &tx, &ty, &revolutions, &skew); LLPathParams paparams(curve, begin, end, scx, scy, shx, shy, twist, twist_begin, radius_offset, tx, ty, revolutions, skew); child->getAttributeString("NumberOfFaces", &attribute); faces = atoi(attribute.c_str()); gMessageSystem->newMessageFast(_PREHASH_ObjectAdd); gMessageSystem->nextBlockFast(_PREHASH_AgentData); gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); gMessageSystem->addUUIDFast(_PREHASH_GroupID, gAgent.getGroupID()); gMessageSystem->nextBlockFast(_PREHASH_ObjectData); gMessageSystem->addU8Fast(_PREHASH_PCode, pcode); gMessageSystem->addU8Fast(_PREHASH_Material, material); gMessageSystem->addU32Fast(_PREHASH_AddFlags, flags ); pparams.packMessage(gMessageSystem); paparams.packMessage(gMessageSystem); LLVector3 forward; forward.setVec(3.f, 0.f, 1.f); forward = forward * gAgent.getQuat(); LLVector3 start = gAgent.getPositionAgent() + forward; start += offset; // offset position to make up for error introduced by placement code LLVector3 normal(0.f, 0.f, 1.f); LLVector3 delta; undo_find_local_contact_point(delta, normal, rot, scale); start += delta; gMessageSystem->addVector3Fast(_PREHASH_Scale, scale ); gMessageSystem->addQuatFast(_PREHASH_Rotation, rot ); gMessageSystem->addVector3Fast(_PREHASH_RayStart, start ); gMessageSystem->addVector3Fast(_PREHASH_RayEnd, start ); gMessageSystem->addBOOLFast(_PREHASH_BypassRaycast, TRUE ); gMessageSystem->addBOOLFast(_PREHASH_RayEndIsIntersection, FALSE ); U8 state = 0; gMessageSystem->addU8Fast(_PREHASH_State, state); LLUUID ray_target_id; gMessageSystem->addUUIDFast(_PREHASH_RayTargetID, ray_target_id ); /* Setting TE info through ObjectAdd is no longer supported. LLPrimitive temp_primitive; temp_primitive.setNumTEs(faces); for (LLXmlTreeNode *face = child->getChildByName( "Face" ); face; face = child->getNextNamedChild()) { // read the faces U32 facenumber; LLColor4 color; // *NOTE: This buffer size is hard coded into scanf() below. char texture[UUID_STR_LENGTH]; LLUUID texid; texid.toString(texture); F32 sx, sy, ox, oy, rot; U8 bump; LLTextureEntry te; face->getAttributeString("FaceColor", &attribute); sscanf(attribute, "%d %f %f %f %f", &facenumber, &color.mV[VX], &color.mV[VY], &color.mV[VZ], &color.mV[VW]); face->getAttributeString("Face", &attribute); sscanf(attribute, "%d %f %f %f %f %f %d %36s", &facenumber, &sx, &sy, &ox, &oy, &rot, &bump, texture); texid.set(texture); te.setColor(color); te.setBumpShinyFullbright(bump); te.setID(texid); te.setRotation(rot); te.setOffset(ox, oy); te.setScale(sx, sy); temp_primitive.setTE(facenumber, te); } temp_primitive.packTEMessage(gMessageSystem); */ gMessageSystem->sendReliable(gAgent.getRegionHost()); } } #endif void handle_take() { // we want to use the folder this was derezzed from if it's // available. Otherwise, derez to the normal place. if(gSelectMgr->getSelection()->isEmpty()) return; LLSelectNode* node = NULL; LLViewerObject* object = NULL; BOOL you_own_everything = TRUE; BOOL locked_but_takeable_object = FALSE; LLUUID category_id; for(node = gSelectMgr->getSelection()->getFirstRootNode(); node != NULL; node = gSelectMgr->getSelection()->getNextRootNode()) { object = node->getObject(); if(object) { if(!object->permYouOwner()) { you_own_everything = FALSE; } if(!object->permMove()) { locked_but_takeable_object = TRUE; } } if(node->mFolderID.notNull()) { if(category_id.isNull()) { category_id = node->mFolderID; } else if(category_id != node->mFolderID) { // we have found two potential destinations. break out // now and send to the default location. category_id.setNull(); break; } } } if(category_id.notNull()) { // there is an unambiguous destination. See if this agent has // such a location and it is not in the trash or library if(!gInventory.getCategory(category_id)) { // nope, set to NULL. category_id.setNull(); } if(category_id.notNull()) { // check trash LLUUID trash; trash = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH); if(category_id == trash || gInventory.isObjectDescendentOf(category_id, trash)) { category_id.setNull(); } // check library if(gInventory.isObjectDescendentOf(category_id, gInventoryLibraryRoot)) { category_id.setNull(); } } } if(category_id.isNull()) { category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT); } LLUUID* cat_id = new LLUUID(category_id); if(locked_but_takeable_object || !you_own_everything) { if(locked_but_takeable_object && you_own_everything) { gViewerWindow->alertXml("ConfirmObjectTakeLock", confirm_take, (void*)cat_id); } else if(!locked_but_takeable_object && !you_own_everything) { gViewerWindow->alertXml("ConfirmObjectTakeNoOwn", confirm_take, (void*)cat_id); } else { gViewerWindow->alertXml("ConfirmObjectTakeLockNoOwn", confirm_take, (void*)cat_id); } } else { confirm_take(0, (void*)cat_id); } } void confirm_take(S32 option, void* data) { LLUUID* cat_id = (LLUUID*)data; if(!cat_id) return; if(enable_take() && (option == 0)) { derez_objects(DRD_TAKE_INTO_AGENT_INVENTORY, *cat_id); } delete cat_id; } // You can take an item when it is public and transferrable, or when // you own it. We err on the side of enabling the item when at least // one item selected can be copied to inventory. BOOL enable_take() { if (sitting_on_selection()) { return FALSE; } LLViewerObject* object = NULL; for(LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); node != NULL; node = gSelectMgr->getSelection()->getNextRootNode()) { object = node->getObject(); if(!object || !node->mValid) continue; if (object->isAvatar()) { // ...don't acquire avatars continue; } #ifdef HACKED_GODLIKE_VIEWER return TRUE; #else # ifdef TOGGLE_HACKED_GODLIKE_VIEWER if (!gInProductionGrid && gAgent.isGodlike()) { return TRUE; } # endif if((node->mPermissions->allowTransferTo(gAgent.getID()) && object->permModify()) || (node->mPermissions->getOwner() == gAgent.getID())) { return TRUE; } #endif } return FALSE; } class LLToolsBuyOrTake : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gSelectMgr->getSelection()->isEmpty()) { return true; } if (is_selection_buy_not_take()) { S32 total_price = selection_price(); if (total_price <= gStatusBar->getBalance() || total_price == 0) { handle_buy(NULL); } else { LLFloaterBuyCurrency::buyCurrency( "Buying this costs", total_price); } } else { handle_take(); } return true; } }; class LLToolsEnableBuyOrTake : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool is_buy = is_selection_buy_not_take(); bool new_value = is_buy ? enable_buy(NULL) : enable_take(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); // Update label LLString label; LLString buy_text; LLString take_text; LLString param = userdata["data"].asString(); LLString::size_type offset = param.find(","); if (offset != param.npos) { buy_text = param.substr(0, offset); take_text = param.substr(offset+1); } if (is_buy) { label = buy_text; } else { label = take_text; } gMenuHolder->childSetText("Pie Object Take", label); gMenuHolder->childSetText("Menu Object Take", label); return true; } }; // This is a small helper function to determine if we have a buy or a // take in the selection. This method is to help with the aliasing // problems of putting buy and take in the same pie menu space. After // a fair amont of discussion, it was determined to prefer buy over // take. The reasoning follows from the fact that when users walk up // to buy something, they will click on one or more items. Thus, if // anything is for sale, it becomes a buy operation, and the server // will group all of the buy items, and copyable/modifiable items into // one package and give the end user as much as the permissions will // allow. If the user wanted to take something, they will select fewer // and fewer items until only 'takeable' items are left. The one // exception is if you own everything in the selection that is for // sale, in this case, you can't buy stuff from yourself, so you can // take it. // return value = TRUE if selection is a 'buy'. // FALSE if selection is a 'take' BOOL is_selection_buy_not_take() { LLViewerObject* obj = NULL; for(LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); node != NULL; node = gSelectMgr->getSelection()->getNextRootNode()) { obj = node->getObject(); if(obj && !(obj->permYouOwner()) && (node->mSaleInfo.isForSale())) { // you do not own the object and it is for sale, thus, // it's a buy return TRUE; } } return FALSE; } S32 selection_price() { LLViewerObject* obj = NULL; S32 total_price = 0; for(LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); node != NULL; node = gSelectMgr->getSelection()->getNextRootNode()) { obj = node->getObject(); if(obj && !(obj->permYouOwner()) && (node->mSaleInfo.isForSale())) { // you do not own the object and it is for sale. // Add its price. total_price += node->mSaleInfo.getSalePrice(); } } return total_price; } void callback_show_buy_currency(S32 option, void*) { if (0 == option) { llinfos << "Loading page " << BUY_CURRENCY_URL << llendl; LLWeb::loadURL(BUY_CURRENCY_URL); } } void show_buy_currency(const char* extra) { // Don't show currency web page for branded clients. std::ostringstream mesg; if (extra != NULL) { mesg << extra << "\n \n"; } mesg << "Go to " << BUY_CURRENCY_URL << "\nfor information on purchasing currency?"; LLString::format_map_t args; if (extra != NULL) { args["[EXTRA]"] = extra; } args["[URL]"] = BUY_CURRENCY_URL; gViewerWindow->alertXml("PromptGoToCurrencyPage", args, callback_show_buy_currency); } void handle_buy_currency(void*) { // LLFloaterBuyCurrency::buyCurrency(); } void handle_buy(void*) { if (gSelectMgr->getSelection()->isEmpty()) return; LLSaleInfo sale_info; BOOL valid = gSelectMgr->selectGetSaleInfo(sale_info); if (!valid) return; if (sale_info.getSaleType() == LLSaleInfo::FS_CONTENTS) { handle_buy_contents(sale_info); } else { handle_buy_object(sale_info); } } class LLObjectBuy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { handle_buy(NULL); return true; } }; BOOL sitting_on_selection() { LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if (!node) { return FALSE; } if (!node->mValid) { return FALSE; } LLViewerObject* root_object = node->getObject(); if (!root_object) { return FALSE; } // Need to determine if avatar is sitting on this object LLVOAvatar* avatar = gAgent.getAvatarObject(); if (!avatar) { return FALSE; } return (avatar->mIsSitting && avatar->getRoot() == root_object); } class LLToolsSaveToInventory : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if(enable_save_into_inventory(NULL)) { derez_objects(DRD_SAVE_INTO_AGENT_INVENTORY, LLUUID::null); } return true; } }; class LLToolsSaveToObjectInventory : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if(gSelectMgr) { LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if(node && (node->mValid) && (!node->mFromTaskID.isNull())) { // *TODO: check to see if the fromtaskid object exists. derez_objects(DRD_SAVE_INTO_TASK_INVENTORY, node->mFromTaskID); } } return true; } }; // Round the position of all root objects to the grid class LLToolsSnapObjectXY : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { F64 snap_size = (F64)gSavedSettings.getF32("GridResolution"); LLViewerObject* obj; LLObjectSelectionHandle selection = gSelectMgr->getSelection(); for (obj = selection->getFirstRootObject(); obj != NULL; obj = selection->getNextRootObject()) { if (obj->permModify()) { LLVector3d pos_global = obj->getPositionGlobal(); F64 round_x = fmod(pos_global.mdV[VX], snap_size); if (round_x < snap_size * 0.5) { // closer to round down pos_global.mdV[VX] -= round_x; } else { // closer to round up pos_global.mdV[VX] -= round_x; pos_global.mdV[VX] += snap_size; } F64 round_y = fmod(pos_global.mdV[VY], snap_size); if (round_y < snap_size * 0.5) { pos_global.mdV[VY] -= round_y; } else { pos_global.mdV[VY] -= round_y; pos_global.mdV[VY] += snap_size; } obj->setPositionGlobal(pos_global, FALSE); } } gSelectMgr->sendMultipleUpdate(UPD_POSITION); return true; } }; // in order to link, all objects must have the same owner, and the // agent must have the ability to modify all of the objects. However, // we're not answering that question with this method. The question // we're answering is: does the user have a reasonable expectation // that a link operation should work? If so, return true, false // otherwise. this allows the handle_link method to more finely check // the selection and give an error message when the uer has a // reasonable expectation for the link to work, but it will fail. class LLToolsEnableLink : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = false; // check if there are at least 2 objects selected, and that the // user can modify at least one of the selected objects. // in component mode, can't link if (!gSavedSettings.getBOOL("EditLinkedParts")) { if(gSelectMgr->selectGetAllRootsValid() && gSelectMgr->getSelection()->getRootObjectCount() >= 2) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); for(LLViewerObject* object = selection->getFirstRootObject(); object != NULL; object = selection->getNextRootObject()) { if(object->permModify()) { new_value = true; break; } } } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLToolsLink : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if(!gSelectMgr->selectGetAllRootsValid()) { LLNotifyBox::showXml("UnableToLinkWhileDownloading"); return true; } S32 object_count = gSelectMgr->getSelection()->getObjectCount(); if (object_count > MAX_CHILDREN_PER_TASK + 1) { LLStringBase::format_map_t args; args["[COUNT]"] = llformat("%d", object_count); int max = MAX_CHILDREN_PER_TASK+1; args["[MAX]"] = llformat("%d", max); gViewerWindow->alertXml("UnableToLinkObjects", args); return true; } if(gSelectMgr->getSelection()->getRootObjectCount() < 2) { gViewerWindow->alertXml("CannotLinkIncompleteSet"); return true; } if(!gSelectMgr->selectGetRootsModify()) { gViewerWindow->alertXml("CannotLinkModify"); return true; } LLUUID owner_id; LLString owner_name; if(!gSelectMgr->selectGetOwner(owner_id, owner_name)) { // we don't actually care if you're the owner, but novices are // the most likely to be stumped by this one, so offer the // easiest and most likely solution. gViewerWindow->alertXml("CannotLinkDifferentOwners"); return true; } gSelectMgr->sendLink(); return true; } }; class LLToolsEnableUnlink : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gSelectMgr->selectGetAllRootsValid() && gSelectMgr->getSelection()->getFirstEditableObject() && !gSelectMgr->getSelection()->getFirstEditableObject()->isAttachment(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLToolsUnlink : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gSelectMgr->sendDelink(); return true; } }; class LLToolsStopAllAnimations : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatarp = gAgent.getAvatarObject(); if (!avatarp) return true; avatarp->deactivateAllMotions(); avatarp->processAnimationStateChanges(); return true; } }; //void handle_hinge(void*) //{ // gSelectMgr->sendHinge(1); //} //void handle_ptop(void*) //{ // gSelectMgr->sendHinge(2); //} //void handle_lptop(void*) //{ // gSelectMgr->sendHinge(3); //} //void handle_wheel(void*) //{ // gSelectMgr->sendHinge(4); //} //void handle_dehinge(void*) //{ // gSelectMgr->sendDehinge(); //} //BOOL enable_dehinge(void*) //{ // LLViewerObject* obj = gSelectMgr->getSelection()->getFirstEditableObject(); // return obj && !obj->isAttachment(); //} class LLEditEnableCut : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canCut(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditCut : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler ) { gEditMenuHandler->cut(); } return true; } }; class LLEditEnableCopy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canCopy(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditCopy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler ) { gEditMenuHandler->copy(); } return true; } }; class LLEditEnablePaste : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canPaste(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditPaste : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler ) { gEditMenuHandler->paste(); } return true; } }; class LLEditEnableDelete : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canDoDelete(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditDelete : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // If a text field can do a deletion, it gets precedence over deleting // an object in the world. if( gEditMenuHandler && gEditMenuHandler->canDoDelete()) { gEditMenuHandler->doDelete(); } // and close any pie/context menus when done gMenuHolder->hideMenus(); // When deleting an object we may not actually be done // Keep selection so we know what to delete when confirmation is needed about the delete gPieObject->hide(TRUE); return true; } }; class LLObjectEnableDelete : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = #ifdef HACKED_GODLIKE_VIEWER TRUE; #else # ifdef TOGGLE_HACKED_GODLIKE_VIEWER (!gInProductionGrid && gAgent.isGodlike()) || # endif (gSelectMgr && gSelectMgr->canDoDelete()); #endif gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditSearch : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLFloaterDirectory::toggleFind(NULL); return true; } }; class LLObjectDelete : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gSelectMgr) { gSelectMgr->doDelete(); } // and close any pie/context menus when done gMenuHolder->hideMenus(); // When deleting an object we may not actually be done // Keep selection so we know what to delete when confirmation is needed about the delete gPieObject->hide(TRUE); return true; } }; void handle_force_delete(void*) { gSelectMgr->selectForceDelete(); } class LLViewEnableLastChatter : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // *TODO: add check that last chatter is in range bool new_value = (gAgent.cameraThirdPerson() && gAgent.getLastChatter().notNull()); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditEnableDeselect : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canDeselect(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditDeselect : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler ) { gEditMenuHandler->deselect(); } return true; } }; class LLEditEnableSelectAll : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canSelectAll(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditSelectAll : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler ) { gEditMenuHandler->selectAll(); } return true; } }; class LLEditEnableUndo : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canUndo(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditUndo : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler && gEditMenuHandler->canUndo() ) { gEditMenuHandler->undo(); } return true; } }; class LLEditEnableRedo : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gEditMenuHandler && gEditMenuHandler->canRedo(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditRedo : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if( gEditMenuHandler && gEditMenuHandler->canRedo() ) { gEditMenuHandler->redo(); } return true; } }; void print_object_info(void*) { gSelectMgr->selectionDump(); } void show_debug_menus() { // this can get called at login screen where there is no menu so only toggle it if one exists if ( gMenuBarView ) { BOOL debug = gSavedSettings.getBOOL("UseDebugMenus"); if(debug) { LLFirstUse::useDebugMenus(); } gMenuBarView->setItemVisible(CLIENT_MENU_NAME, debug); gMenuBarView->setItemEnabled(CLIENT_MENU_NAME, debug); gMenuBarView->setItemVisible(SERVER_MENU_NAME, debug); gMenuBarView->setItemEnabled(SERVER_MENU_NAME, debug); //gMenuBarView->setItemVisible(LLString("DebugOptions"), visible); //gMenuBarView->setItemVisible(LLString(AVI_TOOLS), visible); }; } void toggle_debug_menus(void*) { BOOL visible = ! gSavedSettings.getBOOL("UseDebugMenus"); gSavedSettings.setBOOL("UseDebugMenus", visible); show_debug_menus(); } void toggle_map( void* user_data ) { // Toggle the item BOOL checked = gSavedSettings.getBOOL( static_cast(user_data) ); gSavedSettings.setBOOL( static_cast(user_data), !checked ); if (checked) { gFloaterMap->close(); } else { gFloaterMap->open(); /* Flawfinder: ignore */ } } LLUUID gExporterRequestID; LLString gExportDirectory; LLUploadDialog *gExportDialog = NULL; void handle_export_selected( void * ) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); if (selection->isEmpty()) { return; } llinfos << "Exporting selected objects:" << llendl; LLViewerObject *object = selection->getFirstRootObject(); gExporterRequestID.generate(); gExportDirectory = ""; LLMessageSystem* msg = gMessageSystem; msg->newMessageFast(_PREHASH_ObjectExportSelected); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_RequestID, gExporterRequestID); msg->addS16Fast(_PREHASH_VolumeDetail, 4); for (; object != NULL; object = selection->getNextRootObject()) { msg->nextBlockFast(_PREHASH_ObjectData); msg->addUUIDFast(_PREHASH_ObjectID, object->getID()); llinfos << "Object: " << object->getID() << llendl; } msg->sendReliable(gAgent.getRegion()->getHost()); gExportDialog = LLUploadDialog::modalUploadDialog("Exporting selected objects..."); } BOOL menu_check_build_tool( void* user_data ) { S32 index = (intptr_t) user_data; return gToolMgr->getCurrentToolset()->isToolSelected( index ); } void handle_reload_settings(void*) { gSavedSettings.resetToDefaults(); gSavedSettings.loadFromFile(gSettingsFileName, TRUE); llinfos << "Loading colors from colors.xml" << llendl; std::string color_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"colors.xml"); gColors.resetToDefaults(); gColors.loadFromFile(color_file, FALSE, TYPE_COL4U); } class LLWorldSetHomeLocation : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // we just send the message and let the server check for failure cases // server will echo back a "Home position set." alert if it succeeds // and the home location screencapture happens when that alert is recieved gAgent.setStartPosition(START_LOCATION_ID_HOME); return true; } }; class LLWorldTeleportHome : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gAgent.teleportHome(); return true; } }; class LLWorldAlwaysRun : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gAgent.getAlwaysRun()) { gAgent.clearAlwaysRun(); } else { gAgent.setAlwaysRun(); } LLMessageSystem *msg = gMessageSystem; msg->newMessageFast(_PREHASH_SetAlwaysRun); msg->nextBlockFast(_PREHASH_AgentData); msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID()); msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); msg->addBOOLFast(_PREHASH_AlwaysRun, gAgent.getAlwaysRun() ); gAgent.sendReliableMessage(); return true; } }; class LLWorldCheckAlwaysRun : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.getAlwaysRun(); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLWorldSetAway : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gAgent.getAFK()) { gAgent.clearAFK(); } else { gAgent.setAFK(); } return true; } }; class LLWorldSetBusy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gAgent.getBusy()) { gAgent.clearBusy(); } else { gAgent.setBusy(); gViewerWindow->alertXml("BusyModeSet"); } return true; } }; class LLWorldCreateLandmark : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerRegion* agent_region = gAgent.getRegion(); if(!agent_region) { llwarns << "No agent region" << llendl; return true; } LLParcel* agent_parcel = gParcelMgr->getAgentParcel(); if (!agent_parcel) { llwarns << "No agent parcel" << llendl; return true; } if (!agent_parcel->getAllowLandmark() && !LLViewerParcelMgr::isParcelOwnedByAgent(agent_parcel, GP_LAND_ALLOW_LANDMARK)) { gViewerWindow->alertXml("CannotCreateLandmarkNotOwner"); return true; } LLUUID folder_id; folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK); std::string pos_string; gAgent.buildLocationString(pos_string); create_inventory_item(gAgent.getID(), gAgent.getSessionID(), folder_id, LLTransactionID::tnull, pos_string, pos_string, // name, desc LLAssetType::AT_LANDMARK, LLInventoryType::IT_LANDMARK, NOT_WEARABLE, PERM_ALL, NULL); return true; } }; class LLToolsLookAtSelection : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { const F32 PADDING_FACTOR = 2.f; BOOL zoom = (userdata.asString() == "zoom"); if (!gSelectMgr->getSelection()->isEmpty()) { gAgent.setFocusOnAvatar(FALSE, ANIMATE); LLBBox selection_bbox = gSelectMgr->getBBoxOfSelection(); F32 angle_of_view = llmax(0.1f, gCamera->getAspect() > 1.f ? gCamera->getView() * gCamera->getAspect() : gCamera->getView()); F32 distance = selection_bbox.getExtentLocal().magVec() * PADDING_FACTOR / atan(angle_of_view); LLVector3 obj_to_cam = gCamera->getOrigin() - selection_bbox.getCenterAgent(); obj_to_cam.normVec(); if (zoom) { gAgent.setCameraPosAndFocusGlobal(gSelectMgr->getSelectionCenterGlobal() + LLVector3d(obj_to_cam * distance), gSelectMgr->getSelectionCenterGlobal(), gSelectMgr->getSelection()->getFirstObject()->mID ); } else { gAgent.setFocusGlobal( gSelectMgr->getSelectionCenterGlobal(), gSelectMgr->getSelection()->getFirstObject()->mID ); } } return true; } }; void callback_invite_to_group(LLUUID group_id, void *user_data) { std::vector agent_ids; agent_ids.push_back(*(LLUUID *)user_data); LLFloaterGroupInvite::showForGroup(group_id, &agent_ids); } void invite_to_group(const LLUUID& dest_id) { LLViewerObject* dest = gObjectList.findObject(dest_id); if(dest && dest->isAvatar()) { LLFloaterGroupPicker* widget; widget = LLFloaterGroupPicker::showInstance(LLSD(gAgent.getID())); if (widget) { widget->center(); widget->setPowersMask(GP_MEMBER_INVITE); widget->setSelectCallback(callback_invite_to_group, (void *)&dest_id); } } } class LLAvatarInviteToGroup : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if(avatar) { invite_to_group(avatar->getID()); } return true; } }; class LLAvatarAddFriend : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if(avatar && !is_agent_friend(avatar->getID())) { request_friendship(avatar->getID()); } return true; } }; void complete_give_money(S32 option, void* user_data) { if (option == 0) { gAgent.clearBusy(); } LLObjectSelectionHandle handle(*(LLObjectSelectionHandle*)user_data); delete (LLObjectSelectionHandle*)user_data; LLViewerObject* objectp = handle->getPrimaryObject(); // Show avatar's name if paying attachment if (objectp && objectp->isAttachment()) { while (objectp && !objectp->isAvatar()) { objectp = (LLViewerObject*)objectp->getParent(); } } if (objectp) { if (objectp->isAvatar()) { const BOOL is_group = FALSE; LLFloaterPay::payDirectly(&give_money, objectp->getID(), is_group); } else { LLFloaterPay::payViaObject(&give_money, objectp->getID()); } } } bool handle_give_money_dialog() { LLObjectSelectionHandle* handlep = new LLObjectSelectionHandle(gSelectMgr->getSelection()); if (gAgent.getBusy()) { // warn users of being in busy mode during a transaction gViewerWindow->alertXml("BusyModePay", complete_give_money, handlep); } else { complete_give_money(1, handlep); } return true; } class LLPayObject : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return handle_give_money_dialog(); } }; class LLEnablePayObject : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object(gViewerWindow->lastObjectHit()); bool new_value = (avatar != NULL); if (!new_value) { LLViewerObject* object = gViewerWindow->lastObjectHit(); if( object ) { LLViewerObject *parent = (LLViewerObject *)object->getParent(); if((object->flagTakesMoney()) || (parent && parent->flagTakesMoney())) { new_value = true; } } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLObjectEnableSitOrStand : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = false; LLViewerObject* dest_object = NULL; if((dest_object = gObjectList.findObject(gLastHitObjectID))) { if(dest_object->getPCode() == LL_PCODE_VOLUME) { new_value = true; } } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); // Update label LLString label; LLString sit_text; LLString stand_text; LLString param = userdata["data"].asString(); LLString::size_type offset = param.find(","); if (offset != param.npos) { sit_text = param.substr(0, offset); stand_text = param.substr(offset+1); } if (sitting_on_selection()) { label = stand_text; } else { LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if (node && node->mValid && !node->mSitName.empty()) { label.assign(node->mSitName); } else { label = sit_text; } } gMenuHolder->childSetText("Object Sit", label); return true; } }; void edit_ui(void*) { LLFloater::setEditModeEnabled(!LLFloater::getEditModeEnabled()); } void dump_select_mgr(void*) { gSelectMgr->dump(); } void dump_volume_mgr(void*) { gVolumeMgr->dump(); } void dump_inventory(void*) { gInventory.dumpInventory(); } // forcibly unlock an object void handle_force_unlock(void*) { // First, make it public. gSelectMgr->sendOwner(LLUUID::null, LLUUID::null, TRUE); // Second, lie to the viewer and mark it editable and unowned LLViewerObject* object; for (object = gSelectMgr->getSelection()->getFirstObject(); object; object = gSelectMgr->getSelection()->getNextObject() ) { object->mFlags |= FLAGS_OBJECT_MOVE; object->mFlags |= FLAGS_OBJECT_MODIFY; object->mFlags |= FLAGS_OBJECT_COPY; object->mFlags &= ~FLAGS_OBJECT_ANY_OWNER; object->mFlags &= ~FLAGS_OBJECT_YOU_OWNER; } } // Fullscreen debug stuff void handle_fullscreen_debug(void*) { llinfos << "Width " << gViewerWindow->getWindowWidth() << " Height " << gViewerWindow->getWindowHeight() << llendl; llinfos << "mouse_x_from_center(100) " << mouse_x_from_center(100) << " y " << mouse_y_from_center(100) << llendl; } void handle_crash(void*) { llerrs << "This is an llerror" << llendl; } class LLWorldForceSun : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString tod = userdata.asString(); LLVector3 sun_direction; if (tod == "sunrise") { sun_direction.setVec(1.0f, 0.f, 0.2f); } else if (tod == "noon") { sun_direction.setVec(0.0f, 0.3f, 1.0f); } else if (tod == "sunset") { sun_direction.setVec(-1.0f, 0.f, 0.2f); } else if (tod == "midnight") { sun_direction.setVec(0.0f, 0.3f, -1.0f); } else { gSky.setOverrideSun(FALSE); return true; } sun_direction.normVec(); gSky.setOverrideSun(TRUE); gSky.setSunDirection( sun_direction, LLVector3(0.f, 0.f, 0.f)); return true; } }; void handle_dump_followcam(void*) { LLFollowCamMgr::dump(); } BOOL check_flycam(void*) { return LLViewerJoystick::sOverrideCamera; } void handle_toggle_flycam(void*) { LLViewerJoystick::sOverrideCamera = !LLViewerJoystick::sOverrideCamera; if (LLViewerJoystick::sOverrideCamera) { LLViewerJoystick::updateCamera(TRUE); LLFloaterJoystick::show(NULL); } } void handle_viewer_enable_message_log(void*) { gMessageSystem->startLogging(); } void handle_viewer_disable_message_log(void*) { gMessageSystem->stopLogging(); } // TomY TODO: Move! class LLShowFloater : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString floater_name = userdata.asString(); if (floater_name == "gestures") { LLFloaterGesture::toggleVisibility(); } else if (floater_name == "appearance") { if (gAgent.getWearablesLoaded()) { gAgent.changeCameraToCustomizeAvatar(); } } else if (floater_name == "friends") { LLFloaterMyFriends::toggleInstance(0); } else if (floater_name == "preferences") { LLFloaterPreference::show(NULL); } else if (floater_name == "toolbar") { LLToolBar::toggle(NULL); } else if (floater_name == "chat history") { LLFloaterChat::toggleInstance(LLSD()); } else if (floater_name == "im") { LLFloaterChatterBox::toggleInstance(LLSD()); } else if (floater_name == "inventory") { LLInventoryView::toggleVisibility(NULL); } else if (floater_name == "mute list") { LLFloaterMute::toggle(NULL); } else if (floater_name == "camera controls") { LLFloaterCamera::toggle(NULL); } else if (floater_name == "movement controls") { LLFloaterMove::show(NULL); } else if (floater_name == "world map") { LLFloaterWorldMap::toggle(NULL); } else if (floater_name == "mini map") { LLFloaterMap::toggle(NULL); } else if (floater_name == "stat bar") { gDebugView->mStatViewp->setVisible(!gDebugView->mStatViewp->getVisible()); } else if (floater_name == "my land") { LLFloaterLandHoldings::show(NULL); } else if (floater_name == "about land") { if (gParcelMgr->selectionEmpty()) { gParcelMgr->selectParcelAt(gAgent.getPositionGlobal()); } LLFloaterLand::show(); } else if (floater_name == "buy land") { if (gParcelMgr->selectionEmpty()) { gParcelMgr->selectParcelAt(gAgent.getPositionGlobal()); } gParcelMgr->startBuyLand(); } else if (floater_name == "about region") { LLFloaterRegionInfo::show((void *)NULL); } else if (floater_name == "grid options") { LLFloaterBuildOptions::show(NULL); } else if (floater_name == "script errors") { LLFloaterScriptDebug::show(LLUUID::null); } else if (floater_name == "help f1") { #if LL_LIBXUL_ENABLED gViewerHtmlHelp.show(); #endif } else if (floater_name == "help in-world") { #if LL_LIBXUL_ENABLED LLFloaterHtml::getInstance()->show( "in-world_help" ); #endif } else if (floater_name == "help additional") { #if LL_LIBXUL_ENABLED LLFloaterHtml::getInstance()->show( "additional_help" ); #endif } else if (floater_name == "complaint reporter") { // Prevent menu from appearing in screen shot. gMenuHolder->hideMenus(); LLFloaterReporter::showFromMenu(COMPLAINT_REPORT); } else if (floater_name == "mean events") { if (!gNoRender) { LLFloaterBump::show(NULL); } } else if (floater_name == "bug reporter") { // Prevent menu from appearing in screen shot. gMenuHolder->hideMenus(); LLFloaterReporter::showFromMenu(BUG_REPORT); } else if (floater_name == "buy currency") { LLFloaterBuyCurrency::buyCurrency(); } else if (floater_name == "about") { LLFloaterAbout::show(NULL); } else if (floater_name == "active speakers") { LLFloaterActiveSpeakers::toggleInstance(LLSD()); } return true; } }; class LLFloaterVisible : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString control_name = userdata["control"].asString(); LLString floater_name = userdata["data"].asString(); bool new_value = false; if (floater_name == "friends") { new_value = LLFloaterMyFriends::instanceVisible(0); } else if (floater_name == "toolbar") { new_value = LLToolBar::visible(NULL); } else if (floater_name == "chat history") { new_value = LLFloaterChat::visible(NULL); } else if (floater_name == "im") { new_value = LLFloaterMyFriends::instanceVisible(0); } else if (floater_name == "mute list") { new_value = LLFloaterMute::visible(NULL); } else if (floater_name == "camera controls") { new_value = LLFloaterCamera::visible(NULL); } else if (floater_name == "movement controls") { new_value = LLFloaterMove::visible(NULL); } else if (floater_name == "stat bar") { new_value = gDebugView->mStatViewp->getVisible(); } else if (floater_name == "active speakers") { new_value = LLFloaterActiveSpeakers::instanceVisible(LLSD()); } gMenuHolder->findControl(control_name)->setValue(new_value); return true; } }; void callback_show_url(S32 option, void* url) { const char* urlp = (const char*)url; if (0 == option) { LLWeb::loadURL(urlp); } delete urlp; } class LLPromptShowURL : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString param = userdata.asString(); LLString::size_type offset = param.find(","); if (offset != param.npos) { LLString alert = param.substr(0, offset); LLString url = param.substr(offset+1); char *url_copy = new char[url.size()+1]; if (url_copy != NULL) { strcpy(url_copy, url.c_str()); /* Flawfinder: ignore */ } else { llerrs << "Memory Allocation Failed" << llendl; return false; } gViewerWindow->alertXml(alert, callback_show_url, url_copy); } else { llinfos << "PromptShowURL invalid parameters! Expecting \"ALERT,URL\"." << llendl; } return true; } }; void callback_show_file(S32 option, void* filename) { const char* filenamep = (const char*)filename; if (0 == option) { load_url_local_file(filenamep); } delete filenamep; } class LLPromptShowFile : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString param = userdata.asString(); LLString::size_type offset = param.find(","); if (offset != param.npos) { LLString alert = param.substr(0, offset); LLString file = param.substr(offset+1); char *file_copy = new char[file.size()+1]; if (file_copy != NULL) { strcpy(file_copy, file.c_str()); /* Flawfinder: ignore */ } else { llerrs << "Memory Allocation Failed" << llendl; return false; } gViewerWindow->alertXml(alert, callback_show_file, file_copy); } else { llinfos << "PromptShowFile invalid parameters! Expecting \"ALERT,FILE\"." << llendl; } return true; } }; class LLShowAgentProfile : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLUUID agent_id; if (userdata.asString() == "agent") { agent_id = gAgent.getID(); } else if (userdata.asString() == "hit object") { agent_id = gLastHitObjectID; } else { agent_id = userdata.asUUID(); } LLVOAvatar* avatar = find_avatar_from_object(agent_id); if (avatar) { LLFloaterAvatarInfo::showFromAvatar(avatar); } return true; } }; class LLShowAgentGroups : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLFloaterMyFriends::toggleInstance(1); return true; } }; void handle_focus(void *) { if (gDisconnected) { return; } if (gAgent.getFocusOnAvatar()) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gAgent.cameraZoomIn(0.666f); } else { gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); } gViewerWindow->moveCursorToCenter(); // Switch to camera toolset // gToolMgr->setCurrentToolset(gCameraToolset); gToolMgr->getCurrentToolset()->selectTool( gToolCamera ); } class LLLandEdit : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { if (gAgent.getFocusOnAvatar() && gSavedSettings.getBOOL("EditCameraMovement") ) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gAgent.cameraOrbitOver( F_PI * 0.25f ); gViewerWindow->moveCursorToCenter(); } else if ( gSavedSettings.getBOOL("EditCameraMovement") ) { gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gViewerWindow->moveCursorToCenter(); } gParcelMgr->selectParcelAt( gLastHitPosGlobal ); gFloaterTools->showMore(TRUE); gFloaterView->bringToFront( gFloaterTools ); // Switch to land edit toolset gToolMgr->getCurrentToolset()->selectTool( gToolParcel ); return true; } }; class LLWorldEnableBuyLand : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gParcelMgr->canAgentBuyParcel( gParcelMgr->selectionEmpty() ? gParcelMgr->getAgentParcel() : gParcelMgr->getParcelSelection()->getParcel(), false); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_buy_land(void*) { return gParcelMgr->canAgentBuyParcel( gParcelMgr->getParcelSelection()->getParcel(), false); } void handle_move(void*) { if (gAgent.getFocusOnAvatar()) { // zoom in if we're looking at the avatar gAgent.setFocusOnAvatar(FALSE, ANIMATE); gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); gAgent.cameraZoomIn(0.666f); } else { gAgent.setFocusGlobal(gLastHitPosGlobal + gLastHitObjectOffset, gLastHitObjectID); } gViewerWindow->moveCursorToCenter(); gToolMgr->setCurrentToolset(gBasicToolset); gToolMgr->getCurrentToolset()->selectTool( gToolGrab ); } class LLObjectAttachToAvatar : public view_listener_t { public: static void setObjectSelection(LLObjectSelectionHandle selection) { sObjectSelection = selection; } private: bool handleEvent(LLPointer event, const LLSD& userdata) { setObjectSelection(gSelectMgr->getSelection()); LLViewerObject* selectedObject = sObjectSelection->getFirstRootObject(); if (selectedObject) { S32 index = userdata.asInteger(); LLViewerJointAttachment* attachment_point = index > 0 ? gAgent.getAvatarObject()->mAttachmentPoints[index] : NULL; confirm_replace_attachment(0, attachment_point); } return true; } protected: static LLObjectSelectionHandle sObjectSelection; }; LLObjectSelectionHandle LLObjectAttachToAvatar::sObjectSelection; void near_attach_object(BOOL success, void *user_data) { if (success) { LLViewerJointAttachment *attachment = (LLViewerJointAttachment *)user_data; U8 attachment_id; if (attachment) { attachment_id = gAgent.getAvatarObject()->mAttachmentPoints.reverseLookup(attachment); } else { // interpret 0 as "default location" attachment_id = 0; } gSelectMgr->sendAttach(attachment_id); } LLObjectAttachToAvatar::setObjectSelection(NULL); } void confirm_replace_attachment(S32 option, void* user_data) { if (option == 0/*YES*/) { LLViewerObject* selectedObject = gSelectMgr->getSelection()->getFirstRootObject(); if (selectedObject) { const F32 MIN_STOP_DISTANCE = 1.f; // meters const F32 ARM_LENGTH = 0.5f; // meters const F32 SCALE_FUDGE = 1.5f; F32 stop_distance = SCALE_FUDGE * selectedObject->getMaxScale() + ARM_LENGTH; if (stop_distance < MIN_STOP_DISTANCE) { stop_distance = MIN_STOP_DISTANCE; } LLVector3 walkToSpot = selectedObject->getPositionAgent(); // make sure we stop in front of the object LLVector3 delta = walkToSpot - gAgent.getPositionAgent(); delta.normVec(); delta = delta * 0.5f; walkToSpot -= delta; gAgent.startAutoPilotGlobal(gAgent.getPosGlobalFromAgent(walkToSpot), "Attach", NULL, near_attach_object, user_data, stop_distance); gAgent.clearFocusObject(); } } } class LLAttachmentDrop : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // Called when the user clicked on an object attached to them // and selected "Drop". LLViewerObject *object = gViewerWindow->lastObjectHit(); if (!object) { llwarns << "handle_drop_attachment() - no object to drop" << llendl; return true; } LLViewerObject *parent = (LLViewerObject*)object->getParent(); while (parent) { if(parent->isAvatar()) { break; } object = parent; parent = (LLViewerObject*)parent->getParent(); } if (!object) { llwarns << "handle_detach() - no object to detach" << llendl; return true; } if (object->isAvatar()) { llwarns << "Trying to detach avatar from avatar." << llendl; return true; } // The sendDropAttachment() method works on the list of selected // objects. Thus we need to clear the list, make sure it only // contains the object the user clicked, send the message, // then clear the list. gSelectMgr->sendDropAttachment(); return true; } }; // called from avatar pie menu void handle_detach_from_avatar(void* user_data) { LLViewerJointAttachment *attachment = (LLViewerJointAttachment *)user_data; LLViewerObject* attached_object = attachment->getObject(); if (attached_object) { gMessageSystem->newMessage("ObjectDetach"); gMessageSystem->nextBlockFast(_PREHASH_AgentData); gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() ); gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); gMessageSystem->nextBlockFast(_PREHASH_ObjectData); gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, attached_object->getLocalID()); gMessageSystem->sendReliable( gAgent.getRegionHost() ); } } void attach_label(LLString& label, void* user_data) { LLViewerJointAttachment* attachmentp = (LLViewerJointAttachment*)user_data; if (attachmentp) { label = attachmentp->getName(); if (attachmentp->getObject()) { LLViewerInventoryItem* itemp = gInventory.getItem(attachmentp->getItemID()); if (itemp) { label += LLString(" (") + itemp->getName() + LLString(")"); } } } } void detach_label(LLString& label, void* user_data) { LLViewerJointAttachment* attachmentp = (LLViewerJointAttachment*)user_data; if (attachmentp) { label = attachmentp->getName(); if (attachmentp->getObject()) { LLViewerInventoryItem* itemp = gInventory.getItem(attachmentp->getItemID()); if (itemp) { label += LLString(" (") + itemp->getName() + LLString(")"); } } } } class LLAttachmentDetach : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // Called when the user clicked on an object attached to them // and selected "Detach". LLViewerObject *object = gViewerWindow->lastObjectHit(); if (!object) { llwarns << "handle_detach() - no object to detach" << llendl; return true; } LLViewerObject *parent = (LLViewerObject*)object->getParent(); while (parent) { if(parent->isAvatar()) { break; } object = parent; parent = (LLViewerObject*)parent->getParent(); } if (!object) { llwarns << "handle_detach() - no object to detach" << llendl; return true; } if (object->isAvatar()) { llwarns << "Trying to detach avatar from avatar." << llendl; return true; } // The sendDetach() method works on the list of selected // objects. Thus we need to clear the list, make sure it only // contains the object the user clicked, send the message, // then clear the list. // We use deselectAll to update the simulator's notion of what's // selected, and removeAll just to change things locally. //RN: I thought it was more useful to detach everything that was selected if (gSelectMgr->getSelection()->isAttachment()) { gSelectMgr->sendDetach(); } return true; } }; //Adding an observer for a Jira 2422 and needs to be a fetch observer //for Jira 3119 class LLWornItemFetchedObserver : public LLInventoryFetchObserver { public: LLWornItemFetchedObserver() {} virtual ~LLWornItemFetchedObserver() {} protected: virtual void done() { gPieAttachment->buildDrawLabels(); gInventory.removeObserver(this); delete this; } }; // You can only drop items on parcels where you can build. class LLAttachmentEnableDrop : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLParcel* parcel = gParcelMgr->getAgentParcel(); BOOL can_build = gAgent.isGodlike() || (parcel && parcel->getAllowModify()); //Add an inventory observer to only allow dropping the newly attached item //once it exists in your inventory. Look at Jira 2422. //-jwolk // A bug occurs when you wear/drop an item before it actively is added to your inventory // if this is the case (you're on a slow sim, etc.) a copy of the object, // well, a newly created object with the same properties, is placed // in your inventory. Therefore, we disable the drop option until the // item is in your inventory LLViewerObject* object = gViewerWindow->lastObjectHit(); LLViewerJointAttachment* attachment_pt = NULL; LLInventoryItem* item = NULL; if ( object ) { S32 attachmentID = ATTACHMENT_ID_FROM_STATE(object->getState()); attachment_pt = gAgent.getAvatarObject()->mAttachmentPoints.getIfThere(attachmentID); if ( attachment_pt ) { // make sure item is in your inventory (it could be a delayed attach message being sent from the sim) // so check to see if the item is in the inventory already item = gInventory.getItem(attachment_pt->getItemID()); if ( !item ) { // Item does not exist, make an observer to enable the pie menu // when the item finishes fetching worst case scenario // if a fetch is already out there (being sent from a slow sim) // we refetch and there are 2 fetches LLWornItemFetchedObserver* wornItemFetched = new LLWornItemFetchedObserver(); LLInventoryFetchObserver::item_ref_t items; //add item to the inventory item to be fetched items.push_back(attachment_pt->getItemID()); wornItemFetched->fetchItems(items); gInventory.addObserver(wornItemFetched); } } } //now check to make sure that the item is actually in the inventory before we enable dropping it bool new_value = enable_detach(NULL) && can_build && item; gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_detach(void*) { LLViewerObject* object = gViewerWindow->lastObjectHit(); if (!object) return FALSE; if (!object->isAttachment()) return FALSE; // Find the avatar who owns this attachment LLViewerObject* avatar = object; while (avatar) { // ...if it's you, good to detach if (avatar->getID() == gAgent.getID()) { return TRUE; } avatar = (LLViewerObject*)avatar->getParent(); } return FALSE; } class LLAttachmentEnableDetach : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = enable_detach(NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; // Used to tell if the selected object can be attached to your avatar. BOOL object_selected_and_point_valid(void *user_data) { //LLViewerJointAttachment *attachment = (LLViewerJointAttachment *)user_data; if (gSelectMgr == NULL) return FALSE; LLObjectSelectionHandle selection = gSelectMgr->getSelection(); for (LLViewerObject *object = selection->getFirstRootObject(); object; object = selection->getNextRootObject()) { for (U32 child_num = 0; child_num < object->mChildList.size(); child_num++ ) { if (object->mChildList[child_num]->isAvatar()) { return FALSE; } } } return (selection->getRootObjectCount() == 1) && (selection->getFirstRootObject()->getPCode() == LL_PCODE_VOLUME) && selection->getFirstRootObject()->permYouOwner() && !((LLViewerObject*)selection->getFirstRootObject()->getRoot())->isAvatar() && (selection->getFirstRootObject()->getNVPair("AssetContainer") == NULL); } // Also for seeing if object can be attached. See above. class LLObjectEnableWear : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { return object_selected_and_point_valid(NULL); } }; BOOL object_attached(void *user_data) { LLViewerJointAttachment *attachment = (LLViewerJointAttachment *)user_data; return attachment->getObject() != NULL; } class LLAvatarSendIM : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLVOAvatar* avatar = find_avatar_from_object( gViewerWindow->lastObjectHit() ); if(avatar) { LLString name("IM"); LLNameValue *first = avatar->getNVPair("FirstName"); LLNameValue *last = avatar->getNVPair("LastName"); if (first && last) { name.assign( first->getString() ); name.append(" "); name.append( last->getString() ); } gIMMgr->setFloaterOpen(TRUE); //EInstantMessage type = have_agent_callingcard(gLastHitObjectID) // ? IM_SESSION_ADD : IM_SESSION_CARDLESS_START; gIMMgr->addSession(name, IM_NOTHING_SPECIAL, avatar->getID()); } return true; } }; void handle_activate(void*) { } BOOL enable_activate(void*) { return FALSE; } class LLToolsSelectedScriptAction : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString action = userdata.asString(); LLFloaterScriptQueue *queue = NULL; if (action == "compile") { queue = LLFloaterCompileQueue::create(); } else if (action == "reset") { queue = LLFloaterResetQueue::create(); } else if (action == "start") { queue = LLFloaterRunQueue::create(); } else if (action == "stop") { queue = LLFloaterNotRunQueue::create(); } if (!queue) return true; BOOL scripted = FALSE; BOOL modifiable = FALSE; for(LLViewerObject* obj = gSelectMgr->getSelection()->getFirstObject(); obj; obj = gSelectMgr->getSelection()->getNextObject()) { scripted = obj->flagScripted(); modifiable = obj->permModify(); if( scripted && modifiable ) queue->addObject(obj->getID()); else break; } if(!queue->start()) { if ( ! scripted ) { gViewerWindow->alertXml("CannotRecompileSelectObjectsNoScripts"); } else if ( ! modifiable ) { gViewerWindow->alertXml("CannotRecompileSelectObjectsNoPermission"); } } return true; } }; void handle_reset_selection(void*) { LLFloaterResetQueue* queue = LLFloaterResetQueue::create(); BOOL scripted = FALSE; BOOL modifiable = FALSE; for(LLViewerObject* obj = gSelectMgr->getSelection()->getFirstObject(); obj; obj = gSelectMgr->getSelection()->getNextObject()) { scripted = obj->flagScripted(); modifiable = obj->permModify(); if( scripted && modifiable ) queue->addObject(obj->getID()); else break; } if(!queue->start()) { if ( ! scripted ) { gViewerWindow->alertXml("CannotResetSelectObjectsNoScripts"); } else if ( ! modifiable ) { gViewerWindow->alertXml("CannotResetSelectObjectsNoPermission"); } } } void handle_set_run_selection(void*) { LLFloaterRunQueue* queue = LLFloaterRunQueue::create(); BOOL scripted = FALSE; BOOL modifiable = FALSE; for(LLViewerObject* obj = gSelectMgr->getSelection()->getFirstObject(); obj; obj = gSelectMgr->getSelection()->getNextObject()) { scripted = obj->flagScripted(); modifiable = obj->permModify(); if( scripted && modifiable ) queue->addObject(obj->getID()); else break; } if(!queue->start()) { if ( ! scripted ) { gViewerWindow->alertXml("CannotSetRunningSelectObjectsNoScripts"); } else if ( ! modifiable ) { gViewerWindow->alertXml("CannotSerRunningSelectObjectsNoPermission"); } } } void handle_set_not_run_selection(void*) { LLFloaterNotRunQueue* queue = LLFloaterNotRunQueue::create(); BOOL scripted = FALSE; BOOL modifiable = FALSE; for(LLViewerObject* obj = gSelectMgr->getSelection()->getFirstObject(); obj; obj = gSelectMgr->getSelection()->getNextObject()) { scripted = obj->flagScripted(); modifiable = obj->permModify(); if( scripted && modifiable ) queue->addObject(obj->getID()); else break; } if(!queue->start()) { if ( ! scripted ) { gViewerWindow->alertXml("CannotSetRunningNotSelectObjectsNoScripts"); } else if ( ! modifiable ) { gViewerWindow->alertXml("CannotSerRunningNotSelectObjectsNoPermission"); } } } void handle_selected_texture_info(void*) { LLSelectNode* node = NULL; for (node = gSelectMgr->getSelection()->getFirstNode(); node != NULL; node = gSelectMgr->getSelection()->getNextNode()) { if (!node->mValid) continue; std::string msg; msg.assign("Texture info for: "); msg.append(node->mName); LLChat chat(msg); LLFloaterChat::addChat(chat); U8 te_count = node->getObject()->getNumTEs(); // map from texture ID to list of faces using it typedef std::map< LLUUID, std::vector > map_t; map_t faces_per_texture; for (U8 i = 0; i < te_count; i++) { if (!node->isTESelected(i)) continue; LLViewerImage* img = node->getObject()->getTEImage(i); LLUUID image_id = img->getID(); faces_per_texture[image_id].push_back(i); } // Per-texture, dump which faces are using it. map_t::iterator it; for (it = faces_per_texture.begin(); it != faces_per_texture.end(); ++it) { LLUUID image_id = it->first; U8 te = it->second[0]; LLViewerImage* img = node->getObject()->getTEImage(te); S32 height = img->getHeight(); S32 width = img->getWidth(); S32 components = img->getComponents(); std::string image_id_string; if (gAgent.isGodlike()) { image_id_string = image_id.asString() + " "; } msg = llformat("%s%dx%d %s on face ", image_id_string.c_str(), width, height, (components == 4 ? "alpha" : "opaque")); for (U8 i = 0; i < it->second.size(); ++i) { msg.append( llformat("%d ", (S32)(it->second[i]))); } LLChat chat(msg); LLFloaterChat::addChat(chat); } } } void handle_dump_image_list(void*) { gImageList.dump(); } void handle_test_male(void*) { wear_outfit_by_name("Male Shape & Outfit"); //gGestureList.requestResetFromServer( TRUE ); } void handle_test_female(void*) { wear_outfit_by_name("Female Shape & Outfit"); //gGestureList.requestResetFromServer( FALSE ); } void handle_toggle_pg(void*) { if (gAgent.mAccess < SIM_ACCESS_MATURE) { gAgent.mAccess = SIM_ACCESS_MATURE; } else { gAgent.mAccess = SIM_ACCESS_PG; } LLFloaterWorldMap::reloadIcons(NULL); llinfos << "Access set to " << (S32)gAgent.mAccess << llendl; } void handle_dump_attachments(void*) { LLVOAvatar* avatar = gAgent.getAvatarObject(); if( !avatar ) { llinfos << "NO AVATAR" << llendl; return; } for( LLViewerJointAttachment* attachment = avatar->mAttachmentPoints.getFirstData(); attachment; attachment = avatar->mAttachmentPoints.getNextData() ) { S32 key = avatar->mAttachmentPoints.getCurrentKeyWithoutIncrement(); BOOL visible = (attachment->getObject() != NULL && attachment->getObject()->mDrawable.notNull() && !attachment->getObject()->mDrawable->isRenderType(0)); LLVector3 pos; if (visible) pos = attachment->getObject()->mDrawable->getPosition(); llinfos << "ATTACHMENT " << key << ": item_id=" << attachment->getItemID() << (attachment->getObject() ? " present " : " absent ") << (visible ? "visible " : "invisible ") << " at " << pos << " and " << (visible ? attachment->getObject()->getPosition() : LLVector3::zero) << llendl; } } //--------------------------------------------------------------------- // Callbacks for enabling/disabling items //--------------------------------------------------------------------- BOOL menu_ui_enabled(void *user_data) { BOOL high_res = gSavedSettings.getBOOL( "HighResSnapshot" ); return !high_res; } // TomY TODO DEPRECATE & REMOVE void menu_toggle_control( void* user_data ) { BOOL checked = gSavedSettings.getBOOL( static_cast(user_data) ); if (LLString(static_cast(user_data)) == "HighResSnapshot" && !checked) { // High Res Snapshot active, must uncheck RenderUIInSnapshot gSavedSettings.setBOOL( "RenderUIInSnapshot", FALSE ); } gSavedSettings.setBOOL( static_cast(user_data), !checked ); } // these are used in the gl menus to set control values. class LLToggleControl : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString control_name = userdata.asString(); BOOL checked = gSavedSettings.getBOOL( control_name ); if (control_name == "HighResSnapshot" && !checked) { // High Res Snapshot active, must uncheck RenderUIInSnapshot gSavedSettings.setBOOL( "RenderUIInSnapshot", FALSE ); } gSavedSettings.setBOOL( control_name, !checked ); return true; } }; // As above, but can be a callback from a LLCheckboxCtrl void check_toggle_control( LLUICtrl *, void* user_data ) { BOOL checked = gSavedSettings.getBOOL( static_cast(user_data) ); gSavedSettings.setBOOL( static_cast(user_data), !checked ); } BOOL menu_check_control( void* user_data) { return gSavedSettings.getBOOL((char*)user_data); } // void menu_toggle_variable( void* user_data ) { BOOL checked = *(BOOL*)user_data; *(BOOL*)user_data = !checked; } BOOL menu_check_variable( void* user_data) { return *(BOOL*)user_data; } BOOL enable_land_selected( void* ) { return gParcelMgr && !(gParcelMgr->selectionEmpty()); } class LLSomethingSelected : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = !(gSelectMgr->getSelection()->isEmpty()); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLSomethingSelectedNoHUD : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); bool new_value = !(selection->isEmpty()) && !(selection->getSelectType() == SELECT_TYPE_HUD); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_more_than_one_selected(void* ) { return (gSelectMgr->getSelection()->getObjectCount() > 1); } class LLEditableSelected : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = (gSelectMgr->getSelection()->getFirstEditableObject() != NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLToolsEnableTakeCopy : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = false; if (gSelectMgr) { new_value = true; #ifndef HACKED_GODLIKE_VIEWER # ifdef TOGGLE_HACKED_GODLIKE_VIEWER if (gInProductionGrid || !gAgent.isGodlike()) # endif { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); LLViewerObject* obj = selection->getFirstRootObject(); if(obj) { for( ; obj; obj = selection->getNextRootObject()) { if(!(obj->permCopy()) || obj->isAttachment()) { new_value = false; } } } } #endif // HACKED_GODLIKE_VIEWER } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_selection_you_own_all(void*) { LLViewerObject *obj; if (gSelectMgr) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); for (obj = selection->getFirstRootObject(); obj; obj = selection->getNextRootObject()) { if (!obj->permYouOwner()) { return FALSE; } } } return TRUE; } BOOL enable_selection_you_own_one(void*) { if (gSelectMgr) { LLObjectSelectionHandle selection = gSelectMgr->getSelection(); LLViewerObject *obj; for (obj = selection->getFirstRootObject(); obj; obj = selection->getNextRootObject()) { if (obj->permYouOwner()) { return TRUE; } } } return FALSE; } class LLHasAsset : public LLInventoryCollectFunctor { public: LLHasAsset(const LLUUID& id) : mAssetID(id), mHasAsset(FALSE) {} virtual ~LLHasAsset() {} virtual bool operator()(LLInventoryCategory* cat, LLInventoryItem* item); BOOL hasAsset() const { return mHasAsset; } protected: LLUUID mAssetID; BOOL mHasAsset; }; bool LLHasAsset::operator()(LLInventoryCategory* cat, LLInventoryItem* item) { if(item && item->getAssetUUID() == mAssetID) { mHasAsset = TRUE; } return FALSE; } BOOL enable_save_into_inventory(void*) { if(gSelectMgr) { // find the last root LLSelectNode* last_node = NULL; for(LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); node != NULL; node = gSelectMgr->getSelection()->getNextRootNode()) { last_node = node; } #ifdef HACKED_GODLIKE_VIEWER return TRUE; #else # ifdef TOGGLE_HACKED_GODLIKE_VIEWER if (!gInProductionGrid && gAgent.isGodlike()) { return TRUE; } # endif // check all pre-req's for save into inventory. if(last_node && last_node->mValid && !last_node->mItemID.isNull() && (last_node->mPermissions->getOwner() == gAgent.getID()) && (gInventory.getItem(last_node->mItemID) != NULL)) { LLViewerObject* obj = last_node->getObject(); if( obj && !obj->isAttachment() ) { return TRUE; } } #endif } return FALSE; } class LLToolsEnableSaveToInventory : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = enable_save_into_inventory(NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_save_into_task_inventory(void*) { if(gSelectMgr) { LLSelectNode* node = gSelectMgr->getSelection()->getFirstRootNode(); if(node && (node->mValid) && (!node->mFromTaskID.isNull())) { // *TODO: check to see if the fromtaskid object exists. LLViewerObject* obj = node->getObject(); if( obj && !obj->isAttachment() ) { return TRUE; } } } return FALSE; } class LLToolsEnableSaveToObjectInventory : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = enable_save_into_task_inventory(NULL); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; BOOL enable_not_thirdperson(void*) { return !gAgent.cameraThirdPerson(); } BOOL enable_export_selected(void *) { if (gSelectMgr->getSelection()->isEmpty()) { return FALSE; } if (!gExporterRequestID.isNull()) { return FALSE; } if (!LLUploadDialog::modalUploadIsFinished()) { return FALSE; } return TRUE; } class LLViewEnableMouselook : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // You can't go directly from customize avatar to mouselook. // TODO: write code with appropriate dialogs to handle this transition. bool new_value = (CAMERA_MODE_CUSTOMIZE_AVATAR != gAgent.getCameraMode() && !gSavedSettings.getBOOL("FreezeTime")); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLToolsEnableToolNotPie : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = ( gToolMgr->getBaseTool() != gToolPie ); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLWorldEnableCreateLandmark : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.isGodlike() || (gAgent.getRegion() && gAgent.getRegion()->getAllowLandmark()); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLWorldEnableSetHomeLocation : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = gAgent.isGodlike() || (gAgent.getRegion() && gAgent.getRegion()->getAllowSetHome()); gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLWorldEnableTeleportHome : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLViewerRegion* regionp = gAgent.getRegion(); bool agent_on_prelude = (regionp && regionp->isPrelude()); bool enable_teleport_home = gAgent.isGodlike() || !agent_on_prelude; gMenuHolder->findControl(userdata["control"].asString())->setValue(enable_teleport_home); return true; } }; BOOL enable_region_owner(void*) { if(gAgent.getRegion() && gAgent.getRegion()->getOwner() == gAgent.getID()) return TRUE; return enable_god_customer_service(NULL); } BOOL enable_god_full(void*) { return gAgent.getGodLevel() >= GOD_FULL; } BOOL enable_god_liaison(void*) { return gAgent.getGodLevel() >= GOD_LIAISON; } BOOL enable_god_customer_service(void*) { return gAgent.getGodLevel() >= GOD_CUSTOMER_SERVICE; } BOOL enable_god_basic(void*) { return gAgent.getGodLevel() > GOD_NOT; } #if 0 // 1.9.2 void toggle_vertex_shaders(void *) { BOOL use_shaders = gPipeline.getUseVertexShaders(); gPipeline.setUseVertexShaders(use_shaders); } BOOL check_vertex_shaders(void *) { return gPipeline.getUseVertexShaders(); } #endif void toggle_show_xui_names(void *) { BOOL showXUINames = gSavedSettings.getBOOL("ShowXUINames"); showXUINames = !showXUINames; gSavedSettings.setBOOL("ShowXUINames", showXUINames); } BOOL check_show_xui_names(void *) { return gSavedSettings.getBOOL("ShowXUINames"); } void toggle_cull_small(void *) { // gPipeline.mCullBySize = !gPipeline.mCullBySize; // // gSavedSettings.setBOOL("RenderCullBySize", gPipeline.mCullBySize); } class LLToolsSelectOnlyMyObjects : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { BOOL cur_val = gSavedSettings.getBOOL("SelectOwnedOnly"); gSavedSettings.setBOOL("SelectOwnedOnly", ! cur_val ); return true; } }; class LLToolsSelectOnlyMovableObjects : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { BOOL cur_val = gSavedSettings.getBOOL("SelectMovableOnly"); gSavedSettings.setBOOL("SelectMovableOnly", ! cur_val ); return true; } }; class LLToolsSelectBySurrounding : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLSelectMgr::sRectSelectInclusive = !LLSelectMgr::sRectSelectInclusive; gSavedSettings.setBOOL("RectangleSelectInclusive", LLSelectMgr::sRectSelectInclusive); return true; } }; class LLToolsShowHiddenSelection : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // TomY TODO Merge these LLSelectMgr::sRenderHiddenSelections = !LLSelectMgr::sRenderHiddenSelections; gSavedSettings.setBOOL("RenderHiddenSelections", LLSelectMgr::sRenderHiddenSelections); return true; } }; class LLToolsShowSelectionLightRadius : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { // TomY TODO merge these LLSelectMgr::sRenderLightRadius = !LLSelectMgr::sRenderLightRadius; gSavedSettings.setBOOL("RenderLightRadius", LLSelectMgr::sRenderLightRadius); return true; } }; class LLToolsEditLinkedParts : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { BOOL select_individuals = gSavedSettings.getBOOL("EditLinkedParts"); if (select_individuals) { gSelectMgr->demoteSelectionToIndividuals(); } else { gSelectMgr->promoteSelectionToRoot(); } return true; } }; void reload_personal_settings_overrides(void *) { llinfos << "Loading overrides from " << gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT,"overrides.xml") << llendl; gSavedSettings.loadFromFile(gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT,"overrides.xml")); } void force_breakpoint(void *) { #if LL_WINDOWS // Forcing a breakpoint DebugBreak(); #endif } void reload_vertex_shader(void *) { //THIS WOULD BE AN AWESOME PLACE TO RELOAD SHADERS... just a thought - DaveP } void slow_mo_animations(void*) { static BOOL slow_mo = FALSE; if (slow_mo) { gAgent.getAvatarObject()->setAnimTimeFactor(1.f); slow_mo = FALSE; } else { gAgent.getAvatarObject()->setAnimTimeFactor(0.2f); slow_mo = TRUE; } } void handle_dump_avatar_local_textures(void*) { LLVOAvatar* avatar = gAgent.getAvatarObject(); if( avatar ) { avatar->dumpLocalTextures(); } } void handle_debug_avatar_textures(void*) { LLFloaterAvatarTextures::show(gLastHitObjectID); } void handle_grab_texture(void* data) { LLVOAvatar::ETextureIndex index = (LLVOAvatar::ETextureIndex)((intptr_t)data); LLVOAvatar* avatar = gAgent.getAvatarObject(); if ( avatar ) { const LLUUID& asset_id = avatar->grabLocalTexture(index); llinfos << "Adding baked texture " << asset_id << " to inventory." << llendl; LLAssetType::EType asset_type = LLAssetType::AT_TEXTURE; LLInventoryType::EType inv_type = LLInventoryType::IT_TEXTURE; LLUUID folder_id(gInventory.findCategoryUUIDForType(asset_type)); if(folder_id.notNull()) { LLString name = "Baked "; switch (index) { case LLVOAvatar::TEX_EYES_BAKED: name.append("Iris"); break; case LLVOAvatar::TEX_HEAD_BAKED: name.append("Head"); break; case LLVOAvatar::TEX_UPPER_BAKED: name.append("Upper Body"); break; case LLVOAvatar::TEX_LOWER_BAKED: name.append("Lower Body"); break; case LLVOAvatar::TEX_SKIRT_BAKED: name.append("Skirt"); break; default: name.append("Unknown"); break; } name.append(" Texture"); LLUUID item_id; item_id.generate(); LLPermissions perm; perm.init(gAgentID, gAgentID, LLUUID::null, LLUUID::null); U32 next_owner_perm = PERM_MOVE | PERM_TRANSFER; perm.initMasks(PERM_ALL, PERM_ALL, PERM_NONE, PERM_NONE, next_owner_perm); S32 creation_date_now = time_corrected(); LLPointer item = new LLViewerInventoryItem(item_id, folder_id, perm, asset_id, asset_type, inv_type, name, "", LLSaleInfo::DEFAULT, LLInventoryItem::II_FLAGS_NONE, creation_date_now); item->updateServer(TRUE); gInventory.updateItem(item); gInventory.notifyObservers(); LLInventoryView* view = LLInventoryView::getActiveInventory(); // Show the preview panel for textures to let // user know that the image is now in inventory. if(view) { LLUICtrl* focus_ctrl = gFocusMgr.getKeyboardFocus(); LLFocusMgr::FocusLostCallback callback = gFocusMgr.getFocusCallback(); view->getPanel()->setSelection(item_id, TAKE_FOCUS_NO); view->getPanel()->openSelected(); //LLInventoryView::dumpSelectionInformation((void*)view); // restore keyboard focus gFocusMgr.setKeyboardFocus(focus_ctrl, callback); } } else { llwarns << "Can't find a folder to put it in" << llendl; } } } BOOL enable_grab_texture(void* data) { LLVOAvatar::ETextureIndex index = (LLVOAvatar::ETextureIndex)((intptr_t)data); LLVOAvatar* avatar = gAgent.getAvatarObject(); if ( avatar ) { return avatar->canGrabLocalTexture(index); } return FALSE; } // Returns a pointer to the avatar give the UUID of the avatar OR of an attachment the avatar is wearing. // Returns NULL on failure. LLVOAvatar* find_avatar_from_object( LLViewerObject* object ) { if (object) { if( object->isAttachment() ) { do { object = (LLViewerObject*) object->getParent(); } while( object && !object->isAvatar() ); } else if( !object->isAvatar() ) { object = NULL; } } return (LLVOAvatar*) object; } // Returns a pointer to the avatar give the UUID of the avatar OR of an attachment the avatar is wearing. // Returns NULL on failure. LLVOAvatar* find_avatar_from_object( const LLUUID& object_id ) { return find_avatar_from_object( gObjectList.findObject(object_id) ); } void handle_disconnect_viewer(void *) { char message[2048]; /* Flawfinder: ignore */ message[0] = '\0'; snprintf(message, sizeof(message), "Testing viewer disconnect"); /* Flawfinder: ignore */ do_disconnect(message); } class LLToolsUseSelectionForGrid : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { gSelectMgr->clearGridObjects(); LLObjectSelectionHandle selection = gSelectMgr->getSelection(); for (LLViewerObject* objectp = selection->getFirstRootObject(); objectp; objectp = selection->getNextRootObject()) { gSelectMgr->addGridObject(objectp); } gSelectMgr->setGridMode(GRID_MODE_REF_OBJECT); if (gFloaterTools) { gFloaterTools->mComboGridMode->setCurrentByIndex((S32)GRID_MODE_REF_OBJECT); } return true; } }; void handle_test_load_url(void*) { LLWeb::loadURL(""); LLWeb::loadURL("hacker://www.google.com/"); LLWeb::loadURL("http"); LLWeb::loadURL("http://www.google.com/"); } // // LLViewerMenuHolderGL // LLViewerMenuHolderGL::LLViewerMenuHolderGL() : LLMenuHolderGL() { } BOOL LLViewerMenuHolderGL::hideMenus() { BOOL handled = LLMenuHolderGL::hideMenus(); // drop pie menu selection mParcelSelection = NULL; mObjectSelection = NULL; gMenuBarView->clearHoverItem(); gMenuBarView->resetMenuTrigger(); return handled; } void LLViewerMenuHolderGL::setParcelSelection(LLHandle selection) { mParcelSelection = selection; } void LLViewerMenuHolderGL::setObjectSelection(LLHandle selection) { mObjectSelection = selection; } const LLRect LLViewerMenuHolderGL::getMenuRect() const { return LLRect(0, mRect.getHeight() - MENU_BAR_HEIGHT, mRect.getWidth(), STATUS_BAR_HEIGHT); } void handle_save_to_xml(void*) { LLFloater* frontmost = gFloaterView->getFrontmost(); if (!frontmost) { gViewerWindow->alertXml("NoFrontmostFloater"); return; } LLString default_name = "floater_"; default_name += frontmost->getTitle(); default_name += ".xml"; LLString::toLower(default_name); LLString::replaceChar(default_name, ' ', '_'); LLString::replaceChar(default_name, '/', '_'); LLString::replaceChar(default_name, ':', '_'); LLString::replaceChar(default_name, '"', '_'); LLFilePicker& picker = LLFilePicker::instance(); if (picker.getSaveFile(LLFilePicker::FFSAVE_XML, default_name.c_str())) { LLString filename = picker.getFirstFile(); gUICtrlFactory->saveToXML(frontmost, filename); } } void handle_load_from_xml(void*) { LLFilePicker& picker = LLFilePicker::instance(); if (picker.getOpenFile(LLFilePicker::FFLOAD_XML)) { LLString filename = picker.getFirstFile(); LLFloater* floater = new LLFloater("sample_floater"); gUICtrlFactory->buildFloater(floater, filename); } } void handle_rebake_textures(void*) { LLVOAvatar* avatar = gAgent.getAvatarObject(); if (!avatar) return; // Slam pending upload count to "unstick" things bool slam_for_debug = true; avatar->forceBakeAllTextures(slam_for_debug); } void toggle_visibility(void* user_data) { LLView* viewp = (LLView*)user_data; viewp->setVisible(!viewp->getVisible()); } BOOL get_visibility(void* user_data) { LLView* viewp = (LLView*)user_data; return viewp->getVisible(); } // TomY TODO: Get rid of these? class LLViewShowHoverTips : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLHoverView::sShowHoverTips = !LLHoverView::sShowHoverTips; return true; } }; class LLViewCheckShowHoverTips : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = LLHoverView::sShowHoverTips; gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; // TomY TODO: Get rid of these? class LLViewHighlightTransparent : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLDrawPoolAlpha::sShowDebugAlpha = !LLDrawPoolAlpha::sShowDebugAlpha; return true; } }; class LLViewCheckHighlightTransparent : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = LLDrawPoolAlpha::sShowDebugAlpha; gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLViewToggleBeacon : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString beacon = userdata.asString(); if (beacon == "scriptsbeacon") { LLPipeline::toggleRenderScriptedBeacons(NULL); gSavedSettings.setBOOL( "scriptsbeacon", LLPipeline::getRenderScriptedBeacons(NULL) ); // toggle the other one off if it's on if (LLPipeline::getRenderScriptedBeacons(NULL) && LLPipeline::getRenderScriptedTouchBeacons(NULL)) { LLPipeline::toggleRenderScriptedTouchBeacons(NULL); gSavedSettings.setBOOL( "scripttouchbeacon", LLPipeline::getRenderScriptedTouchBeacons(NULL) ); } } else if (beacon == "physicalbeacon") { LLPipeline::toggleRenderPhysicalBeacons(NULL); gSavedSettings.setBOOL( "physicalbeacon", LLPipeline::getRenderPhysicalBeacons(NULL) ); } else if (beacon == "soundsbeacon") { LLPipeline::toggleRenderSoundBeacons(NULL); gSavedSettings.setBOOL( "soundsbeacon", LLPipeline::getRenderSoundBeacons(NULL) ); } else if (beacon == "particlesbeacon") { LLPipeline::toggleRenderParticleBeacons(NULL); gSavedSettings.setBOOL( "particlesbeacon", LLPipeline::getRenderParticleBeacons(NULL) ); } else if (beacon == "scripttouchbeacon") { LLPipeline::toggleRenderScriptedTouchBeacons(NULL); gSavedSettings.setBOOL( "scripttouchbeacon", LLPipeline::getRenderScriptedTouchBeacons(NULL) ); // toggle the other one off if it's on if (LLPipeline::getRenderScriptedBeacons(NULL) && LLPipeline::getRenderScriptedTouchBeacons(NULL)) { LLPipeline::toggleRenderScriptedBeacons(NULL); gSavedSettings.setBOOL( "scriptsbeacon", LLPipeline::getRenderScriptedBeacons(NULL) ); } } else if (beacon == "renderbeacons") { LLPipeline::toggleRenderBeacons(NULL); gSavedSettings.setBOOL( "renderbeacons", LLPipeline::getRenderBeacons(NULL) ); // toggle the other one on if it's not if (!LLPipeline::getRenderBeacons(NULL) && !LLPipeline::getRenderHighlights(NULL)) { LLPipeline::toggleRenderHighlights(NULL); gSavedSettings.setBOOL( "renderhighlights", LLPipeline::getRenderHighlights(NULL) ); } } else if (beacon == "renderhighlights") { LLPipeline::toggleRenderHighlights(NULL); gSavedSettings.setBOOL( "renderhighlights", LLPipeline::getRenderHighlights(NULL) ); // toggle the other one on if it's not if (!LLPipeline::getRenderBeacons(NULL) && !LLPipeline::getRenderHighlights(NULL)) { LLPipeline::toggleRenderBeacons(NULL); gSavedSettings.setBOOL( "renderbeacons", LLPipeline::getRenderBeacons(NULL) ); } } return true; } }; class LLViewCheckBeaconEnabled : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString beacon = userdata["data"].asString(); bool new_value = false; if (beacon == "scriptsbeacon") { new_value = gSavedSettings.getBOOL( "scriptsbeacon"); LLPipeline::setRenderScriptedBeacons(new_value); } else if (beacon == "physicalbeacon") { new_value = gSavedSettings.getBOOL( "physicalbeacon"); LLPipeline::setRenderPhysicalBeacons(new_value); } else if (beacon == "soundsbeacon") { new_value = gSavedSettings.getBOOL( "soundsbeacon"); LLPipeline::setRenderSoundBeacons(new_value); } else if (beacon == "particlesbeacon") { new_value = gSavedSettings.getBOOL( "particlesbeacon"); LLPipeline::setRenderParticleBeacons(new_value); } else if (beacon == "scripttouchbeacon") { new_value = gSavedSettings.getBOOL( "scripttouchbeacon"); LLPipeline::setRenderScriptedTouchBeacons(new_value); } else if (beacon == "renderbeacons") { new_value = gSavedSettings.getBOOL( "renderbeacons"); LLPipeline::setRenderBeacons(new_value); } else if (beacon == "renderhighlights") { new_value = gSavedSettings.getBOOL( "renderhighlights"); LLPipeline::setRenderHighlights(new_value); } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLViewToggleRenderType : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString type = userdata.asString(); if (type == "hideparticles") { LLPipeline::toggleRenderType(LLPipeline::RENDER_TYPE_PARTICLES); } return true; } }; class LLViewCheckRenderType : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString type = userdata["data"].asString(); bool new_value = false; if (type == "hideparticles") { new_value = LLPipeline::toggleRenderTypeControlNegated((void *)LLPipeline::RENDER_TYPE_PARTICLES); } gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLViewShowHUDAttachments : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLPipeline::sShowHUDAttachments = !LLPipeline::sShowHUDAttachments; return true; } }; class LLViewCheckHUDAttachments : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { bool new_value = LLPipeline::sShowHUDAttachments; gMenuHolder->findControl(userdata["control"].asString())->setValue(new_value); return true; } }; class LLEditEnableTakeOff : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString control_name = userdata["control"].asString(); LLString clothing = userdata["data"].asString(); bool new_value = false; if (clothing == "shirt") { new_value = LLAgent::selfHasWearable((void *)WT_SHIRT); } if (clothing == "pants") { new_value = LLAgent::selfHasWearable((void *)WT_PANTS); } if (clothing == "shoes") { new_value = LLAgent::selfHasWearable((void *)WT_SHOES); } if (clothing == "socks") { new_value = LLAgent::selfHasWearable((void *)WT_SOCKS); } if (clothing == "jacket") { new_value = LLAgent::selfHasWearable((void *)WT_JACKET); } if (clothing == "gloves") { new_value = LLAgent::selfHasWearable((void *)WT_GLOVES); } if (clothing == "undershirt") { new_value = LLAgent::selfHasWearable((void *)WT_UNDERSHIRT); } if (clothing == "underpants") { new_value = LLAgent::selfHasWearable((void *)WT_UNDERPANTS); } if (clothing == "skirt") { new_value = LLAgent::selfHasWearable((void *)WT_SKIRT); } gMenuHolder->findControl(control_name)->setValue(new_value); return true; } }; class LLEditTakeOff : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString clothing = userdata.asString(); if (clothing == "shirt") { LLAgent::userRemoveWearable((void*)WT_SHIRT); } else if (clothing == "pants") { LLAgent::userRemoveWearable((void*)WT_PANTS); } else if (clothing == "shoes") { LLAgent::userRemoveWearable((void*)WT_SHOES); } else if (clothing == "socks") { LLAgent::userRemoveWearable((void*)WT_SOCKS); } else if (clothing == "jacket") { LLAgent::userRemoveWearable((void*)WT_JACKET); } else if (clothing == "gloves") { LLAgent::userRemoveWearable((void*)WT_GLOVES); } else if (clothing == "undershirt") { LLAgent::userRemoveWearable((void*)WT_UNDERSHIRT); } else if (clothing == "underpants") { LLAgent::userRemoveWearable((void*)WT_UNDERPANTS); } else if (clothing == "skirt") { LLAgent::userRemoveWearable((void*)WT_SKIRT); } else if (clothing == "all") { LLAgent::userRemoveAllClothes(NULL); } return true; } }; class LLWorldChat : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { handle_chat(NULL); return true; } }; class LLWorldStartGesture : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { handle_slash_key(NULL); return true; } }; class LLToolsSelectTool : public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) { LLString tool_name = userdata.asString(); if (tool_name == "focus") { gToolMgr->getCurrentToolset()->selectToolByIndex(1); } else if (tool_name == "move") { gToolMgr->getCurrentToolset()->selectToolByIndex(2); } else if (tool_name == "edit") { gToolMgr->getCurrentToolset()->selectToolByIndex(3); } else if (tool_name == "create") { gToolMgr->getCurrentToolset()->selectToolByIndex(4); } else if (tool_name == "land") { gToolMgr->getCurrentToolset()->selectToolByIndex(5); } return true; } }; static void addMenu(view_listener_t *menu, const char *name) { sMenus.push_back(menu); menu->registerListener(gMenuHolder, name); } void initialize_menus() { // File menu init_menu_file(); // Edit menu addMenu(new LLEditUndo(), "Edit.Undo"); addMenu(new LLEditRedo(), "Edit.Redo"); addMenu(new LLEditCut(), "Edit.Cut"); addMenu(new LLEditCopy(), "Edit.Copy"); addMenu(new LLEditPaste(), "Edit.Paste"); addMenu(new LLEditDelete(), "Edit.Delete"); addMenu(new LLEditSearch(), "Edit.Search"); addMenu(new LLEditSelectAll(), "Edit.SelectAll"); addMenu(new LLEditDeselect(), "Edit.Deselect"); addMenu(new LLEditDuplicate(), "Edit.Duplicate"); addMenu(new LLEditTakeOff(), "Edit.TakeOff"); addMenu(new LLEditEnableUndo(), "Edit.EnableUndo"); addMenu(new LLEditEnableRedo(), "Edit.EnableRedo"); addMenu(new LLEditEnableCut(), "Edit.EnableCut"); addMenu(new LLEditEnableCopy(), "Edit.EnableCopy"); addMenu(new LLEditEnablePaste(), "Edit.EnablePaste"); addMenu(new LLEditEnableDelete(), "Edit.EnableDelete"); addMenu(new LLEditEnableSelectAll(), "Edit.EnableSelectAll"); addMenu(new LLEditEnableDeselect(), "Edit.EnableDeselect"); addMenu(new LLEditEnableDuplicate(), "Edit.EnableDuplicate"); addMenu(new LLEditEnableTakeOff(), "Edit.EnableTakeOff"); addMenu(new LLEditEnableCustomizeAvatar(), "Edit.EnableCustomizeAvatar"); // View menu addMenu(new LLViewMouselook(), "View.Mouselook"); addMenu(new LLViewBuildMode(), "View.BuildMode"); addMenu(new LLViewResetView(), "View.ResetView"); addMenu(new LLViewLookAtLastChatter(), "View.LookAtLastChatter"); addMenu(new LLViewShowHoverTips(), "View.ShowHoverTips"); addMenu(new LLViewHighlightTransparent(), "View.HighlightTransparent"); addMenu(new LLViewToggleBeacon(), "View.ToggleBeacon"); addMenu(new LLViewToggleRenderType(), "View.ToggleRenderType"); addMenu(new LLViewShowHUDAttachments(), "View.ShowHUDAttachments"); addMenu(new LLViewZoomOut(), "View.ZoomOut"); addMenu(new LLViewZoomIn(), "View.ZoomIn"); addMenu(new LLViewZoomDefault(), "View.ZoomDefault"); addMenu(new LLViewFullscreen(), "View.Fullscreen"); addMenu(new LLViewDefaultUISize(), "View.DefaultUISize"); addMenu(new LLViewEnableMouselook(), "View.EnableMouselook"); addMenu(new LLViewEnableLastChatter(), "View.EnableLastChatter"); addMenu(new LLViewCheckBuildMode(), "View.CheckBuildMode"); addMenu(new LLViewCheckShowHoverTips(), "View.CheckShowHoverTips"); addMenu(new LLViewCheckHighlightTransparent(), "View.CheckHighlightTransparent"); addMenu(new LLViewCheckBeaconEnabled(), "View.CheckBeaconEnabled"); addMenu(new LLViewCheckRenderType(), "View.CheckRenderType"); addMenu(new LLViewCheckHUDAttachments(), "View.CheckHUDAttachments"); // World menu addMenu(new LLWorldChat(), "World.Chat"); addMenu(new LLWorldStartGesture(), "World.StartGesture"); addMenu(new LLWorldAlwaysRun(), "World.AlwaysRun"); addMenu(new LLWorldFly(), "World.Fly"); addMenu(new LLWorldCreateLandmark(), "World.CreateLandmark"); addMenu(new LLWorldSetHomeLocation(), "World.SetHomeLocation"); addMenu(new LLWorldTeleportHome(), "World.TeleportHome"); addMenu(new LLWorldSetAway(), "World.SetAway"); addMenu(new LLWorldSetBusy(), "World.SetBusy"); addMenu(new LLWorldEnableCreateLandmark(), "World.EnableCreateLandmark"); addMenu(new LLWorldEnableSetHomeLocation(), "World.EnableSetHomeLocation"); addMenu(new LLWorldEnableTeleportHome(), "World.EnableTeleportHome"); addMenu(new LLWorldEnableBuyLand(), "World.EnableBuyLand"); addMenu(new LLWorldCheckAlwaysRun(), "World.CheckAlwaysRun"); addMenu(new LLWorldForceSun(), "World.ForceSun"); // Tools menu addMenu(new LLToolsSelectTool(), "Tools.SelectTool"); addMenu(new LLToolsSelectOnlyMyObjects(), "Tools.SelectOnlyMyObjects"); addMenu(new LLToolsSelectOnlyMovableObjects(), "Tools.SelectOnlyMovableObjects"); addMenu(new LLToolsSelectBySurrounding(), "Tools.SelectBySurrounding"); addMenu(new LLToolsShowHiddenSelection(), "Tools.ShowHiddenSelection"); addMenu(new LLToolsShowSelectionLightRadius(), "Tools.ShowSelectionLightRadius"); addMenu(new LLToolsEditLinkedParts(), "Tools.EditLinkedParts"); addMenu(new LLToolsSnapObjectXY(), "Tools.SnapObjectXY"); addMenu(new LLToolsUseSelectionForGrid(), "Tools.UseSelectionForGrid"); addMenu(new LLToolsLink(), "Tools.Link"); addMenu(new LLToolsUnlink(), "Tools.Unlink"); addMenu(new LLToolsStopAllAnimations(), "Tools.StopAllAnimations"); addMenu(new LLToolsLookAtSelection(), "Tools.LookAtSelection"); addMenu(new LLToolsBuyOrTake(), "Tools.BuyOrTake"); addMenu(new LLToolsTakeCopy(), "Tools.TakeCopy"); addMenu(new LLToolsSaveToInventory(), "Tools.SaveToInventory"); addMenu(new LLToolsSaveToObjectInventory(), "Tools.SaveToObjectInventory"); addMenu(new LLToolsSelectedScriptAction(), "Tools.SelectedScriptAction"); addMenu(new LLToolsEnableToolNotPie(), "Tools.EnableToolNotPie"); addMenu(new LLToolsEnableLink(), "Tools.EnableLink"); addMenu(new LLToolsEnableUnlink(), "Tools.EnableUnlink"); addMenu(new LLToolsEnableBuyOrTake(), "Tools.EnableBuyOrTake"); addMenu(new LLToolsEnableTakeCopy(), "Tools.EnableTakeCopy"); addMenu(new LLToolsEnableSaveToInventory(), "Tools.SaveToInventory"); addMenu(new LLToolsEnableSaveToObjectInventory(), "Tools.SaveToObjectInventory"); /*addMenu(new LLToolsVisibleBuyObject(), "Tools.VisibleBuyObject"); addMenu(new LLToolsVisibleTakeObject(), "Tools.VisibleTakeObject");*/ // Help menu addMenu(new LLHelpMOTD(), "Help.MOTD"); // Self pie menu addMenu(new LLSelfStandUp(), "Self.StandUp"); addMenu(new LLSelfRemoveAllAttachments(), "Self.RemoveAllAttachments"); addMenu(new LLSelfEnableStandUp(), "Self.EnableStandUp"); addMenu(new LLSelfEnableRemoveAllAttachments(), "Self.EnableRemoveAllAttachments"); // Avatar pie menu addMenu(new LLObjectMute(), "Avatar.Mute"); addMenu(new LLAvatarAddFriend(), "Avatar.AddFriend"); addMenu(new LLAvatarFreeze(), "Avatar.Freeze"); addMenu(new LLAvatarDebug(), "Avatar.Debug"); addMenu(new LLAvatarVisibleDebug(), "Avatar.VisibleDebug"); addMenu(new LLAvatarEnableDebug(), "Avatar.EnableDebug"); addMenu(new LLAvatarInviteToGroup(), "Avatar.InviteToGroup"); addMenu(new LLAvatarGiveCard(), "Avatar.GiveCard"); addMenu(new LLAvatarEject(), "Avatar.Eject"); addMenu(new LLAvatarSendIM(), "Avatar.SendIM"); addMenu(new LLObjectEnableMute(), "Avatar.EnableMute"); addMenu(new LLAvatarEnableAddFriend(), "Avatar.EnableAddFriend"); addMenu(new LLAvatarEnableFreezeEject(), "Avatar.EnableFreezeEject"); // Object pie menu addMenu(new LLObjectOpen(), "Object.Open"); addMenu(new LLObjectBuild(), "Object.Build"); addMenu(new LLObjectTouch(), "Object.Touch"); addMenu(new LLObjectSitOrStand(), "Object.SitOrStand"); addMenu(new LLObjectDelete(), "Object.Delete"); addMenu(new LLObjectAttachToAvatar(), "Object.AttachToAvatar"); addMenu(new LLObjectReturn(), "Object.Return"); addMenu(new LLObjectReportAbuse(), "Object.ReportAbuse"); addMenu(new LLObjectMute(), "Object.Mute"); addMenu(new LLObjectBuy(), "Object.Buy"); addMenu(new LLObjectEdit(), "Object.Edit"); addMenu(new LLObjectInspect(), "Object.Inspect"); addMenu(new LLObjectEnableOpen(), "Object.EnableOpen"); addMenu(new LLObjectEnableTouch(), "Object.EnableTouch"); addMenu(new LLObjectEnableSitOrStand(), "Object.EnableSitOrStand"); addMenu(new LLObjectEnableDelete(), "Object.EnableDelete"); addMenu(new LLObjectEnableWear(), "Object.EnableWear"); addMenu(new LLObjectEnableReturn(), "Object.EnableReturn"); addMenu(new LLObjectEnableReportAbuse(), "Object.EnableReportAbuse"); addMenu(new LLObjectEnableMute(), "Object.EnableMute"); addMenu(new LLObjectEnableBuy(), "Object.EnableBuy"); /*addMenu(new LLObjectVisibleTouch(), "Object.VisibleTouch"); addMenu(new LLObjectVisibleCustomTouch(), "Object.VisibleCustomTouch"); addMenu(new LLObjectVisibleStandUp(), "Object.VisibleStandUp"); addMenu(new LLObjectVisibleSitHere(), "Object.VisibleSitHere"); addMenu(new LLObjectVisibleCustomSit(), "Object.VisibleCustomSit");*/ // Attachment pie menu addMenu(new LLAttachmentDrop(), "Attachment.Drop"); addMenu(new LLAttachmentDetach(), "Attachment.Detach"); addMenu(new LLAttachmentEnableDrop(), "Attachment.EnableDrop"); addMenu(new LLAttachmentEnableDetach(), "Attachment.EnableDetach"); // Land pie menu addMenu(new LLLandBuild(), "Land.Build"); addMenu(new LLLandSit(), "Land.Sit"); addMenu(new LLLandBuyPass(), "Land.BuyPass"); addMenu(new LLLandEdit(), "Land.Edit"); addMenu(new LLLandEnableBuyPass(), "Land.EnableBuyPass"); // Generic actions addMenu(new LLShowFloater(), "ShowFloater"); addMenu(new LLPromptShowURL(), "PromptShowURL"); addMenu(new LLPromptShowFile(), "PromptShowFile"); addMenu(new LLShowAgentProfile(), "ShowAgentProfile"); addMenu(new LLShowAgentGroups(), "ShowAgentGroups"); addMenu(new LLToggleControl(), "ToggleControl"); addMenu(new LLGoToObject(), "GoToObject"); addMenu(new LLPayObject(), "PayObject"); addMenu(new LLEnablePayObject(), "EnablePayObject"); addMenu(new LLEnableEdit(), "EnableEdit"); addMenu(new LLFloaterVisible(), "FloaterVisible"); addMenu(new LLSomethingSelected(), "SomethingSelected"); addMenu(new LLSomethingSelectedNoHUD(), "SomethingSelectedNoHUD"); addMenu(new LLEditableSelected(), "EditableSelected"); }