311 lines
9.6 KiB
C++
311 lines
9.6 KiB
C++
/**
|
|
* @file alfloaterregiontracker.cpp
|
|
* @brief Region tracking floater
|
|
*
|
|
* $LicenseInfo:firstyear=2013&license=viewerlgpl$
|
|
* Alchemy Viewer Source Code
|
|
* Copyright (C) 2014, Alchemy Viewer Project.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "alfloaterregiontracker.h"
|
|
|
|
// library
|
|
#include "llbutton.h"
|
|
#include "lldir.h"
|
|
#include "llfile.h"
|
|
#include "llscrolllistctrl.h"
|
|
#include "llsd.h"
|
|
#include "llsdserialize.h"
|
|
#include "llsdserialize_xml.h"
|
|
#include "lltextbox.h"
|
|
|
|
// newview
|
|
#include "llagent.h"
|
|
#include "llfloaterworldmap.h"
|
|
#include "llfloaterreg.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llviewermessage.h"
|
|
#include "llworldmap.h"
|
|
#include "llworldmapmessage.h"
|
|
|
|
const std::string TRACKER_FILE = "tracked_regions.json";
|
|
const F64 REGION_UPDATE_TIMER = 60.0;
|
|
|
|
ALFloaterRegionTracker::ALFloaterRegionTracker(const LLSD& key)
|
|
: LLFloater(key),
|
|
LLEventTimer(5.f),
|
|
mRefreshRegionListBtn(NULL),
|
|
mRemoveRegionBtn(NULL),
|
|
mOpenMapBtn(NULL),
|
|
mRegionScrollList(NULL),
|
|
mLastRegionUpdate(0.0)
|
|
{
|
|
loadFromJSON();
|
|
}
|
|
|
|
ALFloaterRegionTracker::~ALFloaterRegionTracker()
|
|
{
|
|
saveToJSON();
|
|
}
|
|
|
|
bool ALFloaterRegionTracker::postBuild()
|
|
{
|
|
mRefreshRegionListBtn = getChild<LLButton>("refresh");
|
|
mRefreshRegionListBtn->setClickedCallback(boost::bind(&ALFloaterRegionTracker::refresh, this));
|
|
|
|
mRemoveRegionBtn = getChild<LLButton>("remove");
|
|
mRemoveRegionBtn->setClickedCallback(boost::bind(&ALFloaterRegionTracker::removeRegions, this));
|
|
|
|
mOpenMapBtn = getChild<LLButton>("open_map");
|
|
mOpenMapBtn->setClickedCallback(boost::bind(&ALFloaterRegionTracker::openMap, this));
|
|
|
|
mRegionScrollList = getChild<LLScrollListCtrl>("region_list");
|
|
mRegionScrollList->setCommitOnSelectionChange(true);
|
|
mRegionScrollList->setCommitCallback(boost::bind(&ALFloaterRegionTracker::updateHeader, this));
|
|
mRegionScrollList->setDoubleClickCallback(boost::bind(&ALFloaterRegionTracker::openMap, this));
|
|
|
|
updateHeader();
|
|
|
|
return LLFloater::postBuild();
|
|
}
|
|
|
|
void ALFloaterRegionTracker::onOpen(const LLSD& key)
|
|
{
|
|
requestRegionData();
|
|
mEventTimer.start();
|
|
refresh();
|
|
}
|
|
|
|
void ALFloaterRegionTracker::onClose(bool app_quitting)
|
|
{
|
|
mEventTimer.stop();
|
|
}
|
|
|
|
void ALFloaterRegionTracker::updateHeader()
|
|
{
|
|
S32 num_selected(mRegionScrollList->getNumSelected());
|
|
mRefreshRegionListBtn->setEnabled(mRegionMap.size() != 0);
|
|
mRemoveRegionBtn->setEnabled(!!num_selected);
|
|
mOpenMapBtn->setEnabled(num_selected <= 1);
|
|
}
|
|
|
|
void ALFloaterRegionTracker::refresh()
|
|
{
|
|
if (!mRegionMap.size())
|
|
{
|
|
updateHeader();
|
|
return;
|
|
}
|
|
|
|
const std::string& saved_selected_value = mRegionScrollList->getSelectedValue().asString();
|
|
S32 saved_scroll_pos = mRegionScrollList->getScrollPos();
|
|
mRegionScrollList->deleteAllItems();
|
|
|
|
const std::string& cur_region_name = gAgent.getRegion() ? gAgent.getRegion()->getName() : LLStringUtil::null;
|
|
|
|
F64 time_now = LLTimer::getElapsedSeconds();
|
|
bool request_region_update = (time_now - mLastRegionUpdate > REGION_UPDATE_TIMER);
|
|
if (request_region_update)
|
|
{
|
|
mLastRegionUpdate = time_now;
|
|
}
|
|
|
|
for (LLSD::map_const_iterator it = mRegionMap.beginMap(); it != mRegionMap.endMap(); it++)
|
|
{
|
|
const std::string& sim_name = it->first;
|
|
const LLSD& data = it->second;
|
|
if (data.isMap()) // Assume the rest is correct.
|
|
{
|
|
LLScrollListCell::Params label;
|
|
LLScrollListCell::Params maturity;
|
|
LLScrollListCell::Params region;
|
|
LLScrollListCell::Params count;
|
|
label.column("region_label").type("text").value(data["label"].asString());
|
|
maturity.column("region_maturity_icon").type("icon").font_halign(LLFontGL::HCENTER);
|
|
region.column("region_name").type("text").value(sim_name);
|
|
count.column("region_agent_count").type("text").value("...");
|
|
if (LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromName(sim_name))
|
|
{
|
|
maturity.value(info->getAccessIcon());
|
|
|
|
info->updateAgentCount(LLTimer::getElapsedSeconds());
|
|
S32 agent_count = info->getAgentCount();
|
|
if (info->isDown())
|
|
{
|
|
label.color(LLColor4::red);
|
|
maturity.color(LLColor4::red);
|
|
region.color(LLColor4::red);
|
|
count.color(LLColor4::red);
|
|
count.value(0);
|
|
}
|
|
else
|
|
{
|
|
count.value((sim_name == cur_region_name) ? agent_count + 1 : agent_count);
|
|
}
|
|
|
|
if (request_region_update)
|
|
{
|
|
LLWorldMapMessage::getInstance()->sendNamedRegionRequest(sim_name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
label.color(LLColor4::grey);
|
|
maturity.color(LLColor4::grey);
|
|
region.color(LLColor4::grey);
|
|
count.color(LLColor4::grey);
|
|
|
|
LLWorldMapMessage::getInstance()->sendNamedRegionRequest(sim_name);
|
|
if (!mEventTimer.getStarted()) mEventTimer.start();
|
|
}
|
|
LLScrollListItem::Params row;
|
|
row.value = sim_name;
|
|
row.columns.add(label);
|
|
row.columns.add(maturity);
|
|
row.columns.add(region);
|
|
row.columns.add(count);
|
|
mRegionScrollList->addRow(row);
|
|
}
|
|
}
|
|
if (!saved_selected_value.empty())
|
|
{
|
|
mRegionScrollList->selectByValue(saved_selected_value);
|
|
}
|
|
mRegionScrollList->setScrollPos(saved_scroll_pos);
|
|
}
|
|
|
|
bool ALFloaterRegionTracker::tick()
|
|
{
|
|
refresh();
|
|
return false;
|
|
}
|
|
|
|
void ALFloaterRegionTracker::requestRegionData()
|
|
{
|
|
if (!mRegionMap.size())
|
|
return;
|
|
|
|
for (LLSD::map_const_iterator it = mRegionMap.beginMap(); it != mRegionMap.endMap(); it++)
|
|
{
|
|
const std::string& name = it->first;
|
|
if (LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromName(name))
|
|
{
|
|
info->updateAgentCount(LLTimer::getElapsedSeconds());
|
|
}
|
|
else
|
|
{
|
|
LLWorldMapMessage::getInstance()->sendNamedRegionRequest(name);
|
|
}
|
|
}
|
|
mEventTimer.start();
|
|
}
|
|
|
|
void ALFloaterRegionTracker::removeRegions()
|
|
{
|
|
typedef std::vector<LLScrollListItem*> item_t;
|
|
item_t items = mRegionScrollList->getAllSelected();
|
|
for (item_t::const_iterator it = items.begin(); it != items.end(); ++it)
|
|
{
|
|
mRegionMap.erase((*it)->getValue().asString());
|
|
}
|
|
mRegionScrollList->deleteSelectedItems();
|
|
saveToJSON();
|
|
updateHeader();
|
|
}
|
|
|
|
bool ALFloaterRegionTracker::saveToJSON()
|
|
{
|
|
const std::string& filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, TRACKER_FILE);
|
|
llofstream out_file;
|
|
out_file.open(filename.c_str());
|
|
if (out_file.is_open())
|
|
{
|
|
LLSDSerialize::toPrettyNotation(mRegionMap, out_file);
|
|
out_file.close();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ALFloaterRegionTracker::loadFromJSON()
|
|
{
|
|
const std::string& filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, TRACKER_FILE);
|
|
llifstream in_file;
|
|
in_file.open(filename.c_str());
|
|
if (in_file.is_open())
|
|
{
|
|
LLSDSerialize::fromNotation(mRegionMap, in_file, LLSDSerialize::SIZE_UNLIMITED);
|
|
in_file.close();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::string ALFloaterRegionTracker::getRegionLabelIfExists(const std::string& name)
|
|
{
|
|
return mRegionMap.get(name)["label"].asString();
|
|
}
|
|
|
|
void ALFloaterRegionTracker::onRegionAddedCallback(const LLSD& notification, const LLSD& response)
|
|
{
|
|
const S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
|
|
if (option == 0)
|
|
{
|
|
const std::string& name = notification["payload"]["name"].asString();
|
|
std::string label = response["label"].asString();
|
|
LLStringUtil::trim(label);
|
|
if (!name.empty() && !label.empty())
|
|
{
|
|
if (mRegionMap.has(name))
|
|
{
|
|
for (LLSD::map_iterator it = mRegionMap.beginMap(); it != mRegionMap.endMap(); it++)
|
|
if (it->first == name) it->second["label"] = label;
|
|
}
|
|
else
|
|
{
|
|
LLSD region;
|
|
region["label"] = label;
|
|
mRegionMap.insert(name, region);
|
|
}
|
|
saveToJSON();
|
|
refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ALFloaterRegionTracker::openMap()
|
|
{
|
|
if (mRegionScrollList->getNumSelected() == 0)
|
|
{
|
|
LLFloaterReg::showInstance("world_map", "center");
|
|
}
|
|
else
|
|
{
|
|
const std::string& region = mRegionScrollList->getFirstSelected()->getValue().asString();
|
|
LLFloaterWorldMap* worldmap_floaterp = LLFloaterWorldMap::getInstance();
|
|
if (!region.empty() && worldmap_floaterp)
|
|
{
|
|
worldmap_floaterp->trackURL(region, 128, 128, 0);
|
|
LLFloaterReg::showInstance("world_map", "center");
|
|
}
|
|
}
|
|
}
|