// virtual bool LLHTTPNode::handles(const LLSD& remainder, LLSD& context) const { return remainder.size() == 0; }
bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web) { if (params.size() < 2) return false; LLUUID avatar_id; if (!avatar_id.set(params[0], FALSE)) { return false; } const std::string verb = params[1].asString(); if (verb == "about") { LLAvatarActions::showProfile(avatar_id); return true; } if (verb == "inspect") { LLFloaterReg::showInstance("inspect_avatar", LLSD().with("avatar_id", avatar_id)); return true; } if (verb == "im") { LLAvatarActions::startIM(avatar_id); return true; } if (verb == "pay") { if (!LLUI::sSettingGroups["config"]->getBOOL("EnableAvatarPay")) { LLNotificationsUtil::add("NoAvatarPay", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit")); return true; } LLAvatarActions::pay(avatar_id); return true; } if (verb == "offerteleport") { LLAvatarActions::offerTeleport(avatar_id); return true; } if (verb == "requestfriend") { LLAvatarActions::requestFriendshipDialog(avatar_id); return true; } if (verb == "mute") { if (! LLAvatarActions::isBlocked(avatar_id)) { LLAvatarActions::toggleBlock(avatar_id); } return true; } if (verb == "unmute") { if (LLAvatarActions::isBlocked(avatar_id)) { LLAvatarActions::toggleBlock(avatar_id); } return true; } return false; }
void LLMaterialMgr::processGetQueue() { get_queue_t::iterator loopRegionQueue = mGetQueue.begin(); while (mGetQueue.end() != loopRegionQueue) { get_queue_t::iterator itRegionQueue = loopRegionQueue++; const LLUUID& region_id = itRegionQueue->first; if (isGetAllPending(region_id)) { continue; } LLViewerRegion* regionp = LLWorld::instance().getRegionFromID(region_id); if (!regionp) { LL_WARNS("Materials") << "Unknown region with id " << region_id.asString() << LL_ENDL; mGetQueue.erase(itRegionQueue); continue; } else if (!regionp->capabilitiesReceived() || regionp->materialsCapThrottled()) { continue; } else if (mGetAllRequested.end() == mGetAllRequested.find(region_id)) { LL_DEBUGS("Materials") << "calling getAll for " << regionp->getName() << LL_ENDL; getAll(region_id); continue; } const std::string capURL = regionp->getCapability(MATERIALS_CAPABILITY_NAME); if (capURL.empty()) { LL_WARNS("Materials") << "Capability '" << MATERIALS_CAPABILITY_NAME << "' is not defined on region '" << regionp->getName() << "'" << LL_ENDL; mGetQueue.erase(itRegionQueue); continue; } LLSD materialsData = LLSD::emptyArray(); material_queue_t& materials = itRegionQueue->second; U32 max_entries = regionp->getMaxMaterialsPerTransaction(); material_queue_t::iterator loopMaterial = materials.begin(); while ( (materials.end() != loopMaterial) && (materialsData.size() < (int)max_entries) ) { material_queue_t::iterator itMaterial = loopMaterial++; materialsData.append((*itMaterial).asLLSD()); materials.erase(itMaterial); markGetPending(region_id, *itMaterial); } if (materials.empty()) { mGetQueue.erase(itRegionQueue); } std::string materialString = zip_llsd(materialsData); S32 materialSize = materialString.size(); if (materialSize <= 0) { LL_ERRS("Materials") << "cannot zip LLSD binary content" << LL_ENDL; return; } LLSD::Binary materialBinary; materialBinary.resize(materialSize); memcpy(materialBinary.data(), materialString.data(), materialSize); LLSD postData = LLSD::emptyMap(); postData[MATERIALS_CAP_ZIP_FIELD] = materialBinary; LLHTTPClient::ResponderPtr materialsResponder = new LLMaterialsResponder("POST", capURL, boost::bind(&LLMaterialMgr::onGetResponse, this, _1, _2, region_id)); LL_DEBUGS("Materials") << "POSTing to region '" << regionp->getName() << "' at '"<< capURL << " for " << materialsData.size() << " materials." << "\ndata: " << ll_pretty_print_sd(materialsData) << LL_ENDL; LLHTTPClient::post(capURL, postData, materialsResponder); regionp->resetMaterialsCapThrottle(); } }
bool LLLoginHandler::handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web) { // do nothing if we are already logged in if (LLLoginInstance::getInstance()->authSuccess()) { LL_WARNS_ONCE("SLURL") << "Already logged in! Ignoring login SLapp." << LL_ENDL; return true; } if (tokens.size() == 1 && tokens[0].asString() == "show") { // We're using reg-in-client, so show the XUI login widgets LLPanelLogin::showLoginWidgets(); return true; } if (tokens.size() == 1 && tokens[0].asString() == "reg") { LLWindow* window = gViewerWindow->getWindow(); window->incBusyCount(); window->setCursor(UI_CURSOR_ARROW); // Do this first, as it may be slow and we want to keep something // on the user's screen as long as possible LLWeb::loadURLExternal( "http://join.eniac15.lindenlab.com/" ); window->decBusyCount(); window->setCursor(UI_CURSOR_ARROW); // Then hide the window window->minimize(); return true; } // Make sure window is visible LLWindow* window = gViewerWindow->getWindow(); if (window->getMinimized()) { window->restore(); } parse(query_map); //if we haven't initialized stuff yet, this is //coming in from the GURL handler, just parse if (STATE_FIRST == LLStartUp::getStartupState()) { return true; } if (LLStartUp::getStartupState() < STATE_LOGIN_CLEANUP) //on splash page { // as the login page may change from grid to grid, as well as // things like username/password/etc, we simply refresh the // login page to make sure everything is set up correctly LLPanelLogin::loadLoginPage(); LLStartUp::setStartupState( STATE_LOGIN_CLEANUP ); } return true; }
bool handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web) { if (!LLUI::sSettingGroups["config"]->getBOOL("EnableGroupInfo")) { LLNotificationsUtil::add("NoGroupInfo", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit")); return true; } if (tokens.size() < 1) { return false; } if (tokens[0].asString() == "create") { LLGroupActions::createGroup(); return true; } if (tokens.size() < 2) { return false; } if (tokens[0].asString() == "list") { if (tokens[1].asString() == "show") { // <FS:Ansariel> Obey FSUseV2Friends setting where to open the group list //LLSD params; //params["people_panel_tab_name"] = "groups_panel"; //LLFloaterSidePanelContainer::showPanel("people", "panel_people", params); if (gSavedSettings.getBOOL("FSUseV2Friends") && gSavedSettings.getString("FSInternalSkinCurrent") != "Vintage") { LLSD params; params["people_panel_tab_name"] = "groups_panel"; LLFloaterSidePanelContainer::showPanel("people", "panel_people", params); } else { FSFloaterContacts::getInstance()->openTab("groups"); } // </FS:Ansariel> return true; } return false; } LLUUID group_id; if (!group_id.set(tokens[0], FALSE)) { return false; } if (tokens[1].asString() == "about") { if (group_id.isNull()) return true; LLGroupActions::show(group_id); return true; } if (tokens[1].asString() == "inspect") { if (group_id.isNull()) return true; LLGroupActions::inspect(group_id); return true; } return false; }
bool handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web) { if (!LLUI::sSettingGroups["config"]->getBOOL("EnableGroupInfo")) { LLNotificationsUtil::add("NoGroupInfo", LLSD(), LLSD(), std::string("SwitchToStandardSkinAndQuit")); return true; } if (tokens.size() < 1) { return false; } if (tokens[0].asString() == "create") { LLGroupActions::createGroup(); return true; } if (tokens.size() < 2) { return false; } if (tokens[0].asString() == "list") { if (tokens[1].asString() == "show") { LLSD params; params["people_panel_tab_name"] = "groups_panel"; LLFloaterSidePanelContainer::showPanel("people", "panel_people", params); return true; } return false; } LLUUID group_id; if (!group_id.set(tokens[0], FALSE)) { return false; } if (tokens[1].asString() == "about") { if (group_id.isNull()) return true; LLGroupActions::show(group_id); return true; } if (tokens[1].asString() == "inspect") { if (group_id.isNull()) return true; LLGroupActions::inspect(group_id); return true; } return false; }
// virtual S32 LLSDBinaryFormatter::format(const LLSD& data, std::ostream& ostr, U32 options) const { S32 format_count = 1; switch(data.type()) { case LLSD::TypeMap: { ostr.put('{'); U32 size_nbo = htonl(data.size()); ostr.write((const char*)(&size_nbo), sizeof(U32)); LLSD::map_const_iterator iter = data.beginMap(); LLSD::map_const_iterator end = data.endMap(); for(; iter != end; ++iter) { ostr.put('k'); formatString((*iter).first, ostr); format_count += format((*iter).second, ostr); } ostr.put('}'); break; } case LLSD::TypeArray: { ostr.put('['); U32 size_nbo = htonl(data.size()); ostr.write((const char*)(&size_nbo), sizeof(U32)); LLSD::array_const_iterator iter = data.beginArray(); LLSD::array_const_iterator end = data.endArray(); for(; iter != end; ++iter) { format_count += format(*iter, ostr); } ostr.put(']'); break; } case LLSD::TypeUndefined: ostr.put('!'); break; case LLSD::TypeBoolean: if(data.asBoolean()) ostr.put(BINARY_TRUE_SERIAL); else ostr.put(BINARY_FALSE_SERIAL); break; case LLSD::TypeInteger: { ostr.put('i'); U32 value_nbo = htonl(data.asInteger()); ostr.write((const char*)(&value_nbo), sizeof(U32)); break; } case LLSD::TypeReal: { ostr.put('r'); F64 value_nbo = ll_htond(data.asReal()); ostr.write((const char*)(&value_nbo), sizeof(F64)); break; } case LLSD::TypeUUID: ostr.put('u'); ostr.write((const char*)(&(data.asUUID().mData)), UUID_BYTES); break; case LLSD::TypeString: ostr.put('s'); formatString(data.asString(), ostr); break; case LLSD::TypeDate: { ostr.put('d'); F64 value = data.asReal(); ostr.write((const char*)(&value), sizeof(F64)); break; } case LLSD::TypeURI: ostr.put('l'); formatString(data.asString(), ostr); break; case LLSD::TypeBinary: { // *FIX: memory inefficient. ostr.put('b'); std::vector<U8> buffer = data.asBinary(); U32 size_nbo = htonl(buffer.size()); ostr.write((const char*)(&size_nbo), sizeof(U32)); if(buffer.size()) ostr.write((const char*)&buffer[0], buffer.size()); break; } default: // *NOTE: This should never happen. ostr.put('!'); break; } return format_count; }
void LLWLParamSet::mix(LLWLParamSet& src, LLWLParamSet& dest, F32 weight) { // set up the iterators // keep cloud positions and coverage the same /// TODO masking will do this later F32 cloudPos1X = (F32) mParamValues["cloud_pos_density1"][0].asReal(); F32 cloudPos1Y = (F32) mParamValues["cloud_pos_density1"][1].asReal(); F32 cloudPos2X = (F32) mParamValues["cloud_pos_density2"][0].asReal(); F32 cloudPos2Y = (F32) mParamValues["cloud_pos_density2"][1].asReal(); F32 cloudCover = (F32) mParamValues["cloud_shadow"][0].asReal(); LLSD srcVal; LLSD destVal; // Iterate through values for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter) { // If param exists in both src and dest, set the holder variables, otherwise skip if(src.mParamValues.has(iter->first) && dest.mParamValues.has(iter->first)) { srcVal = src.mParamValues[iter->first]; destVal = dest.mParamValues[iter->first]; } else { continue; } if(iter->second.isReal()) // If it's a real, interpolate directly { iter->second = srcVal.asReal() + ((destVal.asReal() - srcVal.asReal()) * weight); } else if(iter->second.isArray() && iter->second[0].isReal() // If it's an array of reals, loop through the reals and interpolate on those && iter->second.size() == srcVal.size() && iter->second.size() == destVal.size()) { // Actually do interpolation: old value + (difference in values * factor) for(int i=0; i < iter->second.size(); ++i) { // iter->second[i] = (1.f-weight)*(F32)srcVal[i].asReal() + weight*(F32)destVal[i].asReal(); // old way of doing it -- equivalent but one more operation iter->second[i] = srcVal[i].asReal() + ((destVal[i].asReal() - srcVal[i].asReal()) * weight); } } else // Else, skip { continue; } } // now mix the extra parameters setStarBrightness((1 - weight) * (F32) src.getStarBrightness() + weight * (F32) dest.getStarBrightness()); llassert(src.getSunAngle() >= - F_PI && src.getSunAngle() <= 3 * F_PI); llassert(dest.getSunAngle() >= - F_PI && dest.getSunAngle() <= 3 * F_PI); llassert(src.getEastAngle() >= 0 && src.getEastAngle() <= 4 * F_PI); llassert(dest.getEastAngle() >= 0 && dest.getEastAngle() <= 4 * F_PI); // sun angle and east angle require some handling to make sure // they go in circles. Yes quaternions would work better. F32 srcSunAngle = src.getSunAngle(); F32 destSunAngle = dest.getSunAngle(); F32 srcEastAngle = src.getEastAngle(); F32 destEastAngle = dest.getEastAngle(); if(fabsf(srcSunAngle - destSunAngle) > F_PI) { if(srcSunAngle > destSunAngle) { destSunAngle += 2 * F_PI; } else { srcSunAngle += 2 * F_PI; } } if(fabsf(srcEastAngle - destEastAngle) > F_PI) { if(srcEastAngle > destEastAngle) { destEastAngle += 2 * F_PI; } else { srcEastAngle += 2 * F_PI; } } setSunAngle((1 - weight) * srcSunAngle + weight * destSunAngle); setEastAngle((1 - weight) * srcEastAngle + weight * destEastAngle); // now setup the sun properly // reset those cloud positions mParamValues["cloud_pos_density1"][0] = cloudPos1X; mParamValues["cloud_pos_density1"][1] = cloudPos1Y; mParamValues["cloud_pos_density2"][0] = cloudPos2X; mParamValues["cloud_pos_density2"][1] = cloudPos2Y; mParamValues["cloud_shadow"][0] = cloudCover; }
void ensure_equals(const std::string& msg, const LLSD& actual, const LLSD& expected) { ensure_equals(msg + " type", actual.type(), expected.type()); switch (actual.type()) { case LLSD::TypeUndefined: return; case LLSD::TypeBoolean: ensure_equals(msg + " boolean", actual.asBoolean(), expected.asBoolean()); return; case LLSD::TypeInteger: ensure_equals(msg + " integer", actual.asInteger(), expected.asInteger()); return; case LLSD::TypeReal: ensure_equals(msg + " real", actual.asReal(), expected.asReal()); return; case LLSD::TypeString: ensure_equals(msg + " string", actual.asString(), expected.asString()); return; case LLSD::TypeUUID: ensure_equals(msg + " uuid", actual.asUUID(), expected.asUUID()); return; case LLSD::TypeDate: ensure_equals(msg + " date", actual.asDate(), expected.asDate()); return; case LLSD::TypeURI: ensure_equals(msg + " uri", actual.asURI(), expected.asURI()); return; case LLSD::TypeBinary: ensure_equals(msg + " binary", actual.asBinary(), expected.asBinary()); return; case LLSD::TypeMap: { ensure_equals(msg + " map size", actual.size(), expected.size()); LLSD::map_const_iterator actual_iter = actual.beginMap(); LLSD::map_const_iterator expected_iter = expected.beginMap(); while(actual_iter != actual.endMap()) { ensure_equals(msg + " map keys", actual_iter->first, expected_iter->first); ensure_equals(msg + "[" + actual_iter->first + "]", actual_iter->second, expected_iter->second); ++actual_iter; ++expected_iter; } return; } case LLSD::TypeArray: { ensure_equals(msg + " array size", actual.size(), expected.size()); for(int i = 0; i < actual.size(); ++i) { ensure_equals(msg + llformat("[%d]", i), actual[i], expected[i]); } return; } default: // should never get here, but compiler produces warning if we // don't cover this case, and at Linden warnings are fatal. throw failure(STRINGIZE("invalid type field " << actual.type())); } }
void LLWLParamSet::mix(LLWLParamSet& src, LLWLParamSet& dest, F32 weight) { // set up the iterators LLSD::map_iterator cIt = mParamValues.beginMap(); // keep cloud positions and coverage the same /// TODO masking will do this later F32 cloudPos1X = (F32) mParamValues["cloud_pos_density1"][0].asReal(); F32 cloudPos1Y = (F32) mParamValues["cloud_pos_density1"][1].asReal(); F32 cloudPos2X = (F32) mParamValues["cloud_pos_density2"][0].asReal(); F32 cloudPos2Y = (F32) mParamValues["cloud_pos_density2"][1].asReal(); F32 cloudCover = (F32) mParamValues["cloud_shadow"][0].asReal(); LLSD srcVal; LLSD destVal; // do the interpolation for all the ones saved as vectors // skip the weird ones for(; cIt != mParamValues.endMap(); cIt++) { // check params to make sure they're actually there if(src.mParamValues.has(cIt->first)) { srcVal = src.mParamValues[cIt->first]; } else { continue; } if(dest.mParamValues.has(cIt->first)) { destVal = dest.mParamValues[cIt->first]; } else { continue; } // skip if not a vector if(!cIt->second.isArray()) { continue; } // only Real vectors allowed if(!cIt->second[0].isReal()) { continue; } // make sure all the same size if( cIt->second.size() != srcVal.size() || cIt->second.size() != destVal.size()) { continue; } // more error checking might be necessary; for(int i=0; i < cIt->second.size(); ++i) { cIt->second[i] = (1.0f - weight) * (F32) srcVal[i].asReal() + weight * (F32) destVal[i].asReal(); } } // now mix the extra parameters setStarBrightness((1 - weight) * (F32) src.getStarBrightness() + weight * (F32) dest.getStarBrightness()); llassert(src.getSunAngle() >= - F_PI && src.getSunAngle() <= 3 * F_PI); llassert(dest.getSunAngle() >= - F_PI && dest.getSunAngle() <= 3 * F_PI); llassert(src.getEastAngle() >= 0 && src.getEastAngle() <= 4 * F_PI); llassert(dest.getEastAngle() >= 0 && dest.getEastAngle() <= 4 * F_PI); // sun angle and east angle require some handling to make sure // they go in circles. Yes quaternions would work better. F32 srcSunAngle = src.getSunAngle(); F32 destSunAngle = dest.getSunAngle(); F32 srcEastAngle = src.getEastAngle(); F32 destEastAngle = dest.getEastAngle(); if(fabsf(srcSunAngle - destSunAngle) > F_PI) { if(srcSunAngle > destSunAngle) { destSunAngle += 2 * F_PI; } else { srcSunAngle += 2 * F_PI; } } if(fabsf(srcEastAngle - destEastAngle) > F_PI) { if(srcEastAngle > destEastAngle) { destEastAngle += 2 * F_PI; } else { srcEastAngle += 2 * F_PI; } } setSunAngle((1 - weight) * srcSunAngle + weight * destSunAngle); setEastAngle((1 - weight) * srcEastAngle + weight * destEastAngle); // now setup the sun properly // reset those cloud positions mParamValues["cloud_pos_density1"][0] = cloudPos1X; mParamValues["cloud_pos_density1"][1] = cloudPos1Y; mParamValues["cloud_pos_density2"][0] = cloudPos2X; mParamValues["cloud_pos_density2"][1] = cloudPos2Y; mParamValues["cloud_shadow"][0] = cloudCover; }
void LLPanelPlaces::onOpen(const LLSD& key) { if (!mPlaceProfile || !mLandmarkInfo) return; if (key.size() != 0) { mFilterEditor->clear(); onFilterEdit("", false); mPlaceInfoType = key["type"].asString(); mPosGlobal.setZero(); mItem = NULL; isLandmarkEditModeOn = false; togglePlaceInfoPanel(TRUE); if (mPlaceInfoType == AGENT_INFO_TYPE) { mPlaceProfile->setInfoType(LLPanelPlaceInfo::AGENT); } else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE) { mLandmarkInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK); if (key.has("x") && key.has("y") && key.has("z")) { mPosGlobal = LLVector3d(key["x"].asReal(), key["y"].asReal(), key["z"].asReal()); } else { mPosGlobal = gAgent.getPositionGlobal(); } mLandmarkInfo->displayParcelInfo(LLUUID(), mPosGlobal); // Disabling "Save", "Close" and "Back" buttons to prevent closing "Create Landmark" // panel before created landmark is loaded. // These buttons will be enabled when created landmark is added to inventory. mSaveBtn->setEnabled(FALSE); mCloseBtn->setEnabled(FALSE); mLandmarkInfoBackBtn->setEnabled(FALSE); } else if (mPlaceInfoType == LANDMARK_INFO_TYPE) { mLandmarkInfo->setInfoType(LLPanelPlaceInfo::LANDMARK); LLInventoryItem* item = gInventory.getItem(key["id"].asUUID()); if (!item) return; setItem(item); } else if (mPlaceInfoType == REMOTE_PLACE_INFO_TYPE) { if (key.has("id")) { LLUUID parcel_id = key["id"].asUUID(); mPlaceProfile->setParcelID(parcel_id); // query the server to get the global 3D position of this // parcel - we need this for teleport/mapping functions. mRemoteParcelObserver->setParcelID(parcel_id); } else { mPosGlobal = LLVector3d(key["x"].asReal(), key["y"].asReal(), key["z"].asReal()); mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal); } mPlaceProfile->setInfoType(LLPanelPlaceInfo::PLACE); } else if (mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE) { S32 index = key["id"].asInteger(); const LLTeleportHistoryStorage::slurl_list_t& hist_items = LLTeleportHistoryStorage::getInstance()->getItems(); mPosGlobal = hist_items[index].mGlobalPos; mPlaceProfile->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY); mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal); } updateVerbs(); } LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance(); if (!parcel_mgr) return; // Start using LLViewerParcelMgr for land selection if // information about nearby land is requested. // Otherwise stop using land selection and deselect land. if (mPlaceInfoType == AGENT_INFO_TYPE) { // We don't know if we are already added to LLViewerParcelMgr observers list // so try to remove observer not to add an extra one. parcel_mgr->removeObserver(mParcelObserver); parcel_mgr->addObserver(mParcelObserver); parcel_mgr->selectParcelAt(gAgent.getPositionGlobal()); } else { parcel_mgr->removeObserver(mParcelObserver); // Clear the reference to selection to allow its removal in deselectUnused(). mParcel.clear(); if (!parcel_mgr->selectionEmpty()) { parcel_mgr->deselectUnused(); } } }
// static void LLFloaterSearch::search(const SearchQuery &p, LLMediaCtrl* mWebBrowser) { if (! mWebBrowser || !p.validateBlock()) { return; } // work out the subdir to use based on the requested category LLSD subs; // declare a map that transforms a category name into // the URL suffix that is used to search that category static LLSD mCategoryPaths = LLSD::emptyMap(); if (mCategoryPaths.size() == 0) { mCategoryPaths["all"] = "search"; mCategoryPaths["people"] = "search/people"; mCategoryPaths["places"] = "search/places"; mCategoryPaths["events"] = "search/events"; mCategoryPaths["groups"] = "search/groups"; mCategoryPaths["wiki"] = "search/wiki"; mCategoryPaths["destinations"] = "destinations"; mCategoryPaths["classifieds"] = "classifieds"; } if (mCategoryPaths.has(p.category)) { subs["CATEGORY"] = mCategoryPaths[p.category].asString(); } else { subs["CATEGORY"] = mCategoryPaths["all"].asString(); } // add the search query string subs["QUERY"] = LLURI::escape(p.query); // add the permissions token that login.cgi gave us // We use "search_token", and fallback to "auth_token" if not present. LLSD search_token = LLUserAuth::getInstance()->getResponse("search_token"); if (search_token.asString().empty()) { search_token = LLUserAuth::getInstance()->getResponse("auth_token"); } subs["AUTH_TOKEN"] = search_token.asString(); // add the user's preferred maturity (can be changed via prefs) std::string maturity; if (gAgent.prefersAdult()) { maturity = "42"; // PG,Mature,Adult } else if (gAgent.prefersMature()) { maturity = "21"; // PG,Mature } else { maturity = "13"; // PG } subs["MATURITY"] = maturity; // add the user's god status subs["GODLIKE"] = gAgent.isGodlike() ? "1" : "0"; // get the search URL and expand all of the substitutions // (also adds things like [LANGUAGE], [VERSION], [OS], etc.) std::string url = gSavedSettings.getString("SearchURL"); url = LLWeb::expandURLSubstitutions(url, subs); // and load the URL in the web view mWebBrowser->navigateTo(url, "text/html"); }