void LLFloaterWindLight::syncMenu() { bool err; LLWLParamManager * param_mgr = LLWLParamManager::instance(); LLWLParamSet& currentParams = param_mgr->mCurParams; //std::map<std::string, LLVector4> & currentParams = param_mgr->mCurParams.mParamValues; // blue horizon param_mgr->mBlueHorizon = currentParams.getVector(param_mgr->mBlueHorizon.mName, err); childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r / 2.0); childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g / 2.0); childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b / 2.0); childSetValue("WLBlueHorizonI", std::max(param_mgr->mBlueHorizon.r / 2.0, std::max(param_mgr->mBlueHorizon.g / 2.0, param_mgr->mBlueHorizon.b / 2.0))); // haze density, horizon, mult, and altitude param_mgr->mHazeDensity = currentParams.getVector(param_mgr->mHazeDensity.mName, err); childSetValue("WLHazeDensity", param_mgr->mHazeDensity.r); param_mgr->mHazeHorizon = currentParams.getVector(param_mgr->mHazeHorizon.mName, err); childSetValue("WLHazeHorizon", param_mgr->mHazeHorizon.r); param_mgr->mDensityMult = currentParams.getVector(param_mgr->mDensityMult.mName, err); childSetValue("WLDensityMult", param_mgr->mDensityMult.x * param_mgr->mDensityMult.mult); param_mgr->mMaxAlt = currentParams.getVector(param_mgr->mMaxAlt.mName, err); childSetValue("WLMaxAltitude", param_mgr->mMaxAlt.x); // blue density param_mgr->mBlueDensity = currentParams.getVector(param_mgr->mBlueDensity.mName, err); childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r / 2.0); childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g / 2.0); childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b / 2.0); childSetValue("WLBlueDensityI", std::max(param_mgr->mBlueDensity.r / 2.0, std::max(param_mgr->mBlueDensity.g / 2.0, param_mgr->mBlueDensity.b / 2.0))); // Lighting // sunlight param_mgr->mSunlight = currentParams.getVector(param_mgr->mSunlight.mName, err); childSetValue("WLSunlightR", param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightG", param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightB", param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightI", std::max(param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE, std::max(param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE))); // glow param_mgr->mGlow = currentParams.getVector(param_mgr->mGlow.mName, err); childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f); childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f); // ambient param_mgr->mAmbient = currentParams.getVector(param_mgr->mAmbient.mName, err); childSetValue("WLAmbientR", param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientG", param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientB", param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientI", std::max(param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE, std::max(param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE))); childSetValue("WLSunAngle", param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI); childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI); // Clouds // Cloud Color param_mgr->mCloudColor = currentParams.getVector(param_mgr->mCloudColor.mName, err); childSetValue("WLCloudColorR", param_mgr->mCloudColor.r); childSetValue("WLCloudColorG", param_mgr->mCloudColor.g); childSetValue("WLCloudColorB", param_mgr->mCloudColor.b); childSetValue("WLCloudColorI", std::max(param_mgr->mCloudColor.r, std::max(param_mgr->mCloudColor.g, param_mgr->mCloudColor.b))); // Cloud param_mgr->mCloudMain = currentParams.getVector(param_mgr->mCloudMain.mName, err); childSetValue("WLCloudX", param_mgr->mCloudMain.r); childSetValue("WLCloudY", param_mgr->mCloudMain.g); childSetValue("WLCloudDensity", param_mgr->mCloudMain.b); // Cloud Detail param_mgr->mCloudDetail = currentParams.getVector(param_mgr->mCloudDetail.mName, err); childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r); childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g); childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b); // Cloud extras param_mgr->mCloudCoverage = currentParams.getVector(param_mgr->mCloudCoverage.mName, err); param_mgr->mCloudScale = currentParams.getVector(param_mgr->mCloudScale.mName, err); childSetValue("WLCloudCoverage", param_mgr->mCloudCoverage.x); childSetValue("WLCloudScale", param_mgr->mCloudScale.x); // cloud scrolling bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX(); bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY(); childSetValue("WLCloudLockX", lockX); childSetValue("WLCloudLockY", lockY); childSetValue("DrawClassicClouds", gSavedSettings.getBOOL("SkyUseClassicClouds")); // disable if locked, enable if not if(lockX) { childDisable("WLCloudScrollX"); } else { childEnable("WLCloudScrollX"); } if(lockY) { childDisable("WLCloudScrollY"); } else { childEnable("WLCloudScrollY"); } // *HACK cloud scrolling is off my an additive of 10 childSetValue("WLCloudScrollX", param_mgr->mCurParams.getCloudScrollX() - 10.0f); childSetValue("WLCloudScrollY", param_mgr->mCurParams.getCloudScrollY() - 10.0f); param_mgr->mDistanceMult = currentParams.getVector(param_mgr->mDistanceMult.mName, err); childSetValue("WLDistanceMult", param_mgr->mDistanceMult.x); // Tweak extras param_mgr->mWLGamma = currentParams.getVector(param_mgr->mWLGamma.mName, err); childSetValue("WLGamma", param_mgr->mWLGamma.x); childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness()); LLTabContainer* tab = getChild<LLTabContainer>("WindLight Tabs"); LLPanel* panel = getChild<LLPanel>("Scattering"); tab->enableTabButton(tab->getIndexForPanel(panel), gSavedSettings.getBOOL("RenderDeferredGI")); }
BOOL LLFloaterWorldMap::postBuild() { mTabs = getChild<LLTabContainer>("maptab"); if (!mTabs) return FALSE; LLPanel *panel; panel = mTabs->getChild<LLPanel>("objects_mapview"); if (panel) { mTabs->setTabChangeCallback(panel, onCommitBackground); mTabs->setTabUserData(panel, this); } panel = mTabs->getChild<LLPanel>("terrain_mapview"); if (panel) { mTabs->setTabChangeCallback(panel, onCommitBackground); mTabs->setTabUserData(panel, this); } // The following callback syncs the worlmap tabs with the images. // Commented out since it was crashing when LLWorldMap became a singleton. // We should be fine without it but override the onOpen method and put it // there if it turns out to be needed. -MG // //onCommitBackground((void*)this, false); childSetCommitCallback("friend combo", onAvatarComboCommit, this); LLComboBox *avatar_combo = getChild<LLComboBox>("friend combo"); if (avatar_combo) { avatar_combo->selectFirstItem(); avatar_combo->setPrearrangeCallback( onAvatarComboPrearrange ); avatar_combo->setTextEntryCallback( onComboTextEntry ); } childSetAction("DoSearch", onLocationCommit, this); childSetFocusChangedCallback("location", onLocationFocusChanged, this); LLLineEditor *location_editor = getChild<LLLineEditor>("location"); if (location_editor) { location_editor->setKeystrokeCallback( onSearchTextEntry ); } childSetCommitCallback("search_results", onCommitSearchResult, this); childSetDoubleClickCallback("search_results", onClickTeleportBtn); childSetCommitCallback("spin x", onCommitLocation, this); childSetCommitCallback("spin y", onCommitLocation, this); childSetCommitCallback("spin z", onCommitLocation, this); childSetCommitCallback("landmark combo", onLandmarkComboCommit, this); LLComboBox *landmark_combo = getChild<LLComboBox>( "landmark combo"); if (landmark_combo) { landmark_combo->selectFirstItem(); landmark_combo->setPrearrangeCallback( onLandmarkComboPrearrange ); landmark_combo->setTextEntryCallback( onComboTextEntry ); } childSetAction("Go Home", onGoHome, this); childSetAction("Teleport", onClickTeleportBtn, this); childSetAction("Show Destination", onShowTargetBtn, this); childSetAction("Show My Location", onShowAgentBtn, this); childSetAction("Clear", onClearBtn, this); childSetAction("copy_slurl", onCopySLURL, this); mCurZoomVal = log(LLWorldMapView::sMapScale)/log(2.f); childSetValue("zoom slider", LLWorldMapView::sMapScale); setDefaultBtn(NULL); mZoomTimer.stop(); return TRUE; }
void LLFloaterWorldMap::updateLocation() { bool gotSimName; LLTracker::ETrackingStatus status = LLTracker::getTrackingStatus(); // These values may get updated by a message, so need to check them every frame // The fields may be changed by the user, so only update them if the data changes LLVector3d pos_global = LLTracker::getTrackedPositionGlobal(); if (pos_global.isExactlyZero()) { LLVector3d agentPos = gAgent.getPositionGlobal(); // Set to avatar's current postion if nothing is selected if ( status == LLTracker::TRACKING_NOTHING && mSetToUserPosition ) { // Make sure we know where we are before setting the current user position std::string agent_sim_name; gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( agentPos, agent_sim_name ); if ( gotSimName ) { mSetToUserPosition = FALSE; // Fill out the location field childSetValue("location", agent_sim_name); // Figure out where user is LLVector3d agentPos = gAgent.getPositionGlobal(); S32 agent_x = llround( (F32)fmod( agentPos.mdV[VX], (F64)REGION_WIDTH_METERS ) ); S32 agent_y = llround( (F32)fmod( agentPos.mdV[VY], (F64)REGION_WIDTH_METERS ) ); S32 agent_z = llround( (F32)agentPos.mdV[VZ] ); childSetValue("spin x", LLSD(agent_x) ); childSetValue("spin y", LLSD(agent_y) ); childSetValue("spin z", LLSD(agent_z) ); // Set the current SLURL mSLURL = LLURLDispatcher::buildSLURL(agent_sim_name, agent_x, agent_y, agent_z); // [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a) if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) { childSetValue("location", RlvStrings::getString(RLV_STRING_HIDDEN_REGION)); mSLURL.clear(); } // [/RLVa:KB] } } return; // invalid location } std::string sim_name; gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal( pos_global, sim_name ); if ((status != LLTracker::TRACKING_NOTHING) && (status != mTrackedStatus || pos_global != mTrackedLocation || sim_name != mTrackedSimName)) { mTrackedStatus = status; mTrackedLocation = pos_global; mTrackedSimName = sim_name; if (status == LLTracker::TRACKING_AVATAR) { // *HACK: Adjust Z values automatically for liaisons & // gods so they swoop down when they click on the // map. Requested convenience. if(gAgent.isGodlike()) { pos_global[2] = 200; } } childSetValue("location", sim_name); F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS ); F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS ); childSetValue("spin x", LLSD(region_x) ); childSetValue("spin y", LLSD(region_y) ); childSetValue("spin z", LLSD((F32)pos_global.mdV[VZ]) ); // simNameFromPosGlobal can fail, so don't give the user an invalid SLURL if ( gotSimName ) { mSLURL = LLURLDispatcher::buildSLURL(sim_name, llround(region_x), llround(region_y), llround((F32)pos_global.mdV[VZ])); } else { // Empty SLURL will disable the "Copy SLURL to clipboard" button mSLURL = ""; } // [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a) if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) { childSetValue("location", RlvStrings::getString(RLV_STRING_HIDDEN_REGION)); mSLURL.clear(); } // [/RLVa:KB] } }
void LLFloaterTools::updatePopup(LLCoordGL center, MASK mask) { LLTool *tool = LLToolMgr::getInstance()->getCurrentTool(); // HACK to allow seeing the buttons when you have the app in a window. // Keep the visibility the same as it if (tool == gToolNull) { return; } if ( isMinimized() ) { // SL looks odd if we draw the tools while the window is minimized return; } // Focus buttons BOOL focus_visible = ( tool == LLToolCamera::getInstance() ); mBtnFocus ->setToggleState( focus_visible ); mRadioZoom ->setVisible( focus_visible ); mRadioOrbit ->setVisible( focus_visible ); mRadioPan ->setVisible( focus_visible ); childSetVisible("slider zoom", focus_visible); childSetEnabled("slider zoom", gCameraBtnZoom); mRadioZoom ->set( !gCameraBtnOrbit && !gCameraBtnPan && !(mask == MASK_ORBIT) && !(mask == (MASK_ORBIT | MASK_ALT)) && !(mask == MASK_PAN) && !(mask == (MASK_PAN | MASK_ALT)) ); mRadioOrbit ->set( gCameraBtnOrbit || (mask == MASK_ORBIT) || (mask == (MASK_ORBIT | MASK_ALT)) ); mRadioPan ->set( gCameraBtnPan || (mask == MASK_PAN) || (mask == (MASK_PAN | MASK_ALT)) ); // multiply by correction factor because volume sliders go [0, 0.5] childSetValue( "slider zoom", gAgent.getCameraZoomFraction() * 0.5f); // Move buttons BOOL move_visible = (tool == LLToolGrab::getInstance()); if (mBtnMove) mBtnMove ->setToggleState( move_visible ); // HACK - highlight buttons for next click if (mRadioMove) { mRadioMove ->setVisible( move_visible ); mRadioMove ->set( !gGrabBtnSpin && !gGrabBtnVertical && !(mask == MASK_VERTICAL) && !(mask == MASK_SPIN) ); } if (mRadioLift) { mRadioLift ->setVisible( move_visible ); mRadioLift ->set( gGrabBtnVertical || (mask == MASK_VERTICAL) ); } if (mRadioSpin) { mRadioSpin ->setVisible( move_visible ); mRadioSpin ->set( gGrabBtnSpin || (mask == MASK_SPIN) ); } // Edit buttons BOOL edit_visible = tool == LLToolCompTranslate::getInstance() || tool == LLToolCompRotate::getInstance() || tool == LLToolCompScale::getInstance() || tool == LLToolFace::getInstance() || tool == LLToolIndividual::getInstance() || tool == LLToolPipette::getInstance(); mBtnEdit ->setToggleState( edit_visible ); mRadioPosition ->setVisible( edit_visible ); mRadioRotate ->setVisible( edit_visible ); mRadioStretch ->setVisible( edit_visible ); if (mRadioSelectFace) { mRadioSelectFace->setVisible( edit_visible ); mRadioSelectFace->set( tool == LLToolFace::getInstance() ); } if (mCheckSelectIndividual) { mCheckSelectIndividual->setVisible(edit_visible); //mCheckSelectIndividual->set(gSavedSettings.getBOOL("EditLinkedParts")); } mRadioPosition ->set( tool == LLToolCompTranslate::getInstance() ); mRadioRotate ->set( tool == LLToolCompRotate::getInstance() ); mRadioStretch ->set( tool == LLToolCompScale::getInstance() ); if (mComboGridMode) { mComboGridMode->setVisible( edit_visible ); S32 index = mComboGridMode->getCurrentIndex(); mComboGridMode->removeall(); switch (mObjectSelection->getSelectType()) { case SELECT_TYPE_HUD: mComboGridMode->add(getString("grid_screen_text")); mComboGridMode->add(getString("grid_local_text")); //mComboGridMode->add(getString("grid_reference_text")); break; case SELECT_TYPE_WORLD: mComboGridMode->add(getString("grid_world_text")); mComboGridMode->add(getString("grid_local_text")); mComboGridMode->add(getString("grid_reference_text")); break; case SELECT_TYPE_ATTACHMENT: mComboGridMode->add(getString("grid_attachment_text")); mComboGridMode->add(getString("grid_local_text")); mComboGridMode->add(getString("grid_reference_text")); break; } mComboGridMode->setCurrentByIndex(index); } if (mTextGridMode) mTextGridMode->setVisible( edit_visible ); // Snap to grid disabled for grab tool - very confusing if (mCheckSnapToGrid) mCheckSnapToGrid->setVisible( edit_visible /* || tool == LLToolGrab::getInstance() */ ); if (mBtnGridOptions) mBtnGridOptions->setVisible( edit_visible /* || tool == LLToolGrab::getInstance() */ ); //mCheckSelectLinked ->setVisible( edit_visible ); if (mCheckStretchUniform) mCheckStretchUniform->setVisible( edit_visible ); if (mCheckStretchTexture) mCheckStretchTexture->setVisible( edit_visible ); // Create buttons BOOL create_visible = (tool == LLToolCompCreate::getInstance()); mBtnCreate ->setToggleState( tool == LLToolCompCreate::getInstance() ); if (mCheckCopySelection && mCheckCopySelection->get()) { // don't highlight any placer button for (std::vector<LLButton*>::size_type i = 0; i < mButtons.size(); i++) { mButtons[i]->setToggleState(FALSE); mButtons[i]->setVisible( create_visible ); } } else { // Highlight the correct placer button for( std::vector<LLButton*>::size_type i = 0; i < mButtons.size(); i++ ) { LLPCode pcode = LLToolPlacer::getObjectType(); void *userdata = mButtons[i]->getCallbackUserData(); LLPCode *cur = (LLPCode*) userdata; BOOL state = (pcode == *cur); mButtons[i]->setToggleState( state ); mButtons[i]->setVisible( create_visible ); } } if (mCheckSticky) mCheckSticky ->setVisible( create_visible ); if (mCheckCopySelection) mCheckCopySelection ->setVisible( create_visible ); if (mCheckCopyCenters) mCheckCopyCenters ->setVisible( create_visible ); if (mCheckCopyRotates) mCheckCopyRotates ->setVisible( create_visible ); if (mCheckCopyCenters) mCheckCopyCenters->setEnabled( mCheckCopySelection->get() ); if (mCheckCopyRotates) mCheckCopyRotates->setEnabled( mCheckCopySelection->get() ); // Land buttons BOOL land_visible = (tool == LLToolBrushLand::getInstance() || tool == LLToolSelectLand::getInstance() ); if (mBtnLand) mBtnLand ->setToggleState( land_visible ); // mRadioEditLand ->set( tool == LLToolBrushLand::getInstance() ); if (mRadioSelectLand) mRadioSelectLand->set( tool == LLToolSelectLand::getInstance() ); // mRadioEditLand ->setVisible( land_visible ); if (mRadioSelectLand) mRadioSelectLand->setVisible( land_visible ); S32 dozer_mode = gSavedSettings.getS32("RadioLandBrushAction"); S32 dozer_size = gSavedSettings.getS32("RadioLandBrushSize"); if (mRadioDozerFlatten) { mRadioDozerFlatten ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 0); mRadioDozerFlatten ->setVisible( land_visible ); } if (mRadioDozerRaise) { mRadioDozerRaise ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 1); mRadioDozerRaise ->setVisible( land_visible ); } if (mRadioDozerLower) { mRadioDozerLower ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 2); mRadioDozerLower ->setVisible( land_visible ); } if (mRadioDozerSmooth) { mRadioDozerSmooth ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 3); mRadioDozerSmooth ->setVisible( land_visible ); } if (mRadioDozerNoise) { mRadioDozerNoise ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 4); mRadioDozerNoise ->setVisible( land_visible ); } if (mRadioDozerRevert) { mRadioDozerRevert ->set( tool == LLToolBrushLand::getInstance() && dozer_mode == 5); mRadioDozerRevert ->setVisible( land_visible ); } if (mComboDozerSize) { mComboDozerSize ->setCurrentByIndex(dozer_size); mComboDozerSize ->setVisible( land_visible ); mComboDozerSize ->setEnabled( tool == LLToolBrushLand::getInstance() ); } if (mBtnApplyToSelection) { mBtnApplyToSelection->setVisible( land_visible ); mBtnApplyToSelection->setEnabled( land_visible && !LLViewerParcelMgr::getInstance()->selectionEmpty() && tool != LLToolSelectLand::getInstance()); } if (mCheckShowOwners) { mCheckShowOwners ->setVisible( land_visible ); } if (mSliderDozerForce) { mSliderDozerForce ->setVisible( land_visible ); childSetVisible("Strength:", land_visible); } // // More panel visibility // BOOL show_more = gSavedSettings.getBOOL("ToolboxShowMore"); mTab->setVisible(show_more && tool != LLToolBrushLand::getInstance() && tool != LLToolSelectLand::getInstance()); mPanelLandInfo->setVisible(show_more && (tool == LLToolBrushLand::getInstance() || tool == LLToolSelectLand::getInstance())); }
//virtual BOOL LLPanelPreference::postBuild() { ////////////////////// PanelVoice /////////////////// if(hasChild("voice_unavailable")) { BOOL voice_disabled = gSavedSettings.getBOOL("CmdLineDisableVoice"); childSetVisible("voice_unavailable", voice_disabled); childSetVisible("enable_voice_check", !voice_disabled); } //////////////////////PanelSkins /////////////////// if (hasChild("skin_selection")) { LLFloaterPreference::refreshSkin(this); // if skin is set to a skin that no longer exists (silver) set back to default if (getChild<LLRadioGroup>("skin_selection")->getSelectedIndex() < 0) { gSavedSettings.setString("SkinCurrent", "default"); LLFloaterPreference::refreshSkin(this); } } if(hasChild("online_visibility") && hasChild("send_im_to_email")) { childSetText("email_address",getString("log_in_to_change") ); // childSetText("busy_response", getString("log_in_to_change")); } //////////////////////PanelPrivacy /////////////////// if (hasChild("media_enabled")) { bool media_enabled = gSavedSettings.getBOOL("AudioStreamingMedia"); getChild<LLCheckBoxCtrl>("media_enabled")->set(media_enabled); getChild<LLCheckBoxCtrl>("autoplay_enabled")->setEnabled(media_enabled); } if (hasChild("music_enabled")) { getChild<LLCheckBoxCtrl>("music_enabled")->set(gSavedSettings.getBOOL("AudioStreamingMusic")); } if (hasChild("voice_call_friends_only_check")) { getChild<LLCheckBoxCtrl>("voice_call_friends_only_check")->setCommitCallback(boost::bind(&showFriendsOnlyWarning, _1, _2)); } // Panel Advanced if (hasChild("modifier_combo")) { //localizing if push2talk button is set to middle mouse if (MIDDLE_MOUSE_CV == childGetValue("modifier_combo").asString()) { childSetValue("modifier_combo", getString("middle_mouse")); } } apply(); return true; }
// returns false, if adding new grid failed bool HippoPanelGridsImpl::saveCurGrid() { HippoGridInfo *gridInfo = 0; gridInfo = gHippoGridManager->getGrid(mCurGrid); //gridInfo->getGridInfo(); refresh(); std::string gridname = childGetValue("gridname"); if (gridname == "<required>") gridname = ""; std::string loginuri = childGetValue("loginuri"); if (loginuri == "<required>") loginuri = ""; if (gridname.empty() && !loginuri.empty()) this->retrieveGridInfo(); if ((mState == ADD_NEW) || (mState == ADD_COPY)) { // check nickname std::string gridname = childGetValue("gridname"); childSetValue("gridname", (gridname != "")? gridname: "<required>"); if (gridname == "") { LLNotificationsUtil::add("GridsNoNick"); return false; } if (gHippoGridManager->getGrid(gridname)) { LLSD args; args["NAME"] = gridname; LLNotificationsUtil::add("GridExists", args); return false; } // check login URI if (loginuri == "") { LLSD args; args["NAME"] = gridname; LLNotificationsUtil::add("GridsNoLoginUri", args); return false; } mState = NORMAL; mCurGrid = gridname; gridInfo = new HippoGridInfo(gridname); gHippoGridManager->addGrid(gridInfo); try { gridInfo->getGridInfo(); } catch (AIAlert::ErrorCode const& error) { if (error.getCode() == HTTP_NOT_FOUND || error.getCode() == HTTP_METHOD_NOT_ALLOWED) { // Ignore this error; it might be a user entered entry for a grid that has no get_grid_info support. llwarns << AIAlert::text(error) << llendl; } else if (error.getCode() == HTTP_OK) { // XML parse error. AIAlert::add("GridInfoError", error); } else { // Append GridInfoErrorInstruction to error message. AIAlert::add("GridInfoError", AIAlert::Error(AIAlert::Prefix(), AIAlert::not_modal, error, "GridInfoErrorInstruction")); } } } if (!gridInfo) { llwarns << "Grid not found, ignoring changes." << llendl; return true; } gridInfo->setPlatform(childGetValue("platform")); gridInfo->setGridName(childGetValue("gridname")); gridInfo->setLoginUri(childGetValue("loginuri")); gridInfo->setLoginPage(childGetValue("loginpage")); gridInfo->setHelperUri(childGetValue("helperuri")); gridInfo->setWebSite(childGetValue("website")); gridInfo->setSupportUrl(childGetValue("support")); gridInfo->setRegisterUrl(childGetValue("register")); gridInfo->setPasswordUrl(childGetValue("password")); gridInfo->setSearchUrl(childGetValue("search")); gridInfo->setRenderCompat(childGetValue("render_compat")); refresh(); return true; }
void LLPanelPermissions::refresh() { LLButton* BtnDeedToGroup = getChild<LLButton>("button deed"); if(BtnDeedToGroup) { std::string deedText; if (gSavedSettings.getWarning("DeedObject")) { deedText = getString("text deed continued"); } else { deedText = getString("text deed"); } BtnDeedToGroup->setLabelSelected(deedText); BtnDeedToGroup->setLabelUnselected(deedText); } BOOL root_selected = TRUE; LLSelectNode* nodep = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode(); S32 object_count = LLSelectMgr::getInstance()->getSelection()->getRootObjectCount(); if(!nodep || 0 == object_count) { nodep = LLSelectMgr::getInstance()->getSelection()->getFirstNode(); object_count = LLSelectMgr::getInstance()->getSelection()->getObjectCount(); root_selected = FALSE; } //BOOL attachment_selected = LLSelectMgr::getInstance()->getSelection()->isAttachment(); //attachment_selected = false; LLViewerObject* objectp = NULL; if(nodep) objectp = nodep->getObject(); if(!nodep || !objectp)// || attachment_selected) { // ...nothing selected childSetEnabled("perm_modify",false); childSetText("perm_modify",LLStringUtil::null); childSetEnabled("Creator:",false); childSetText("Creator Name",LLStringUtil::null); childSetEnabled("Creator Name",false); childSetEnabled("button creator profile",false); childSetEnabled("Owner:",false); childSetText("Owner Name",LLStringUtil::null); childSetEnabled("Owner Name",false); childSetEnabled("button owner profile",false); childSetEnabled("Group:",false); childSetText("Group Name",LLStringUtil::null); childSetEnabled("Group Name",false); childSetEnabled("button set group",false); childSetText("Object Name",LLStringUtil::null); childSetEnabled("Object Name",false); childSetEnabled("Name:",false); childSetText("Group Name",LLStringUtil::null); childSetEnabled("Group Name",false); childSetEnabled("Description:",false); childSetText("Object Description",LLStringUtil::null); childSetEnabled("Object Description",false); childSetEnabled("Permissions:",false); childSetValue("checkbox share with group",FALSE); childSetEnabled("checkbox share with group",false); childSetEnabled("button deed",false); childSetValue("checkbox allow everyone move",FALSE); childSetEnabled("checkbox allow everyone move",false); childSetValue("checkbox allow everyone copy",FALSE); childSetEnabled("checkbox allow everyone copy",false); //Next owner can: childSetEnabled("Next owner can:",false); childSetValue("checkbox next owner can modify",FALSE); childSetEnabled("checkbox next owner can modify",false); childSetValue("checkbox next owner can copy",FALSE); childSetEnabled("checkbox next owner can copy",false); childSetValue("checkbox next owner can transfer",FALSE); childSetEnabled("checkbox next owner can transfer",false); //checkbox for sale childSetValue("checkbox for sale",FALSE); childSetEnabled("checkbox for sale",false); //checkbox include in search childSetValue("search_check", FALSE); childSetEnabled("search_check", false); LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type"); if(RadioSaleType) { RadioSaleType->setSelectedIndex(-1); RadioSaleType->setEnabled(FALSE); } childSetEnabled("Cost",false); childSetText("Cost",getString("Cost Default")); childSetText("Edit Cost",LLStringUtil::null); childSetEnabled("Edit Cost",false); childSetEnabled("label click action",false); LLComboBox* ComboClickAction = getChild<LLComboBox>("clickaction"); if(ComboClickAction) { ComboClickAction->setEnabled(FALSE); ComboClickAction->clear(); } childSetVisible("B:",false); childSetVisible("O:",false); childSetVisible("G:",false); childSetVisible("E:",false); childSetVisible("N:",false); childSetVisible("F:",false); return; } // figure out a few variables BOOL is_one_object = (object_count == 1); // BUG: fails if a root and non-root are both single-selected. BOOL is_perm_modify = (LLSelectMgr::getInstance()->getSelection()->getFirstRootNode() && LLSelectMgr::getInstance()->selectGetRootsModify()) || LLSelectMgr::getInstance()->selectGetModify(); const LLFocusableElement* keyboard_focus_view = gFocusMgr.getKeyboardFocus(); S32 string_index = 0; std::string MODIFY_INFO_STRINGS[] = { getString("text modify info 1"), getString("text modify info 2"), getString("text modify info 3"), getString("text modify info 4") }; if(!is_perm_modify) { string_index += 2; } if(!is_one_object) { ++string_index; } childSetEnabled("perm_modify",true); childSetText("perm_modify",MODIFY_INFO_STRINGS[string_index]); childSetEnabled("Permissions:",true); // Update creator text field childSetEnabled("Creator:",true); BOOL creators_identical; std::string creator_name; creators_identical = LLSelectMgr::getInstance()->selectGetCreator(mCreatorID, creator_name); childSetText("Creator Name",creator_name); childSetEnabled("Creator Name",TRUE); childSetEnabled("button creator profile", creators_identical && mCreatorID.notNull() ); // Update owner text field childSetEnabled("Owner:",true); BOOL owners_identical; std::string owner_name; owners_identical = LLSelectMgr::getInstance()->selectGetOwner(mOwnerID, owner_name); // llinfos << "owners_identical " << (owners_identical ? "TRUE": "FALSE") << llendl; if (mOwnerID.isNull()) { if(LLSelectMgr::getInstance()->selectIsGroupOwned()) { // Group owned already displayed by selectGetOwner } else { // Display last owner if public std::string last_owner_name; LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name); // It should never happen that the last owner is null and the owner // is null, but it seems to be a bug in the simulator right now. JC if (!mLastOwnerID.isNull() && !last_owner_name.empty()) { owner_name.append(", last "); owner_name.append( last_owner_name ); } } } childSetText("Owner Name",owner_name); childSetEnabled("Owner Name",TRUE); childSetEnabled("button owner profile",owners_identical && (mOwnerID.notNull() || LLSelectMgr::getInstance()->selectIsGroupOwned())); // update group text field childSetEnabled("Group:",true); childSetText("Group Name",LLStringUtil::null); LLUUID group_id; BOOL groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id); if (groups_identical) { if(mLabelGroupName) { mLabelGroupName->setNameID(group_id, TRUE); mLabelGroupName->setEnabled(TRUE); } } else { if(mLabelGroupName) { mLabelGroupName->setNameID(LLUUID::null, TRUE); mLabelGroupName->refresh(LLUUID::null, LLStringUtil::null, LLStringUtil::null, TRUE); mLabelGroupName->setEnabled(FALSE); } } childSetEnabled("button set group",owners_identical && (mOwnerID == gAgent.getID())); // figure out the contents of the name, description, & category BOOL edit_name_desc = FALSE; if(is_one_object && objectp->permModify()) { edit_name_desc = TRUE; } childSetEnabled("Name:",true); LLLineEditor* LineEditorObjectName = getChild<LLLineEditor>("Object Name"); childSetEnabled("Description:",true); LLLineEditor* LineEditorObjectDesc = getChild<LLLineEditor>("Object Description"); if(is_one_object) { if(keyboard_focus_view != LineEditorObjectName) { childSetText("Object Name",nodep->mName); } if(LineEditorObjectDesc) { if(keyboard_focus_view != LineEditorObjectDesc) { LineEditorObjectDesc->setText(nodep->mDescription); } } } else { childSetText("Object Name",LLStringUtil::null); LineEditorObjectDesc->setText(LLStringUtil::null); } if(edit_name_desc) { childSetEnabled("Object Name",true); childSetEnabled("Object Description",true); } else { childSetEnabled("Object Name",false); childSetEnabled("Object Description",false); } S32 total_sale_price = 0; S32 individual_sale_price = 0; BOOL is_for_sale_mixed = FALSE; BOOL is_sale_price_mixed = FALSE; U32 num_for_sale = FALSE; LLSelectMgr::getInstance()->selectGetAggregateSaleInfo(num_for_sale, is_for_sale_mixed, is_sale_price_mixed, total_sale_price, individual_sale_price); const BOOL self_owned = (gAgent.getID() == mOwnerID); const BOOL group_owned = LLSelectMgr::getInstance()->selectIsGroupOwned() ; const BOOL public_owned = (mOwnerID.isNull() && !LLSelectMgr::getInstance()->selectIsGroupOwned()); const BOOL can_transfer = LLSelectMgr::getInstance()->selectGetRootsTransfer(); const BOOL can_copy = LLSelectMgr::getInstance()->selectGetRootsCopy(); if(!owners_identical) { childSetEnabled("Cost",false); childSetText("Edit Cost",LLStringUtil::null); childSetEnabled("Edit Cost",false); } // You own these objects. else if(self_owned || (group_owned && gAgent.hasPowerInGroup(group_id,GP_OBJECT_SET_SALE))) { // If there are multiple items for sale then set text to PRICE PER UNIT. if (num_for_sale > 1) { childSetText("Cost",getString("Cost Per Unit")); } else { childSetText("Cost",getString("Cost Default")); } LLLineEditor *editPrice = getChild<LLLineEditor>("Edit Cost"); if(keyboard_focus_view != editPrice) { // If the sale price is mixed then set the cost to MIXED, otherwise // set to the actual cost. if (num_for_sale > 0 && is_for_sale_mixed) { childSetText("Edit Cost",getString("Sale Mixed")); } else if (num_for_sale > 0 && is_sale_price_mixed) { childSetText("Edit Cost",getString("Cost Mixed")); } else { childSetText("Edit Cost",llformat("%d",individual_sale_price)); } } // The edit fields are only enabled if you can sell this object // and the sale price is not mixed. bool enable_edit = (num_for_sale && can_transfer) ? !is_for_sale_mixed : false; childSetEnabled("Cost",enable_edit); childSetEnabled("Edit Cost",enable_edit); } // Someone, not you, owns these objects. else if(!public_owned) { childSetEnabled("Cost",false); childSetEnabled("Edit Cost",false); // Don't show a price if none of the items are for sale. if (num_for_sale) childSetText("Edit Cost",llformat("%d",total_sale_price)); else childSetText("Edit Cost",LLStringUtil::null); // If multiple items are for sale, set text to TOTAL PRICE. if (num_for_sale > 1) childSetText("Cost",getString("Cost Total")); else childSetText("Cost",getString("Cost Default")); } // This is a public object. else { childSetEnabled("Cost",false); childSetText("Cost",getString("Cost Default")); childSetText("Edit Cost",LLStringUtil::null); childSetEnabled("Edit Cost",false); } // Enable and disable the permissions checkboxes // based on who owns the object. // TODO: Creator permissions BOOL valid_base_perms = FALSE; BOOL valid_owner_perms = FALSE; BOOL valid_group_perms = FALSE; BOOL valid_everyone_perms = FALSE; BOOL valid_next_perms = FALSE; U32 base_mask_on; U32 base_mask_off; U32 owner_mask_on; U32 owner_mask_off; U32 group_mask_on; U32 group_mask_off; U32 everyone_mask_on; U32 everyone_mask_off; U32 next_owner_mask_on = 0; U32 next_owner_mask_off = 0; valid_base_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_BASE, &base_mask_on, &base_mask_off); valid_owner_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER, &owner_mask_on, &owner_mask_off); valid_group_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP, &group_mask_on, &group_mask_off); valid_everyone_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE, &everyone_mask_on, &everyone_mask_off); valid_next_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_NEXT_OWNER, &next_owner_mask_on, &next_owner_mask_off); if( gSavedSettings.getBOOL("DebugPermissions") ) { std::string perm_string; if (valid_base_perms) { perm_string = "B: "; perm_string += mask_to_string(base_mask_on); childSetText("B:",perm_string); childSetVisible("B:",true); perm_string = "O: "; perm_string += mask_to_string(owner_mask_on); childSetText("O:",perm_string); childSetVisible("O:",true); perm_string = "G: "; perm_string += mask_to_string(group_mask_on); childSetText("G:",perm_string); childSetVisible("G:",true); perm_string = "E: "; perm_string += mask_to_string(everyone_mask_on); childSetText("E:",perm_string); childSetVisible("E:",true); perm_string = "N: "; perm_string += mask_to_string(next_owner_mask_on); childSetText("N:",perm_string); childSetVisible("N:",true); } perm_string = "F: "; U32 flag_mask = 0x0; if (objectp->permMove()) flag_mask |= PERM_MOVE; if (objectp->permModify()) flag_mask |= PERM_MODIFY; if (objectp->permCopy()) flag_mask |= PERM_COPY; if (objectp->permTransfer()) flag_mask |= PERM_TRANSFER; perm_string += mask_to_string(flag_mask); childSetText("F:",perm_string); childSetVisible("F:",true); } else { childSetVisible("B:",false); childSetVisible("O:",false); childSetVisible("G:",false); childSetVisible("E:",false); childSetVisible("N:",false); childSetVisible("F:",false); } bool has_change_perm_ability = false; bool has_change_sale_ability = false; if(valid_base_perms && (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_MANIPULATE)))) { has_change_perm_ability = true; } if(valid_base_perms && (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_SET_SALE)))) { has_change_sale_ability = true; } if (!has_change_perm_ability && !has_change_sale_ability && !root_selected) { // ...must select root to choose permissions childSetValue("perm_modify", getString("text modify warning")); } if (has_change_perm_ability) { childSetEnabled("checkbox share with group",true); childSetEnabled("checkbox allow everyone move",owner_mask_on & PERM_MOVE); childSetEnabled("checkbox allow everyone copy",owner_mask_on & PERM_COPY && owner_mask_on & PERM_TRANSFER); } else { childSetEnabled("checkbox share with group", FALSE); childSetEnabled("checkbox allow everyone move", FALSE); childSetEnabled("checkbox allow everyone copy", FALSE); } if (has_change_sale_ability && (owner_mask_on & PERM_TRANSFER)) { childSetEnabled("checkbox for sale", can_transfer || (!can_transfer && num_for_sale)); // Set the checkbox to tentative if the prices of each object selected // are not the same. childSetTentative("checkbox for sale", is_for_sale_mixed); childSetEnabled("sale type",num_for_sale && can_transfer && !is_sale_price_mixed); childSetEnabled("Next owner can:", TRUE); childSetEnabled("checkbox next owner can modify",base_mask_on & PERM_MODIFY); childSetEnabled("checkbox next owner can copy",base_mask_on & PERM_COPY); childSetEnabled("checkbox next owner can transfer",next_owner_mask_on & PERM_COPY); } else { childSetEnabled("checkbox for sale",FALSE); childSetEnabled("sale type",FALSE); childSetEnabled("Next owner can:",FALSE); childSetEnabled("checkbox next owner can modify",FALSE); childSetEnabled("checkbox next owner can copy",FALSE); childSetEnabled("checkbox next owner can transfer",FALSE); } if(valid_group_perms) { if((group_mask_on & PERM_COPY) && (group_mask_on & PERM_MODIFY) && (group_mask_on & PERM_MOVE)) { childSetValue("checkbox share with group",TRUE); childSetTentative("checkbox share with group",FALSE); childSetEnabled("button deed",gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer); } else if((group_mask_off & PERM_COPY) && (group_mask_off & PERM_MODIFY) && (group_mask_off & PERM_MOVE)) { childSetValue("checkbox share with group",FALSE); childSetTentative("checkbox share with group",false); childSetEnabled("button deed",false); } else { childSetValue("checkbox share with group",TRUE); childSetTentative("checkbox share with group",true); childSetEnabled("button deed",gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (group_mask_on & PERM_MOVE) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer); } } if(valid_everyone_perms) { // Move if(everyone_mask_on & PERM_MOVE) { childSetValue("checkbox allow everyone move",TRUE); childSetTentative("checkbox allow everyone move",false); } else if(everyone_mask_off & PERM_MOVE) { childSetValue("checkbox allow everyone move",FALSE); childSetTentative("checkbox allow everyone move",false); } else { childSetValue("checkbox allow everyone move",TRUE); childSetTentative("checkbox allow everyone move",true); } // Copy == everyone can't copy if(everyone_mask_on & PERM_COPY) { childSetValue("checkbox allow everyone copy",TRUE); childSetTentative("checkbox allow everyone copy",!can_copy || !can_transfer); } else if(everyone_mask_off & PERM_COPY) { childSetValue("checkbox allow everyone copy",FALSE); childSetTentative("checkbox allow everyone copy",false); } else { childSetValue("checkbox allow everyone copy",TRUE); childSetTentative("checkbox allow everyone copy",true); } } if(valid_next_perms) { // Modify == next owner canot modify if(next_owner_mask_on & PERM_MODIFY) { childSetValue("checkbox next owner can modify",TRUE); childSetTentative("checkbox next owner can modify",false); } else if(next_owner_mask_off & PERM_MODIFY) { childSetValue("checkbox next owner can modify",FALSE); childSetTentative("checkbox next owner can modify",false); } else { childSetValue("checkbox next owner can modify",TRUE); childSetTentative("checkbox next owner can modify",true); } // Copy == next owner cannot copy if(next_owner_mask_on & PERM_COPY) { childSetValue("checkbox next owner can copy",TRUE); childSetTentative("checkbox next owner can copy",!can_copy); } else if(next_owner_mask_off & PERM_COPY) { childSetValue("checkbox next owner can copy",FALSE); childSetTentative("checkbox next owner can copy",FALSE); } else { childSetValue("checkbox next owner can copy",TRUE); childSetTentative("checkbox next owner can copy",TRUE); } // Transfer == next owner cannot transfer if(next_owner_mask_on & PERM_TRANSFER) { childSetValue("checkbox next owner can transfer",TRUE); childSetTentative("checkbox next owner can transfer",!can_transfer); } else if(next_owner_mask_off & PERM_TRANSFER) { childSetValue("checkbox next owner can transfer",FALSE); childSetTentative("checkbox next owner can transfer",FALSE); } else { childSetValue("checkbox next owner can transfer",TRUE); childSetTentative("checkbox next owner can transfer",TRUE); } } // reflect sale information LLSaleInfo sale_info; BOOL valid_sale_info = LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info); LLSaleInfo::EForSale sale_type = sale_info.getSaleType(); LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("sale type"); if(RadioSaleType) { if (valid_sale_info) { RadioSaleType->setSelectedIndex((S32)sale_type - 1); RadioSaleType->setTentative(FALSE); // unfortunately this doesn't do anything at the moment. } else { // default option is sell copy, determined to be safest RadioSaleType->setSelectedIndex((S32)LLSaleInfo::FS_COPY - 1); RadioSaleType->setTentative(TRUE); // unfortunately this doesn't do anything at the moment. } } childSetValue("checkbox for sale", num_for_sale != 0); // HACK: There are some old objects in world that are set for sale, // but are no-transfer. We need to let users turn for-sale off, but only // if for-sale is set. bool cannot_actually_sell = !can_transfer || (!can_copy && sale_type == LLSaleInfo::FS_COPY); if (num_for_sale && has_change_sale_ability && cannot_actually_sell) { childSetEnabled("checkbox for sale", true); } // Check search status of objects BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME ); bool include_in_search; bool all_include_in_search = LLSelectMgr::getInstance()->selectionGetIncludeInSearch(&include_in_search); childSetEnabled("search_check", has_change_sale_ability && all_volume); childSetValue("search_check", include_in_search); childSetTentative("search_check", ! all_include_in_search); // Click action (touch, sit, buy) U8 click_action = 0; if (LLSelectMgr::getInstance()->selectionGetClickAction(&click_action)) { LLComboBox* ComboClickAction = getChild<LLComboBox>("clickaction"); if(ComboClickAction) { ComboClickAction->setCurrentByIndex((S32)click_action); } } childSetEnabled("label click action",is_perm_modify && all_volume); childSetEnabled("clickaction",is_perm_modify && all_volume); }
void LLFloaterProperties::refreshFromItem(LLInventoryItem* item) { // <edit> childSetText("EditItemID", item->getUUID().asString()); childSetText("EditFolderID", item->getParentUUID().asString()); childSetText("EditGroup", item->getPermissions().getGroup().asString()); childSetText("EditAssetID", item->getAssetUUID().asString()); std::string type_str = LLAssetType::lookup(item->getType()); if(type_str.c_str() == NULL) type_str = llformat("%d", item->getType()); childSetText("EditType", type_str); std::string invtype_str = LLInventoryType::lookup(item->getInventoryType()); if(invtype_str.c_str() == NULL) invtype_str = llformat("%d", item->getInventoryType()); childSetText("EditInvType", invtype_str); childSetText("EditFlags", llformat("%d", item->getFlags())); std::ostringstream strm; item->exportLegacyStream(strm, TRUE); std::string str(strm.str()); LLStringUtil::replaceTabsWithSpaces(str, 4); childSetText("item_text", str); // </edit> //////////////////////// // PERMISSIONS LOOKUP // //////////////////////// // do not enable the UI for incomplete items. LLViewerInventoryItem* i = (LLViewerInventoryItem*)item; BOOL is_complete = i->isComplete(); const LLPermissions& perm = item->getPermissions(); BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm, GP_OBJECT_MANIPULATE); BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm, GP_OBJECT_SET_SALE); // You need permission to modify the object to modify an inventory // item in it. LLViewerObject* object = NULL; if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID); BOOL is_obj_modify = TRUE; if(object) { is_obj_modify = object->permOwnerModify(); } ////////////////////// // ITEM NAME & DESC // ////////////////////// BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm, GP_OBJECT_MANIPULATE) && is_obj_modify && is_complete; childSetEnabled("LabelItemNameTitle",TRUE); childSetEnabled("LabelItemName",is_modifiable); childSetText("LabelItemName",item->getName()); childSetEnabled("LabelItemDescTitle",TRUE); childSetEnabled("LabelItemDesc",is_modifiable); childSetVisible("IconLocked",!is_modifiable); childSetText("LabelItemDesc",item->getDescription()); ////////////////// // CREATOR NAME // ////////////////// if(!gCacheName) return; if(!gAgent.getRegion()) return; if (item->getCreatorUUID().notNull()) { std::string name; gCacheName->getFullName(item->getCreatorUUID(), name); childSetEnabled("BtnCreator",TRUE); childSetEnabled("LabelCreatorTitle",TRUE); childSetEnabled("LabelCreatorName",TRUE); childSetText("LabelCreatorName",name); } else { childSetEnabled("BtnCreator",FALSE); childSetEnabled("LabelCreatorTitle",FALSE); childSetEnabled("LabelCreatorName",FALSE); childSetText("LabelCreatorName",getString("unknown")); } //////////////// // OWNER NAME // //////////////// if(perm.isOwned()) { std::string name; if (perm.isGroupOwned()) { gCacheName->getGroupName(perm.getGroup(), name); } else { gCacheName->getFullName(perm.getOwner(), name); } childSetEnabled("BtnOwner",TRUE); childSetEnabled("LabelOwnerTitle",TRUE); childSetEnabled("LabelOwnerName",TRUE); childSetText("LabelOwnerName",name); } else { childSetEnabled("BtnOwner",FALSE); childSetEnabled("LabelOwnerTitle",FALSE); childSetEnabled("LabelOwnerName",FALSE); childSetText("LabelOwnerName",getString("public")); } ////////////////// // ACQUIRE DATE // ////////////////// // *TODO: Localize / translate this time_t time_utc = item->getCreationDate(); if (0 == time_utc) { childSetText("LabelAcquiredDate",getString("unknown")); } else { std::string timestr; timeToFormattedString(time_utc, gSavedSettings.getString("TimestampFormat"), timestr); childSetText("LabelAcquiredDate", timestr); } /////////////////////// // OWNER PERMISSIONS // /////////////////////// if(can_agent_manipulate) { childSetText("OwnerLabel",getString("you_can")); } else { childSetText("OwnerLabel",getString("owner_can")); } U32 base_mask = perm.getMaskBase(); U32 owner_mask = perm.getMaskOwner(); U32 group_mask = perm.getMaskGroup(); U32 everyone_mask = perm.getMaskEveryone(); U32 next_owner_mask = perm.getMaskNextOwner(); childSetEnabled("OwnerLabel",TRUE); childSetEnabled("CheckOwnerModify",FALSE); childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY))); childSetEnabled("CheckOwnerCopy",FALSE); childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY))); childSetEnabled("CheckOwnerTransfer",FALSE); childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER))); /////////////////////// // DEBUG PERMISSIONS // /////////////////////// if( gSavedSettings.getBOOL("DebugPermissions") ) { BOOL slam_perm = FALSE; BOOL overwrite_group = FALSE; BOOL overwrite_everyone = FALSE; if (item->getType() == LLAssetType::AT_OBJECT) { U32 flags = item->getFlags(); slam_perm = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM; overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE; overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP; } std::string perm_string; perm_string = "B: "; perm_string += mask_to_string(base_mask); childSetText("BaseMaskDebug",perm_string); childSetVisible("BaseMaskDebug",TRUE); perm_string = "O: "; perm_string += mask_to_string(owner_mask); childSetText("OwnerMaskDebug",perm_string); childSetVisible("OwnerMaskDebug",TRUE); perm_string = "G"; perm_string += overwrite_group ? "*: " : ": "; perm_string += mask_to_string(group_mask); childSetText("GroupMaskDebug",perm_string); childSetVisible("GroupMaskDebug",TRUE); perm_string = "E"; perm_string += overwrite_everyone ? "*: " : ": "; perm_string += mask_to_string(everyone_mask); childSetText("EveryoneMaskDebug",perm_string); childSetVisible("EveryoneMaskDebug",TRUE); perm_string = "N"; perm_string += slam_perm ? "*: " : ": "; perm_string += mask_to_string(next_owner_mask); childSetText("NextMaskDebug",perm_string); childSetVisible("NextMaskDebug",TRUE); } else { childSetVisible("BaseMaskDebug",FALSE); childSetVisible("OwnerMaskDebug",FALSE); childSetVisible("GroupMaskDebug",FALSE); childSetVisible("EveryoneMaskDebug",FALSE); childSetVisible("NextMaskDebug",FALSE); } ///////////// // SHARING // ///////////// // Check for ability to change values. if (is_obj_modify && can_agent_manipulate) { childSetEnabled("CheckShareWithGroup",TRUE); childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER)); } else { childSetEnabled("CheckShareWithGroup",FALSE); childSetEnabled("CheckEveryoneCopy",FALSE); } // Set values. BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE; BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE; BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE; if (is_group_copy && is_group_modify && is_group_move) { childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE)); LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(FALSE); } } else if (!is_group_copy && !is_group_modify && !is_group_move) { childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE)); LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(FALSE); } } else { LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(TRUE); ctl->set(TRUE); } } childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY))); /////////////// // SALE INFO // /////////////// const LLSaleInfo& sale_info = item->getSaleInfo(); BOOL is_for_sale = sale_info.isForSale(); // Check for ability to change values. if (is_obj_modify && can_agent_sell && gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE)) { childSetEnabled("SaleLabel",is_complete); childSetEnabled("CheckPurchase",is_complete); childSetEnabled("NextOwnerLabel",TRUE); childSetEnabled("CheckNextOwnerModify",base_mask & PERM_MODIFY); childSetEnabled("CheckNextOwnerCopy",base_mask & PERM_COPY); childSetEnabled("CheckNextOwnerTransfer",next_owner_mask & PERM_COPY); childSetEnabled("RadioSaleType",is_complete && is_for_sale); childSetEnabled("TextPrice",is_complete && is_for_sale); childSetEnabled("EditPrice",is_complete && is_for_sale); } else { childSetEnabled("SaleLabel",FALSE); childSetEnabled("CheckPurchase",FALSE); childSetEnabled("NextOwnerLabel",FALSE); childSetEnabled("CheckNextOwnerModify",FALSE); childSetEnabled("CheckNextOwnerCopy",FALSE); childSetEnabled("CheckNextOwnerTransfer",FALSE); childSetEnabled("RadioSaleType",FALSE); childSetEnabled("TextPrice",FALSE); childSetEnabled("EditPrice",FALSE); } // Set values. childSetValue("CheckPurchase", is_for_sale); childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY))); childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY))); childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER))); LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType"); if (is_for_sale) { radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1); S32 numerical_price; numerical_price = sale_info.getSalePrice(); childSetText("EditPrice",llformat("%d",numerical_price)); } else { radioSaleType->setSelectedIndex(-1); childSetText("EditPrice",llformat("%d",0)); } }
void LLFloaterProperties::updateSaleInfo() { LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem(); if(!item) return; LLSaleInfo sale_info(item->getSaleInfo()); if(!gAgent.allowOperation(PERM_TRANSFER, item->getPermissions(), GP_OBJECT_SET_SALE)) { childSetValue("CheckPurchase",LLSD((BOOL)FALSE)); } if((BOOL)childGetValue("CheckPurchase")) { // turn on sale info LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_COPY; LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("RadioSaleType"); if(RadioSaleType) { switch (RadioSaleType->getSelectedIndex()) { case 0: sale_type = LLSaleInfo::FS_ORIGINAL; break; case 1: sale_type = LLSaleInfo::FS_COPY; break; case 2: sale_type = LLSaleInfo::FS_CONTENTS; break; default: sale_type = LLSaleInfo::FS_COPY; break; } } if (sale_type == LLSaleInfo::FS_COPY && !gAgent.allowOperation(PERM_COPY, item->getPermissions(), GP_OBJECT_SET_SALE)) { sale_type = LLSaleInfo::FS_ORIGINAL; } LLLineEditor* EditPrice = getChild<LLLineEditor>("EditPrice"); S32 price = -1; if(EditPrice) { price = atoi(EditPrice->getText().c_str()); } // Invalid data - turn off the sale if (price < 0) { sale_type = LLSaleInfo::FS_NOT; price = 0; } sale_info.setSaleType(sale_type); sale_info.setSalePrice(price); } else { sale_info.setSaleType(LLSaleInfo::FS_NOT); } if(sale_info != item->getSaleInfo() && item->isComplete()) { LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item); // Force an update on the sale price at rez if (item->getType() == LLAssetType::AT_OBJECT) { U32 flags = new_item->getFlags(); flags |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_SALE; new_item->setFlags(flags); } new_item->setSaleInfo(sale_info); if(mObjectID.isNull()) { // This is in the agent's inventory. new_item->updateServer(FALSE); gInventory.updateItem(new_item); gInventory.notifyObservers(); } else { // This is in an object's contents. LLViewerObject* object = gObjectList.findObject(mObjectID); if(object) { object->updateInventory( new_item, TASK_INVENTORY_ITEM_KEY, false); } } } else { // need to make sure we don't just follow the click refresh(); } }
BOOL LLPanelDirFind::postBuild() { LLPanelDirBrowser::postBuild(); childSetAction("back_btn", onClickBack, this); childSetAction("home_btn", onClickHome, this); childSetAction("forward_btn", onClickForward, this); childSetAction("reload_btn", onClickRefresh, this); childSetCommitCallback("search_editor", onCommitSearch, this); childSetAction("search_btn", onClickSearch, this); childSetAction("?", onClickHelp, this); // showcase doesn't have maturity flags -- it's all PG if (hasChild("incmature")) { // Teens don't get mature checkbox if (gAgent.wantsPGOnly()) { childSetValue("incmature", FALSE); childSetValue("incadult", FALSE); childHide("incmature"); childHide("incadult"); childSetValue("incpg", TRUE); childDisable("incpg"); } if (!gAgent.canAccessMature()) { childSetValue("incmature", FALSE); childDisable("incmature"); } if (!gAgent.canAccessAdult()) { childSetValue("incadult", FALSE); childDisable("incadult"); } } mWebBrowser = getChild<LLMediaCtrl>(mBrowserName); if (mWebBrowser) { mWebBrowser->addObserver(this); // new pages appear in same window as the results page now mWebBrowser->setOpenInInternalBrowser( false ); mWebBrowser->setOpenInExternalBrowser( false ); // need to handle secondlife:///app/ URLs for direct teleports mWebBrowser->setTrusted( true ); // redirect 404 pages from S3 somewhere else mWebBrowser->set404RedirectUrl( getString("redirect_404_url") ); navigateToDefaultPage(); } childSetVisible("filter_gaming", (gAgent.getRegion()->getGamingFlags() & REGION_GAMING_PRESENT) && !(gAgent.getRegion()->getGamingFlags() & REGION_GAMING_HIDE_FIND_ALL)); return TRUE; }
void LLFloaterInventoryFinder::updateElementsFromFilter() { if (!mFilter) return; // Get data needed for filter display U32 filter_types = mFilter->getFilterObjectTypes(); std::string filter_string = mFilter->getFilterSubString(); LLInventoryFilter::EFolderShow show_folders = mFilter->getShowFolderState(); U32 hours = mFilter->getHoursAgo(); // update the ui elements setTitle(mFilter->getName()); childSetValue("check_animation", (S32) (filter_types & 0x1 << LLInventoryType::IT_ANIMATION)); childSetValue("check_calling_card", (S32) (filter_types & 0x1 << LLInventoryType::IT_CALLINGCARD)); childSetValue("check_clothing", (S32) (filter_types & 0x1 << LLInventoryType::IT_WEARABLE)); childSetValue("check_gesture", (S32) (filter_types & 0x1 << LLInventoryType::IT_GESTURE)); childSetValue("check_landmark", (S32) (filter_types & 0x1 << LLInventoryType::IT_LANDMARK)); childSetValue("check_notecard", (S32) (filter_types & 0x1 << LLInventoryType::IT_NOTECARD)); childSetValue("check_object", (S32) (filter_types & 0x1 << LLInventoryType::IT_OBJECT)); childSetValue("check_script", (S32) (filter_types & 0x1 << LLInventoryType::IT_LSL)); childSetValue("check_sound", (S32) (filter_types & 0x1 << LLInventoryType::IT_SOUND)); childSetValue("check_texture", (S32) (filter_types & 0x1 << LLInventoryType::IT_TEXTURE)); childSetValue("check_snapshot", (S32) (filter_types & 0x1 << LLInventoryType::IT_SNAPSHOT)); childSetValue("check_show_empty", show_folders == LLInventoryFilter::SHOW_ALL_FOLDERS); childSetValue("check_since_logoff", mFilter->isSinceLogoff()); mSpinSinceHours->set((F32)(hours % 24)); mSpinSinceDays->set((F32)(hours / 24)); }
void LLChatBar::sendChat( EChatType type ) { if (mInputEditor) { LLWString text = mInputEditor->getConvertedText(); if (!text.empty()) { // store sent line in history, duplicates will get filtered if (mInputEditor) mInputEditor->updateHistory(); // Check if this is destined for another channel S32 channel = mChanCtrlEnabled ? (S32)(mChannelControl->get()) : 0; stripChannelNumber(text, &channel); std::string utf8text = wstring_to_utf8str(text); // Try to trigger a gesture, if not chat to a script. std::string utf8_revised_text; if (0 == channel) { if (gSavedSettings.getBOOL("AutoCloseOOC")) { // Try to find any unclosed OOC chat (i.e. an opening // double parenthesis without a matching closing double // parenthesis. if (utf8text.find("((") != -1 && utf8text.find("))") == -1) { if (utf8text.at(utf8text.length() - 1) == ')') { // cosmetic: add a space first to avoid a closing triple parenthesis utf8text += " "; } // add the missing closing double parenthesis. utf8text += "))"; } } // Convert MU*s style poses into IRC emotes here. if (gSavedSettings.getBOOL("AllowMUpose") && utf8text.find(":") == 0 && utf8text.length() > 3) { if (utf8text.find(":'") == 0) { utf8text.replace(0, 1, "/me"); } else if (isalpha(utf8text.at(1))) // Do not prevent smileys and such. { utf8text.replace(0, 1, "/me "); } } // discard returned "found" boolean gGestureManager.triggerAndReviseString(utf8text, &utf8_revised_text); } else { utf8_revised_text = utf8text; } utf8_revised_text = utf8str_trim(utf8_revised_text); if (!utf8_revised_text.empty()) if (!utf8_revised_text.empty() && cmd_line_chat(utf8_revised_text, type)) { // Chat with animation sendChatFromViewer(utf8_revised_text, type, TRUE); } } } childSetValue("Chat Editor", LLStringUtil::null); gAgent.stopTyping(); // If the user wants to stop chatting on hitting return, lose focus // and go out of chat mode. if (gChatBar == this && gSavedSettings.getBOOL("CloseChatOnReturn")) { stopChat(); } }
void LLSidepanelItemInfo::refreshFromItem(LLViewerInventoryItem* item) { //////////////////////// // PERMISSIONS LOOKUP // //////////////////////// llassert(item); if (!item) return; // do not enable the UI for incomplete items. BOOL is_complete = item->isComplete(); const BOOL cannot_restrict_permissions = LLInventoryType::cannotRestrictPermissions(item->getInventoryType()); const BOOL is_calling_card = (item->getInventoryType() == LLInventoryType::IT_CALLINGCARD); const LLPermissions& perm = item->getPermissions(); const BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm, GP_OBJECT_MANIPULATE); const BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm, GP_OBJECT_SET_SALE) && !cannot_restrict_permissions; const BOOL is_link = item->getIsLinkType(); const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH); bool not_in_trash = (item->getUUID() != trash_id) && !gInventory.isObjectDescendentOf(item->getUUID(), trash_id); // You need permission to modify the object to modify an inventory // item in it. LLViewerObject* object = NULL; if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID); BOOL is_obj_modify = TRUE; if(object) { is_obj_modify = object->permOwnerModify(); } ////////////////////// // ITEM NAME & DESC // ////////////////////// BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm, GP_OBJECT_MANIPULATE) && is_obj_modify && is_complete && not_in_trash; childSetEnabled("LabelItemNameTitle",TRUE); childSetEnabled("LabelItemName",is_modifiable && !is_calling_card); // for now, don't allow rename of calling cards childSetText("LabelItemName",item->getName()); childSetEnabled("LabelItemDescTitle",TRUE); childSetEnabled("LabelItemDesc",is_modifiable); childSetVisible("IconLocked",!is_modifiable); childSetText("LabelItemDesc",item->getDescription()); ////////////////// // CREATOR NAME // ////////////////// if(!gCacheName) return; if(!gAgent.getRegion()) return; if (item->getCreatorUUID().notNull()) { std::string name; gCacheName->getFullName(item->getCreatorUUID(), name); childSetEnabled("BtnCreator",TRUE); childSetEnabled("LabelCreatorTitle",TRUE); childSetEnabled("LabelCreatorName",TRUE); childSetText("LabelCreatorName",name); } else { childSetEnabled("BtnCreator",FALSE); childSetEnabled("LabelCreatorTitle",FALSE); childSetEnabled("LabelCreatorName",FALSE); childSetText("LabelCreatorName",getString("unknown")); } //////////////// // OWNER NAME // //////////////// if(perm.isOwned()) { std::string name; if (perm.isGroupOwned()) { gCacheName->getGroupName(perm.getGroup(), name); } else { gCacheName->getFullName(perm.getOwner(), name); } childSetEnabled("BtnOwner",TRUE); childSetEnabled("LabelOwnerTitle",TRUE); childSetEnabled("LabelOwnerName",TRUE); childSetText("LabelOwnerName",name); } else { childSetEnabled("BtnOwner",FALSE); childSetEnabled("LabelOwnerTitle",FALSE); childSetEnabled("LabelOwnerName",FALSE); childSetText("LabelOwnerName",getString("public")); } ////////////////// // ACQUIRE DATE // ////////////////// time_t time_utc = item->getCreationDate(); if (0 == time_utc) { childSetText("LabelAcquiredDate",getString("unknown")); } else { std::string timeStr = getString("acquiredDate"); LLSD substitution; substitution["datetime"] = (S32) time_utc; LLStringUtil::format (timeStr, substitution); childSetText ("LabelAcquiredDate", timeStr); } ///////////////////////////////////// // PERMISSIONS AND SALE ITEM HIDING ///////////////////////////////////// const std::string perm_and_sale_items[]={ "perms_inv", "OwnerLabel", "perm_modify", "CheckOwnerModify", "CheckOwnerCopy", "CheckOwnerTransfer", "GroupLabel", "CheckShareWithGroup", "AnyoneLabel", "CheckEveryoneCopy", "NextOwnerLabel", "CheckNextOwnerModify", "CheckNextOwnerCopy", "CheckNextOwnerTransfer", "CheckPurchase", "SaleLabel", "RadioSaleType", "combobox sale copy", "Edit Cost", "TextPrice" }; const std::string debug_items[]={ "BaseMaskDebug", "OwnerMaskDebug", "GroupMaskDebug", "EveryoneMaskDebug", "NextMaskDebug" }; // Hide permissions checkboxes and labels and for sale info if in the trash // or ui elements don't apply to these objects and return from function if (!not_in_trash || cannot_restrict_permissions) { for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t) { childSetVisible(perm_and_sale_items[t],false); } for(size_t t=0; t<LL_ARRAY_SIZE(debug_items); ++t) { childSetVisible(debug_items[t],false); } return; } else // Make sure perms and sale ui elements are visible { for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t) { childSetVisible(perm_and_sale_items[t],true); } } /////////////////////// // OWNER PERMISSIONS // /////////////////////// if(can_agent_manipulate) { childSetText("OwnerLabel",getString("you_can")); } else { childSetText("OwnerLabel",getString("owner_can")); } U32 base_mask = perm.getMaskBase(); U32 owner_mask = perm.getMaskOwner(); U32 group_mask = perm.getMaskGroup(); U32 everyone_mask = perm.getMaskEveryone(); U32 next_owner_mask = perm.getMaskNextOwner(); childSetEnabled("OwnerLabel",TRUE); childSetEnabled("CheckOwnerModify",FALSE); childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY))); childSetEnabled("CheckOwnerCopy",FALSE); childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY))); childSetEnabled("CheckOwnerTransfer",FALSE); childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER))); /////////////////////// // DEBUG PERMISSIONS // /////////////////////// if( gSavedSettings.getBOOL("DebugPermissions") ) { BOOL slam_perm = FALSE; BOOL overwrite_group = FALSE; BOOL overwrite_everyone = FALSE; if (item->getType() == LLAssetType::AT_OBJECT) { U32 flags = item->getFlags(); slam_perm = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM; overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE; overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP; } std::string perm_string; perm_string = "B: "; perm_string += mask_to_string(base_mask); childSetText("BaseMaskDebug",perm_string); childSetVisible("BaseMaskDebug",TRUE); perm_string = "O: "; perm_string += mask_to_string(owner_mask); childSetText("OwnerMaskDebug",perm_string); childSetVisible("OwnerMaskDebug",TRUE); perm_string = "G"; perm_string += overwrite_group ? "*: " : ": "; perm_string += mask_to_string(group_mask); childSetText("GroupMaskDebug",perm_string); childSetVisible("GroupMaskDebug",TRUE); perm_string = "E"; perm_string += overwrite_everyone ? "*: " : ": "; perm_string += mask_to_string(everyone_mask); childSetText("EveryoneMaskDebug",perm_string); childSetVisible("EveryoneMaskDebug",TRUE); perm_string = "N"; perm_string += slam_perm ? "*: " : ": "; perm_string += mask_to_string(next_owner_mask); childSetText("NextMaskDebug",perm_string); childSetVisible("NextMaskDebug",TRUE); } else { childSetVisible("BaseMaskDebug",FALSE); childSetVisible("OwnerMaskDebug",FALSE); childSetVisible("GroupMaskDebug",FALSE); childSetVisible("EveryoneMaskDebug",FALSE); childSetVisible("NextMaskDebug",FALSE); } ///////////// // SHARING // ///////////// // Check for ability to change values. if (is_link || cannot_restrict_permissions) { childSetEnabled("CheckShareWithGroup",FALSE); childSetEnabled("CheckEveryoneCopy",FALSE); } else if (is_obj_modify && can_agent_manipulate) { childSetEnabled("CheckShareWithGroup",TRUE); childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER)); } else { childSetEnabled("CheckShareWithGroup",FALSE); childSetEnabled("CheckEveryoneCopy",FALSE); } // Set values. BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE; BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE; BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE; if (is_group_copy && is_group_modify && is_group_move) { childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE)); LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(FALSE); } } else if (!is_group_copy && !is_group_modify && !is_group_move) { childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE)); LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(FALSE); } } else { LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup"); if(ctl) { ctl->setTentative(TRUE); ctl->set(TRUE); } } childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY))); /////////////// // SALE INFO // /////////////// const LLSaleInfo& sale_info = item->getSaleInfo(); BOOL is_for_sale = sale_info.isForSale(); // Check for ability to change values. if (is_obj_modify && can_agent_sell && gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE)) { childSetEnabled("SaleLabel",is_complete); childSetEnabled("CheckPurchase",is_complete); childSetEnabled("NextOwnerLabel",TRUE); childSetEnabled("CheckNextOwnerModify",(base_mask & PERM_MODIFY) && !cannot_restrict_permissions); childSetEnabled("CheckNextOwnerCopy",(base_mask & PERM_COPY) && !cannot_restrict_permissions); childSetEnabled("CheckNextOwnerTransfer",(next_owner_mask & PERM_COPY) && !cannot_restrict_permissions); childSetEnabled("RadioSaleType",is_complete && is_for_sale); childSetEnabled("TextPrice",is_complete && is_for_sale); childSetEnabled("Edit Cost",is_complete && is_for_sale); } else { childSetEnabled("SaleLabel",FALSE); childSetEnabled("CheckPurchase",FALSE); childSetEnabled("NextOwnerLabel",FALSE); childSetEnabled("CheckNextOwnerModify",FALSE); childSetEnabled("CheckNextOwnerCopy",FALSE); childSetEnabled("CheckNextOwnerTransfer",FALSE); childSetEnabled("RadioSaleType",FALSE); childSetEnabled("TextPrice",FALSE); childSetEnabled("Edit Cost",FALSE); } // Set values. childSetValue("CheckPurchase", is_for_sale); childSetEnabled("combobox sale copy", is_for_sale); childSetEnabled("Edit Cost", is_for_sale); childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY))); childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY))); childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER))); LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType"); if (is_for_sale) { radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1); S32 numerical_price; numerical_price = sale_info.getSalePrice(); childSetText("Edit Cost",llformat("%d",numerical_price)); } else { radioSaleType->setSelectedIndex(-1); childSetText("Edit Cost",llformat("%d",0)); } }
void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, WLColorControl* colorControl) { deactivateAnimator(); LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl); colorControl->i = sldrCtrl->getValueF32(); // only for sliders where we pass a name if(colorControl->hasSliderName) { // set it to the top F32 maxVal = std::max(std::max(colorControl->r, colorControl->g), colorControl->b); F32 iVal; if(colorControl->isSunOrAmbientColor) { iVal = colorControl->i * 3; } else if(colorControl->isBlueHorizonOrDensity) { iVal = colorControl->i * 2; } else { iVal = colorControl->i; } // get the names of the other sliders std::string rName = colorControl->mSliderName; rName.append("R"); std::string gName = colorControl->mSliderName; gName.append("G"); std::string bName = colorControl->mSliderName; bName.append("B"); // handle if at 0 if(iVal == 0) { colorControl->r = 0; colorControl->g = 0; colorControl->b = 0; // if all at the start // set them all to the intensity } else if (maxVal == 0) { colorControl->r = iVal; colorControl->g = iVal; colorControl->b = iVal; } else { // add delta amounts to each F32 delta = (iVal - maxVal) / maxVal; colorControl->r *= (1.0f + delta); colorControl->g *= (1.0f + delta); colorControl->b *= (1.0f + delta); } // divide sun color vals by three if(colorControl->isSunOrAmbientColor) { childSetValue(rName, colorControl->r/3); childSetValue(gName, colorControl->g/3); childSetValue(bName, colorControl->b/3); } else if(colorControl->isBlueHorizonOrDensity) { childSetValue(rName, colorControl->r/2); childSetValue(gName, colorControl->g/2); childSetValue(bName, colorControl->b/2); } else { // set the sliders to the new vals childSetValue(rName, colorControl->r); childSetValue(gName, colorControl->g); childSetValue(bName, colorControl->b); } } // now update the current parameters and send them to shaders colorControl->update(LLWLParamManager::instance()->mCurParams); LLWLParamManager::instance()->propagateParameters(); }
void LLPanelRegionTools::setPricePerMeter(S32 price) { childSetValue("land cost", price); }
void LLPanelActiveSpeakers::refreshSpeakers() { // store off current selection and scroll state to preserve across list rebuilds LLUUID selected_id = mSpeakerList->getSelectedValue().asUUID(); S32 scroll_pos = mSpeakerList->getScrollInterface()->getScrollPos(); // decide whether it's ok to resort the list then update the speaker manager appropriately. // rapid resorting by activity makes it hard to interact with speakers in the list // so we freeze the sorting while the user appears to be interacting with the control. // we assume this is the case whenever the mouse pointer is within the active speaker // panel and hasn't been motionless for more than a few seconds. see DEV-6655 -MG LLRect screen_rect; localRectToScreen(getLocalRect(), &screen_rect); BOOL mouse_in_view = screen_rect.pointInRect(gViewerWindow->getCurrentMouseX(), gViewerWindow->getCurrentMouseY()); F32 mouses_last_movement = gMouseIdleTimer.getElapsedTimeF32(); BOOL sort_ok = ! (mouse_in_view && mouses_last_movement<RESORT_TIMEOUT); mSpeakerMgr->update(sort_ok); const std::string icon_image_0 = "icn_active-speakers-dot-lvl0.tga"; const std::string icon_image_1 = "icn_active-speakers-dot-lvl1.tga"; const std::string icon_image_2 = "icn_active-speakers-dot-lvl2.tga"; std::vector<LLScrollListItem*> items = mSpeakerList->getAllData(); std::string mute_icon_image = "mute_icon.tga"; LLSpeakerMgr::speaker_list_t speaker_list; mSpeakerMgr->getSpeakerList(&speaker_list, mShowTextChatters); for (std::vector<LLScrollListItem*>::iterator item_it = items.begin(); item_it != items.end(); ++item_it) { LLScrollListItem* itemp = (*item_it); LLUUID speaker_id = itemp->getUUID(); LLPointer<LLSpeaker> speakerp = mSpeakerMgr->findSpeaker(speaker_id); if (!speakerp) { continue; } // since we are forced to sort by text, encode sort order as string std::string speaking_order_sort_string = llformat("%010d", speakerp->mSortIndex); LLScrollListCell* icon_cell = itemp->getColumn(0); if (icon_cell) { std::string icon_image_id; S32 icon_image_idx = llmin(2, llfloor((speakerp->mSpeechVolume / LLVoiceClient::OVERDRIVEN_POWER_LEVEL) * 3.f)); switch(icon_image_idx) { case 0: icon_image_id = icon_image_0; break; case 1: icon_image_id = icon_image_1; break; case 2: icon_image_id = icon_image_2; break; } LLColor4 icon_color; if (speakerp->mStatus == LLSpeaker::STATUS_MUTED) { icon_cell->setValue(mute_icon_image); if(speakerp->mModeratorMutedVoice) { icon_color.setVec(0.5f, 0.5f, 0.5f, 1.f); } else { icon_color.setVec(1.f, 71.f / 255.f, 71.f / 255.f, 1.f); } } else { icon_cell->setValue(icon_image_id); icon_color = speakerp->mDotColor; if (speakerp->mStatus > LLSpeaker::STATUS_VOICE_ACTIVE) // if voice is disabled for this speaker { // non voice speakers have hidden icons, render as transparent icon_color.setVec(0.f, 0.f, 0.f, 0.f); } } icon_cell->setColor(icon_color); if (speakerp->mStatus > LLSpeaker::STATUS_VOICE_ACTIVE && speakerp->mStatus != LLSpeaker::STATUS_MUTED) // if voice is disabled for this speaker { // non voice speakers have hidden icons, render as transparent icon_cell->setColor(LLColor4::transparent); } } // update name column LLScrollListCell* name_cell = itemp->getColumn(1); if (name_cell) { //FIXME: remove hard coding of font colors if (speakerp->mStatus == LLSpeaker::STATUS_NOT_IN_CHANNEL) { // draw inactive speakers in gray name_cell->setColor(LLColor4::grey4); } else { name_cell->setColor(gColors.getColor("DefaultListText")); } std::string speaker_name; if (speakerp->mDisplayName.empty()) { speaker_name = LLCacheName::getDefaultName(); } else { speaker_name = speakerp->mDisplayName; } if (speakerp->mIsModerator) { speaker_name += std::string(" ") + getString("moderator_label"); } name_cell->setValue(speaker_name); ((LLScrollListText*)name_cell)->setFontStyle(speakerp->mIsModerator ? LLFontGL::BOLD : LLFontGL::NORMAL); } // update speaking order column LLScrollListCell* speaking_status_cell = itemp->getColumn(2); if (speaking_status_cell) { // print speaking ordinal in a text-sorting friendly manner speaking_status_cell->setValue(speaking_order_sort_string); } } // we potentially modified the sort order by touching the list items mSpeakerList->setSorted(FALSE); LLPointer<LLSpeaker> selected_speakerp = mSpeakerMgr->findSpeaker(selected_id); // update UI for selected participant if (mMuteVoiceCtrl) { mMuteVoiceCtrl->setValue(LLMuteList::getInstance()->isMuted(selected_id, LLMute::flagVoiceChat)); mMuteVoiceCtrl->setEnabled(LLVoiceClient::voiceEnabled() && gVoiceClient->getVoiceEnabled(selected_id) && selected_id.notNull() && selected_id != gAgent.getID() && (selected_speakerp.notNull() && (selected_speakerp->mType == LLSpeaker::SPEAKER_AGENT || selected_speakerp->mType == LLSpeaker::SPEAKER_EXTERNAL))); } if (mMuteTextCtrl) { mMuteTextCtrl->setValue(LLMuteList::getInstance()->isMuted(selected_id, LLMute::flagTextChat)); mMuteTextCtrl->setEnabled(selected_id.notNull() && selected_id != gAgent.getID() && selected_speakerp.notNull() && selected_speakerp->mType != LLSpeaker::SPEAKER_EXTERNAL && !LLMuteList::getInstance()->isLinden(selected_speakerp->mDisplayName)); } childSetValue("speaker_volume", gVoiceClient->getUserVolume(selected_id)); childSetEnabled("speaker_volume", LLVoiceClient::voiceEnabled() && gVoiceClient->getVoiceEnabled(selected_id) && selected_id.notNull() && selected_id != gAgent.getID() && (selected_speakerp.notNull() && (selected_speakerp->mType == LLSpeaker::SPEAKER_AGENT || selected_speakerp->mType == LLSpeaker::SPEAKER_EXTERNAL))); childSetEnabled( "moderator_controls_label", selected_id.notNull()); childSetEnabled( "moderator_allow_voice", selected_id.notNull() && mSpeakerMgr->isVoiceActive() && gVoiceClient->getVoiceEnabled(selected_id)); childSetEnabled( "moderator_allow_text", selected_id.notNull()); if (mProfileBtn) { mProfileBtn->setEnabled(selected_id.notNull() && (selected_speakerp.notNull() && selected_speakerp->mType != LLSpeaker::SPEAKER_EXTERNAL) ); } // show selected user name in large font if (mNameText) { if (selected_speakerp) { mNameText->setValue(selected_speakerp->mDisplayName); } else { mNameText->setValue(LLStringUtil::null); } } //update moderator capabilities LLPointer<LLSpeaker> self_speakerp = mSpeakerMgr->findSpeaker(gAgent.getID()); if(self_speakerp) { childSetVisible("moderation_mode_panel", self_speakerp->mIsModerator && mSpeakerMgr->isVoiceActive()); childSetVisible("moderator_controls", self_speakerp->mIsModerator); } // keep scroll value stable mSpeakerList->getScrollInterface()->setScrollPos(scroll_pos); }
void LLFloaterEnvSettings::syncMenu() { LLSliderCtrl* sldr; sldr = sEnvSettings->getChild<LLSliderCtrl>("EnvTimeSlider"); // sync the clock F32 val = (F32)LLWLParamManager::instance()->mAnimator.getDayTime(); std::string timeStr = timeToString(val); LLTextBox* textBox; textBox = sEnvSettings->getChild<LLTextBox>("EnvTimeText"); textBox->setValue(timeStr); // sync time slider which starts at 6 AM val -= 0.25; if(val < 0) { val++; } sldr->setValue(val); // sync cloud coverage bool err; childSetValue("EnvCloudSlider", LLWLParamManager::instance()->mCurParams.getFloat("cloud_shadow", err)); LLWaterParamManager * param_mgr = LLWaterParamManager::instance(); // sync water params LLColor4 col = param_mgr->getFogColor(); LLColorSwatchCtrl* colCtrl = sEnvSettings->getChild<LLColorSwatchCtrl>("EnvWaterColor"); col.mV[3] = 1.0f; colCtrl->set(col); childSetValue("EnvWaterFogSlider", param_mgr->mFogDensity.mExp); param_mgr->setDensitySliderValue(param_mgr->mFogDensity.mExp); // turn off Use Estate Time button if it's already being used if(LLWLParamManager::instance()->mAnimator.getUseLindenTime()) { childDisable("EnvUseEstateTimeButton"); } else { childEnable("EnvUseEstateTimeButton"); } if(!gPipeline.canUseVertexShaders()) { childDisable("EnvWaterColor"); childDisable("EnvWaterColorText"); //childDisable("EnvAdvancedWaterButton"); } else { childEnable("EnvWaterColor"); childEnable("EnvWaterColorText"); //childEnable("EnvAdvancedWaterButton"); } // only allow access to these if they are using windlight if(!gPipeline.canUseWindLightShaders()) { childDisable("EnvCloudSlider"); childDisable("EnvCloudText"); //childDisable("EnvAdvancedSkyButton"); } else { childEnable("EnvCloudSlider"); childEnable("EnvCloudText"); //childEnable("EnvAdvancedSkyButton"); } }
void LLPanelObjectTools::setCheckFlags(U32 flags) { childSetValue("disable scripts", flags & REGION_FLAGS_SKIP_SCRIPTS ? TRUE : FALSE); childSetValue("disable collisions", flags & REGION_FLAGS_SKIP_COLLISIONS ? TRUE : FALSE); childSetValue("disable physics", flags & REGION_FLAGS_SKIP_PHYSICS ? TRUE : FALSE); }
void LLFloaterWindLight::syncMenu() { bool err; LLWLParamManager * param_mgr = LLWLParamManager::instance(); LLWLParamSet& currentParams = param_mgr->mCurParams; //std::map<std::string, LLVector4> & currentParams = param_mgr->mCurParams.mParamValues; // [RLVa:KB] - Checked: 2009-07-10 (RLVa-1.0.0g) // Fixes LL "bug" (preset name isn't kept synchronized) if (mSkyPresetCombo->getSelectedItemLabel() != LLEnvManagerNew::instance().getSkyPresetName()) { mSkyPresetCombo->selectByValue(LLEnvManagerNew::instance().getSkyPresetName()); } // [/RLVa:KB] // blue horizon param_mgr->mBlueHorizon = currentParams.getVector(param_mgr->mBlueHorizon.mName, err); childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r / 2.0); childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g / 2.0); childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b / 2.0); childSetValue("WLBlueHorizonI", std::max(param_mgr->mBlueHorizon.r / 2.0, std::max(param_mgr->mBlueHorizon.g / 2.0, param_mgr->mBlueHorizon.b / 2.0))); // haze density, horizon, mult, and altitude param_mgr->mHazeDensity = currentParams.getVector(param_mgr->mHazeDensity.mName, err); childSetValue("WLHazeDensity", param_mgr->mHazeDensity.r); param_mgr->mHazeHorizon = currentParams.getVector(param_mgr->mHazeHorizon.mName, err); childSetValue("WLHazeHorizon", param_mgr->mHazeHorizon.r); param_mgr->mDensityMult = currentParams.getVector(param_mgr->mDensityMult.mName, err); childSetValue("WLDensityMult", param_mgr->mDensityMult.x * param_mgr->mDensityMult.mult); param_mgr->mMaxAlt = currentParams.getVector(param_mgr->mMaxAlt.mName, err); childSetValue("WLMaxAltitude", param_mgr->mMaxAlt.x); // blue density param_mgr->mBlueDensity = currentParams.getVector(param_mgr->mBlueDensity.mName, err); childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r / 2.0); childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g / 2.0); childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b / 2.0); childSetValue("WLBlueDensityI", std::max(param_mgr->mBlueDensity.r / 2.0, std::max(param_mgr->mBlueDensity.g / 2.0, param_mgr->mBlueDensity.b / 2.0))); // Lighting // sunlight param_mgr->mSunlight = currentParams.getVector(param_mgr->mSunlight.mName, err); childSetValue("WLSunlightR", param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightG", param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightB", param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLSunlightI", std::max(param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE, std::max(param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE))); // glow param_mgr->mGlow = currentParams.getVector(param_mgr->mGlow.mName, err); childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f); childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f); // ambient param_mgr->mAmbient = currentParams.getVector(param_mgr->mAmbient.mName, err); childSetValue("WLAmbientR", param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientG", param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientB", param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE); childSetValue("WLAmbientI", std::max(param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE, std::max(param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE))); childSetValue("WLSunAngle", param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI); childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI); // Clouds // Cloud Color param_mgr->mCloudColor = currentParams.getVector(param_mgr->mCloudColor.mName, err); childSetValue("WLCloudColorR", param_mgr->mCloudColor.r); childSetValue("WLCloudColorG", param_mgr->mCloudColor.g); childSetValue("WLCloudColorB", param_mgr->mCloudColor.b); childSetValue("WLCloudColorI", std::max(param_mgr->mCloudColor.r, std::max(param_mgr->mCloudColor.g, param_mgr->mCloudColor.b))); // Cloud param_mgr->mCloudMain = currentParams.getVector(param_mgr->mCloudMain.mName, err); childSetValue("WLCloudX", param_mgr->mCloudMain.r); childSetValue("WLCloudY", param_mgr->mCloudMain.g); childSetValue("WLCloudDensity", param_mgr->mCloudMain.b); // Cloud Detail param_mgr->mCloudDetail = currentParams.getVector(param_mgr->mCloudDetail.mName, err); childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r); childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g); childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b); // Cloud extras param_mgr->mCloudCoverage = currentParams.getVector(param_mgr->mCloudCoverage.mName, err); param_mgr->mCloudScale = currentParams.getVector(param_mgr->mCloudScale.mName, err); childSetValue("WLCloudCoverage", param_mgr->mCloudCoverage.x); childSetValue("WLCloudScale", param_mgr->mCloudScale.x); // cloud scrolling bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX(); bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY(); childSetValue("WLCloudLockX", lockX); childSetValue("WLCloudLockY", lockY); childSetValue("DrawClassicClouds", gSavedSettings.getBOOL("SkyUseClassicClouds2")); // disable if locked, enable if not if(lockX) { childDisable("WLCloudScrollX"); } else { childEnable("WLCloudScrollX"); } if(lockY) { childDisable("WLCloudScrollY"); } else { childEnable("WLCloudScrollY"); } // *HACK cloud scrolling is off my an additive of 10 childSetValue("WLCloudScrollX", param_mgr->mCurParams.getCloudScrollX() - 10.0f); childSetValue("WLCloudScrollY", param_mgr->mCurParams.getCloudScrollY() - 10.0f); param_mgr->mDistanceMult = currentParams.getVector(param_mgr->mDistanceMult.mName, err); childSetValue("WLDistanceMult", param_mgr->mDistanceMult.x); // Tweak extras param_mgr->mWLGamma = currentParams.getVector(param_mgr->mWLGamma.mName, err); childSetValue("WLGamma", param_mgr->mWLGamma.x); childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness()); }
void LLPanelRegionTools::clearAllWidgets() { // clear all widgets childSetValue("region name", "unknown"); childSetFocus("region name", FALSE); childSetValue("check prelude", FALSE); childDisable("check prelude"); childSetValue("check fixed sun", FALSE); childDisable("check fixed sun"); childSetValue("check reset home", FALSE); childDisable("check reset home"); childSetValue("check damage", FALSE); childDisable("check damage"); childSetValue("check visible", FALSE); childDisable("check visible"); childSetValue("block terraform", FALSE); childDisable("block terraform"); childSetValue("block dwell", FALSE); childDisable("block dwell"); childSetValue("is sandbox", FALSE); childDisable("is sandbox"); childSetValue("billable factor", BILLABLE_FACTOR_DEFAULT); childDisable("billable factor"); childSetValue("land cost", PRICE_PER_METER_DEFAULT); childDisable("land cost"); childDisable("Apply"); childDisable("Bake Terrain"); childDisable("Autosave now"); }
BOOL LLFloaterTools::postBuild() { // Hide until tool selected setVisible(FALSE); // Since we constantly show and hide this during drags, don't // make sounds on visibility changes. setSoundFlags(LLView::SILENT); getDragHandle()->setEnabled( !gSavedSettings.getBOOL("ToolboxAutoMove") ); LLRect rect; mBtnFocus = getChild<LLButton>("button focus");//btn; childSetAction("button focus",LLFloaterTools::setEditTool, (void*)LLToolCamera::getInstance()); mBtnMove = getChild<LLButton>("button move"); childSetAction("button move",LLFloaterTools::setEditTool, (void*)LLToolGrab::getInstance()); mBtnEdit = getChild<LLButton>("button edit"); childSetAction("button edit",LLFloaterTools::setEditTool, (void*)LLToolCompTranslate::getInstance()); mBtnCreate = getChild<LLButton>("button create"); childSetAction("button create",LLFloaterTools::setEditTool, (void*)LLToolCompCreate::getInstance()); mBtnLand = getChild<LLButton>("button land" ); childSetAction("button land",LLFloaterTools::setEditTool, (void*)LLToolSelectLand::getInstance()); mTextStatus = getChild<LLTextBox>("text status"); childSetCommitCallback("slider zoom",commit_slider_zoom,this); mRadioZoom = getChild<LLCheckBoxCtrl>("radio zoom"); childSetCommitCallback("radio zoom",commit_radio_zoom,this); mRadioOrbit = getChild<LLCheckBoxCtrl>("radio orbit"); childSetCommitCallback("radio orbit",commit_radio_orbit,this); mRadioPan = getChild<LLCheckBoxCtrl>("radio pan"); childSetCommitCallback("radio pan",commit_radio_pan,this); mRadioMove = getChild<LLCheckBoxCtrl>("radio move"); childSetCommitCallback("radio move",click_popup_grab_drag,this); mRadioLift = getChild<LLCheckBoxCtrl>("radio lift"); childSetCommitCallback("radio lift",click_popup_grab_lift,this); mRadioSpin = getChild<LLCheckBoxCtrl>("radio spin"); childSetCommitCallback("radio spin",click_popup_grab_spin,NULL); mRadioPosition = getChild<LLCheckBoxCtrl>("radio position"); childSetCommitCallback("radio position",commit_select_tool,LLToolCompTranslate::getInstance()); mRadioRotate = getChild<LLCheckBoxCtrl>("radio rotate"); childSetCommitCallback("radio rotate",commit_select_tool,LLToolCompRotate::getInstance()); mRadioStretch = getChild<LLCheckBoxCtrl>("radio stretch"); childSetCommitCallback("radio stretch",commit_select_tool,LLToolCompScale::getInstance()); mRadioSelectFace = getChild<LLCheckBoxCtrl>("radio select face"); childSetCommitCallback("radio select face",commit_select_tool,LLToolFace::getInstance()); mCheckSelectIndividual = getChild<LLCheckBoxCtrl>("checkbox edit linked parts"); childSetValue("checkbox edit linked parts",(BOOL)gSavedSettings.getBOOL("EditLinkedParts")); childSetCommitCallback("checkbox edit linked parts",commit_select_component,this); mCheckSnapToGrid = getChild<LLCheckBoxCtrl>("checkbox snap to grid"); childSetValue("checkbox snap to grid",(BOOL)gSavedSettings.getBOOL("SnapEnabled")); mBtnGridOptions = getChild<LLButton>("Options..."); childSetAction("Options...",onClickGridOptions, this); mCheckStretchUniform = getChild<LLCheckBoxCtrl>("checkbox uniform"); childSetValue("checkbox uniform",(BOOL)gSavedSettings.getBOOL("ScaleUniform")); mCheckStretchTexture = getChild<LLCheckBoxCtrl>("checkbox stretch textures"); childSetValue("checkbox stretch textures",(BOOL)gSavedSettings.getBOOL("ScaleStretchTextures")); mTextGridMode = getChild<LLTextBox>("text ruler mode"); mComboGridMode = getChild<LLComboBox>("combobox grid mode"); childSetCommitCallback("combobox grid mode",commit_grid_mode, this); // // Create Buttons // static const std::string toolNames[]={ "ToolCube", "ToolPrism", "ToolPyramid", "ToolTetrahedron", "ToolCylinder", "ToolHemiCylinder", "ToolCone", "ToolHemiCone", "ToolSphere", "ToolHemiSphere", "ToolTorus", "ToolTube", "ToolRing", "ToolTree", "ToolGrass"}; void* toolData[]={ &LLToolPlacerPanel::sCube, &LLToolPlacerPanel::sPrism, &LLToolPlacerPanel::sPyramid, &LLToolPlacerPanel::sTetrahedron, &LLToolPlacerPanel::sCylinder, &LLToolPlacerPanel::sCylinderHemi, &LLToolPlacerPanel::sCone, &LLToolPlacerPanel::sConeHemi, &LLToolPlacerPanel::sSphere, &LLToolPlacerPanel::sSphereHemi, &LLToolPlacerPanel::sTorus, &LLToolPlacerPanel::sSquareTorus, &LLToolPlacerPanel::sTriangleTorus, &LLToolPlacerPanel::sTree, &LLToolPlacerPanel::sGrass}; for(size_t t=0; t<sizeof(toolNames)/sizeof(toolNames[0]); ++t) { LLButton *found = getChild<LLButton>(toolNames[t]); if(found) { found->setClickedCallback(setObjectType,toolData[t]); mButtons.push_back( found ); }else{ llwarns << "Tool button not found! DOA Pending." << llendl; } } mCheckCopySelection = getChild<LLCheckBoxCtrl>("checkbox copy selection"); childSetValue("checkbox copy selection",(BOOL)gSavedSettings.getBOOL("CreateToolCopySelection")); mCheckSticky = getChild<LLCheckBoxCtrl>("checkbox sticky"); childSetValue("checkbox sticky",(BOOL)gSavedSettings.getBOOL("CreateToolKeepSelected")); mCheckCopyCenters = getChild<LLCheckBoxCtrl>("checkbox copy centers"); childSetValue("checkbox copy centers",(BOOL)gSavedSettings.getBOOL("CreateToolCopyCenters")); mCheckCopyRotates = getChild<LLCheckBoxCtrl>("checkbox copy rotates"); childSetValue("checkbox copy rotates",(BOOL)gSavedSettings.getBOOL("CreateToolCopyRotates")); mRadioSelectLand = getChild<LLCheckBoxCtrl>("radio select land"); childSetCommitCallback("radio select land",commit_select_tool, LLToolSelectLand::getInstance()); mRadioDozerFlatten = getChild<LLCheckBoxCtrl>("radio flatten"); childSetCommitCallback("radio flatten",click_popup_dozer_mode, (void*)0); mRadioDozerRaise = getChild<LLCheckBoxCtrl>("radio raise"); childSetCommitCallback("radio raise",click_popup_dozer_mode, (void*)1); mRadioDozerLower = getChild<LLCheckBoxCtrl>("radio lower"); childSetCommitCallback("radio lower",click_popup_dozer_mode, (void*)2); mRadioDozerSmooth = getChild<LLCheckBoxCtrl>("radio smooth"); childSetCommitCallback("radio smooth",click_popup_dozer_mode, (void*)3); mRadioDozerNoise = getChild<LLCheckBoxCtrl>("radio noise"); childSetCommitCallback("radio noise",click_popup_dozer_mode, (void*)4); mRadioDozerRevert = getChild<LLCheckBoxCtrl>("radio revert"); childSetCommitCallback("radio revert",click_popup_dozer_mode, (void*)5); mComboDozerSize = getChild<LLComboBox>("combobox brush size"); childSetCommitCallback("combobox brush size",click_dozer_size, (void*)0); if(mComboDozerSize) mComboDozerSize->setCurrentByIndex(0); mBtnApplyToSelection = getChild<LLButton>("button apply to selection"); childSetAction("button apply to selection",click_apply_to_selection, (void*)0); mCheckShowOwners = getChild<LLCheckBoxCtrl>("checkbox show owners"); childSetValue("checkbox show owners",gSavedSettings.getBOOL("ShowParcelOwners")); mSliderDozerForce = getChild<LLSlider>("slider force"); childSetCommitCallback("slider force",commit_slider_dozer_force, (void*)0); // the setting stores the actual force multiplier, but the slider is logarithmic, so we convert here childSetValue( "slider force", log10(gSavedSettings.getF32("LandBrushForce"))); childSetAction("button more", click_show_more, this); childSetAction("button less", click_show_more, this); mTab = getChild<LLTabContainer>("Object Info Tabs"); if(mTab) { mTab->setVisible( gSavedSettings.getBOOL("ToolboxShowMore") ); mTab->setFollows(FOLLOWS_TOP | FOLLOWS_LEFT); mTab->setVisible( gSavedSettings.getBOOL("ToolboxShowMore") ); mTab->setBorderVisible(FALSE); mTab->selectFirstTab(); } mStatusText["rotate"] = getString("status_rotate"); mStatusText["scale"] = getString("status_scale"); mStatusText["move"] = getString("status_move"); mStatusText["modifyland"] = getString("status_modifyland"); mStatusText["camera"] = getString("status_camera"); mStatusText["grab"] = getString("status_grab"); mStatusText["place"] = getString("status_place"); mStatusText["selectland"] = getString("status_selectland"); return TRUE; }
void LLPanelRegionTools::setGridPosY(S32 pos) { childSetValue("gridposy", pos); }
void LLFloaterEditSky::syncControls() { bool err; LLWLParamManager * param_mgr = LLWLParamManager::getInstance(); LLWLParamSet& cur_params = param_mgr->mCurParams; // blue horizon param_mgr->mBlueHorizon = cur_params.getVector(param_mgr->mBlueHorizon.mName, err); setColorSwatch("WLBlueHorizon", param_mgr->mBlueHorizon, WL_BLUE_HORIZON_DENSITY_SCALE); // haze density, horizon, mult, and altitude param_mgr->mHazeDensity = cur_params.getFloat(param_mgr->mHazeDensity.mName, err); childSetValue("WLHazeDensity", (F32) param_mgr->mHazeDensity); param_mgr->mHazeHorizon = cur_params.getFloat(param_mgr->mHazeHorizon.mName, err); childSetValue("WLHazeHorizon", (F32) param_mgr->mHazeHorizon); param_mgr->mDensityMult = cur_params.getFloat(param_mgr->mDensityMult.mName, err); childSetValue("WLDensityMult", ((F32) param_mgr->mDensityMult) * param_mgr->mDensityMult.mult); param_mgr->mMaxAlt = cur_params.getFloat(param_mgr->mMaxAlt.mName, err); childSetValue("WLMaxAltitude", (F32) param_mgr->mMaxAlt); // blue density param_mgr->mBlueDensity = cur_params.getVector(param_mgr->mBlueDensity.mName, err); setColorSwatch("WLBlueDensity", param_mgr->mBlueDensity, WL_BLUE_HORIZON_DENSITY_SCALE); // Lighting // sunlight param_mgr->mSunlight = cur_params.getVector(param_mgr->mSunlight.mName, err); setColorSwatch("WLSunlight", param_mgr->mSunlight, WL_SUN_AMBIENT_SLIDER_SCALE); // glow param_mgr->mGlow = cur_params.getVector(param_mgr->mGlow.mName, err); childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f); childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f); // ambient param_mgr->mAmbient = cur_params.getVector(param_mgr->mAmbient.mName, err); setColorSwatch("WLAmbient", param_mgr->mAmbient, WL_SUN_AMBIENT_SLIDER_SCALE); F32 time24 = sun_pos_to_time24(param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI); getChild<LLMultiSliderCtrl>("WLSunPos")->setCurSliderValue(time24, TRUE); getChild<LLTimeCtrl>("WLDayTime")->setTime24(time24); childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI); // Clouds // Cloud Color param_mgr->mCloudColor = cur_params.getVector(param_mgr->mCloudColor.mName, err); setColorSwatch("WLCloudColor", param_mgr->mCloudColor, WL_CLOUD_SLIDER_SCALE); // Cloud param_mgr->mCloudMain = cur_params.getVector(param_mgr->mCloudMain.mName, err); childSetValue("WLCloudX", param_mgr->mCloudMain.r); childSetValue("WLCloudY", param_mgr->mCloudMain.g); childSetValue("WLCloudDensity", param_mgr->mCloudMain.b); // Cloud Detail param_mgr->mCloudDetail = cur_params.getVector(param_mgr->mCloudDetail.mName, err); childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r); childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g); childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b); // Cloud extras param_mgr->mCloudCoverage = cur_params.getFloat(param_mgr->mCloudCoverage.mName, err); param_mgr->mCloudScale = cur_params.getFloat(param_mgr->mCloudScale.mName, err); childSetValue("WLCloudCoverage", (F32) param_mgr->mCloudCoverage); childSetValue("WLCloudScale", (F32) param_mgr->mCloudScale); // cloud scrolling bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX(); bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY(); childSetValue("WLCloudLockX", lockX); childSetValue("WLCloudLockY", lockY); // disable if locked, enable if not if (lockX) { childDisable("WLCloudScrollX"); } else { childEnable("WLCloudScrollX"); } if (lockY) { childDisable("WLCloudScrollY"); } else { childEnable("WLCloudScrollY"); } // *HACK cloud scrolling is off my an additive of 10 childSetValue("WLCloudScrollX", param_mgr->mCurParams.getCloudScrollX() - 10.0f); childSetValue("WLCloudScrollY", param_mgr->mCurParams.getCloudScrollY() - 10.0f); param_mgr->mDistanceMult = cur_params.getFloat(param_mgr->mDistanceMult.mName, err); childSetValue("WLDistanceMult", (F32) param_mgr->mDistanceMult); // Tweak extras param_mgr->mWLGamma = cur_params.getFloat(param_mgr->mWLGamma.mName, err); childSetValue("WLGamma", (F32) param_mgr->mWLGamma); childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness()); }
void LLPanelRegionTools::setRedirectGridY(S32 pos) { childSetValue("redirecty", pos); }
void LLFloaterPreference::setKey(KEY key) { childSetValue("modifier_combo", LLKeyboard::stringFromKey(key)); // update the control right away since we no longer wait for apply getChild<LLUICtrl>("modifier_combo")->onCommit(); }
void LLPanelRegionTools::setParentEstateID(U32 id) { childSetValue("parentestate", (S32)id); }
// virtual void LLFloaterWorldMap::draw() { // Hide/Show Mature Events controls childSetVisible("events_mature_icon", gAgent.canAccessMature()); childSetVisible("events_mature_label", gAgent.canAccessMature()); childSetVisible("event_mature_chk", gAgent.canAccessMature()); childSetVisible("events_adult_icon", gAgent.canAccessMature()); childSetVisible("events_adult_label", gAgent.canAccessMature()); childSetVisible("event_adult_chk", gAgent.canAccessMature()); bool adult_enabled = gAgent.canAccessAdult(); if (!adult_enabled) { childSetValue("event_adult_chk", FALSE); } childSetEnabled("event_adult_chk", adult_enabled); // On orientation island, users don't have a home location yet, so don't // let them teleport "home". It dumps them in an often-crowed welcome // area (infohub) and they get confused. JC LLViewerRegion* regionp = gAgent.getRegion(); bool agent_on_prelude = (regionp && regionp->isPrelude()); bool enable_go_home = gAgent.isGodlike() || !agent_on_prelude; childSetEnabled("Go Home", enable_go_home); updateLocation(); LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus(); if (LLTracker::TRACKING_AVATAR == tracking_status) { childSetColor("avatar_icon", gTrackColor); } else { childSetColor("avatar_icon", gDisabledTrackColor); } if (LLTracker::TRACKING_LANDMARK == tracking_status) { childSetColor("landmark_icon", gTrackColor); } else { childSetColor("landmark_icon", gDisabledTrackColor); } if (LLTracker::TRACKING_LOCATION == tracking_status) { childSetColor("location_icon", gTrackColor); } else { if (mCompletingRegionName != "") { F64 seconds = LLTimer::getElapsedSeconds(); double value = fmod(seconds, 2); value = 0.5 + 0.5*cos(value * 3.14159f); LLColor4 loading_color(0.0, F32(value/2), F32(value), 1.0); childSetColor("location_icon", loading_color); } else { childSetColor("location_icon", gDisabledTrackColor); } } // check for completion of tracking data if (mWaitingForTracker) { centerOnTarget(TRUE); } // childSetEnabled("Clear", (BOOL)tracking_status); childSetEnabled("Show Destination", (BOOL)tracking_status || LLWorldMap::getInstance()->mIsTrackingUnknownLocation); childSetEnabled("copy_slurl", (mSLURL.size() > 0) ); setMouseOpaque(TRUE); getDragHandle()->setMouseOpaque(TRUE); //RN: snaps to zoom value because interpolation caused jitter in the text rendering if (!mZoomTimer.getStarted() && mCurZoomVal != (F32)childGetValue("zoom slider").asReal()) { mZoomTimer.start(); } F32 interp = mZoomTimer.getElapsedTimeF32() / MAP_ZOOM_TIME; if (interp > 1.f) { interp = 1.f; mZoomTimer.stop(); } mCurZoomVal = lerp(mCurZoomVal, (F32)childGetValue("zoom slider").asReal(), interp); F32 map_scale = 256.f*pow(2.f, mCurZoomVal); LLWorldMapView::setScale( map_scale ); LLFloater::draw(); }
void LLPanelRegionTools::setBillableFactor(F32 billable_factor) { childSetValue("billable factor", billable_factor); }
void LLPanelFace::getState() { LLViewerObject* objectp = LLSelectMgr::getInstance()->getSelection()->getFirstObject(); if( objectp && objectp->getPCode() == LL_PCODE_VOLUME && objectp->permModify()) { BOOL editable = objectp->permModify(); // only turn on auto-adjust button if there is a media renderer and the media is loaded childSetEnabled("textbox autofix",FALSE); //mLabelTexAutoFix->setEnabled ( FALSE ); childSetEnabled("button align",FALSE); //mBtnAutoFix->setEnabled ( FALSE ); if(LLViewerMedia::hasMedia()) { childSetEnabled("textbox autofix",editable); childSetEnabled("button align",editable); } //if ( LLMediaEngine::getInstance()->getMediaRenderer () ) // if ( LLMediaEngine::getInstance()->getMediaRenderer ()->isLoaded () ) // { // // //mLabelTexAutoFix->setEnabled ( editable ); // // //mBtnAutoFix->setEnabled ( editable ); // } childSetEnabled("button apply",editable); bool identical; LLTextureCtrl* texture_ctrl = getChild<LLTextureCtrl>("texture control"); // Texture { LLUUID id; struct f1 : public LLSelectedTEGetFunctor<LLUUID> { LLUUID get(LLViewerObject* object, S32 te) { LLViewerImage* image = object->getTEImage(te); return image ? image->getID() : LLUUID::null; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, id ); if (identical) { // All selected have the same texture if(texture_ctrl) { texture_ctrl->setTentative( FALSE ); texture_ctrl->setEnabled( editable ); texture_ctrl->setImageAssetID( id ); } } else { if(texture_ctrl) { if( id.isNull() ) { // None selected texture_ctrl->setTentative( FALSE ); texture_ctrl->setEnabled( FALSE ); texture_ctrl->setImageAssetID( LLUUID::null ); } else { // Tentative: multiple selected with different textures texture_ctrl->setTentative( TRUE ); texture_ctrl->setEnabled( editable ); texture_ctrl->setImageAssetID( id ); } } } } LLAggregatePermissions texture_perms; if(texture_ctrl) { // texture_ctrl->setValid( editable ); if (LLSelectMgr::getInstance()->selectGetAggregateTexturePermissions(texture_perms)) { BOOL can_copy = texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_EMPTY || texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_ALL; BOOL can_transfer = texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_EMPTY || texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_ALL; texture_ctrl->setCanApplyImmediately(can_copy && can_transfer); } else { texture_ctrl->setCanApplyImmediately(FALSE); } } // Texture scale { childSetEnabled("tex scale",editable); //mLabelTexScale->setEnabled( editable ); F32 scale_s = 1.f; struct f2 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->mScaleS; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_s ); childSetValue("TexScaleU",editable ? llabs(scale_s) : 0); childSetTentative("TexScaleU",LLSD((BOOL)(!identical))); childSetEnabled("TexScaleU",editable); childSetValue("checkbox flip s",LLSD((BOOL)(scale_s < 0 ? TRUE : FALSE ))); childSetTentative("checkbox flip s",LLSD((BOOL)((!identical) ? TRUE : FALSE ))); childSetEnabled("checkbox flip s",editable); } { F32 scale_t = 1.f; struct f3 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->mScaleT; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_t ); childSetValue("TexScaleV",llabs(editable ? llabs(scale_t) : 0)); childSetTentative("TexScaleV",LLSD((BOOL)(!identical))); childSetEnabled("TexScaleV",editable); childSetValue("checkbox flip t",LLSD((BOOL)(scale_t< 0 ? TRUE : FALSE ))); childSetTentative("checkbox flip t",LLSD((BOOL)((!identical) ? TRUE : FALSE ))); childSetEnabled("checkbox flip t",editable); } // Texture offset { childSetEnabled("tex offset",editable); F32 offset_s = 0.f; struct f4 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->mOffsetS; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, offset_s ); childSetValue("TexOffsetU", editable ? offset_s : 0); childSetTentative("TexOffsetU",!identical); childSetEnabled("TexOffsetU",editable); } { F32 offset_t = 0.f; struct f5 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->mOffsetT; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, offset_t ); childSetValue("TexOffsetV", editable ? offset_t : 0); childSetTentative("TexOffsetV",!identical); childSetEnabled("TexOffsetV",editable); } // Texture rotation { childSetEnabled("tex rotate",editable); F32 rotation = 0.f; struct f6 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->mRotation; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, rotation ); childSetValue("TexRot", editable ? rotation * RAD_TO_DEG : 0); childSetTentative("TexRot",!identical); childSetEnabled("TexRot",editable); } // Color swatch LLColorSwatchCtrl* mColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch"); LLColor4 color = LLColor4::white; if(mColorSwatch) { struct f7 : public LLSelectedTEGetFunctor<LLColor4> { LLColor4 get(LLViewerObject* object, S32 face) { return object->getTE(face)->getColor(); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, color ); mColorSwatch->setOriginal(color); mColorSwatch->set(color, TRUE); mColorSwatch->setValid(editable); mColorSwatch->setEnabled( editable ); mColorSwatch->setCanApplyImmediately( editable ); } // Color transparency { childSetEnabled("color trans",editable); } F32 transparency = (1.f - color.mV[VALPHA]) * 100.f; { childSetValue("ColorTrans", editable ? transparency : 0); childSetEnabled("ColorTrans",editable); } { F32 glow = 0.f; struct f8 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return object->getTE(face)->getGlow(); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, glow ); childSetValue("glow",glow); childSetEnabled("glow",editable); childSetTentative("glow",!identical); childSetEnabled("glow label",editable); } // Bump { F32 shinyf = 0.f; struct f9 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return (F32)(object->getTE(face)->getShiny()); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, shinyf ); LLCtrlSelectionInterface* combobox_shininess = childGetSelectionInterface("combobox shininess"); if (combobox_shininess) { combobox_shininess->selectNthItem((S32)shinyf); } else { llwarns << "failed childGetSelectionInterface for 'combobox shininess'" << llendl; } childSetEnabled("combobox shininess",editable); childSetTentative("combobox shininess",!identical); childSetEnabled("label shininess",editable); } { F32 bumpf = 0.f; struct f10 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return (F32)(object->getTE(face)->getBumpmap()); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, bumpf ); LLCtrlSelectionInterface* combobox_bumpiness = childGetSelectionInterface("combobox bumpiness"); if (combobox_bumpiness) { combobox_bumpiness->selectNthItem((S32)bumpf); } else { llwarns << "failed childGetSelectionInterface for 'combobox bumpiness'" << llendl; } childSetEnabled("combobox bumpiness",editable); childSetTentative("combobox bumpiness",!identical); childSetEnabled("label bumpiness",editable); } { F32 genf = 0.f; struct f11 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return (F32)(object->getTE(face)->getTexGen()); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, genf ); S32 selected_texgen = ((S32) genf) >> TEM_TEX_GEN_SHIFT; LLCtrlSelectionInterface* combobox_texgen = childGetSelectionInterface("combobox texgen"); if (combobox_texgen) { combobox_texgen->selectNthItem(selected_texgen); } else { llwarns << "failed childGetSelectionInterface for 'combobox texgen'" << llendl; } childSetEnabled("combobox texgen",editable); childSetTentative("combobox texgen",!identical); childSetEnabled("tex gen",editable); if (selected_texgen == 1) { childSetText("tex scale",getString("string repeats per meter")); childSetValue("TexScaleU", 2.0f * childGetValue("TexScaleU").asReal() ); childSetValue("TexScaleV", 2.0f * childGetValue("TexScaleV").asReal() ); } else { childSetText("tex scale",getString("string repeats per face")); } } { F32 fullbrightf = 0.f; struct f12 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { return (F32)(object->getTE(face)->getFullbright()); } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, fullbrightf ); childSetValue("checkbox fullbright",(S32)fullbrightf); childSetEnabled("checkbox fullbright",editable); childSetTentative("checkbox fullbright",!identical); } // Repeats per meter label { childSetEnabled("rpt",editable); } // Repeats per meter { F32 repeats = 1.f; struct f13 : public LLSelectedTEGetFunctor<F32> { F32 get(LLViewerObject* object, S32 face) { U32 s_axis = VX; U32 t_axis = VY; // BUG: Only repeats along S axis // BUG: Only works for boxes. LLPrimitive::getTESTAxes(face, &s_axis, &t_axis); return object->getTE(face)->mScaleS / object->getScale().mV[s_axis]; } } func; identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, repeats ); childSetValue("rptctrl", editable ? repeats : 0); childSetTentative("rptctrl",!identical); LLComboBox* mComboTexGen = getChild<LLComboBox>("combobox texgen"); if (mComboTexGen) { BOOL enabled = editable && (!mComboTexGen || mComboTexGen->getCurrentIndex() != 1); childSetEnabled("rptctrl",enabled); childSetEnabled("button apply",enabled); } } }
void LLPrefsAscentSysImpl::cancel() { //General ----------------------------------------------------------------------------- childSetValue("double_click_teleport_check", mDoubleClickTeleport); childSetValue("center_after_teleport_check", mResetCameraAfterTP); childSetValue("offset_teleport_check", mOffsetTPByUserHeight); childSetValue("preview_anim_in_world_check", mPreviewAnimInWorld); childSetValue("save_scripts_as_mono_check", mSaveScriptsAsMono); childSetValue("always_rez_in_group_check", mAlwaysRezInGroup); //Chat -------------------------------------------------------------------------------- childSetValue("hide_notifications_in_chat_check", mHideNotificationsInChat); childSetValue("play_typing_sound_check", mPlayTypingSound); childSetValue("hide_typing_check", mHideTypingNotification); childSetValue("seconds_in_chat_and_ims_check", mSecondsInChatAndIMs); childSetValue("allow_mu_pose_check", mEnableMUPose); childSetValue("close_ooc_check", mEnableOOCAutoClose); //Show Links //Time Format //Date Format childSetValue("seconds_in_chat_and_ims_check", mEnableOOCAutoClose); //Save Performance -------------------------------------------------------------------- childSetValue("fetch_inventory_on_login_check", mFetchInventoryOnLogin); childSetValue("enable_wind", mEnableLLWind); childSetValue("enable_clouds", mEnableClouds); childSetValue("enable_classic_clouds", mEnableClassicClouds); childSetValue("speed_rez_check", mSpeedRez); if (mSpeedRez) { childEnable("speed_rez_interval"); childEnable("speed_rez_seconds"); } else { childDisable("speed_rez_interval"); childDisable("speed_rez_seconds"); } //Command Line ------------------------------------------------------------------------ //Privacy ----------------------------------------------------------------------------- childSetValue("broadcast_viewer_effects", mBroadcastViewerEffects); childSetValue("disable_point_at_and_beams_check", mDisablePointAtAndBeam); childSetValue("private_look_at_check", mPrivateLookAt); childSetValue("revoke_perms_on_stand_up_check", mRevokePermsOnStandUp); childSetValue("enable_clouds", mEnableClouds); childSetValue("enable_classic_clouds", mEnableClassicClouds); gLLWindEnabled = mEnableLLWind; }