1 files changed, 176 insertions, 65 deletions

diff --git a/indra/newview/llwldaycycle.cpp b/indra/newview/llwldaycycle.cpp
index 85b3d62a49..e646b605a9 100644
--- a/indra/newview/llwldaycycle.cpp
+++ b/indra/newview/llwldaycycle.cpp
@@ -27,12 +27,12 @@
 #include "llviewerprecompiledheaders.h"
 
 #include "llwldaycycle.h"
-
-#include "llnotificationsutil.h"
 #include "llsdserialize.h"
-#include "llxmlnode.h"
-
 #include "llwlparammanager.h"
+#include "llfloaterdaycycle.h"
+#include "llnotifications.h"
+
+#include "llviewerwindow.h"
 
 #include <map>
 
@@ -45,85 +45,160 @@ LLWLDayCycle::~LLWLDayCycle()
 {
 }
 
-void LLWLDayCycle::loadDayCycle(const std::string & fileName)
+void LLWLDayCycle::loadDayCycle(const LLSD& day_data, LLWLParamKey::EScope scope)
 {
-	// clear the first few things
+	lldebugs << "Loading day cycle (day_data.size() = " << day_data.size() << ", scope = " << scope << ")" << llendl;
 	mTimeMap.clear();
 
-	// now load the file
-	std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, 
-		"windlight/days", fileName));
-	llinfos << "Loading DayCycle settings from " << pathName << llendl;
-	
-	llifstream day_cycle_xml(pathName);
-	if (day_cycle_xml.is_open())
+	// add each key frame
+	for(S32 i = 0; i < day_data.size(); ++i)
 	{
-		// load and parse it
-		LLSD day_data(LLSD::emptyArray());
-		LLPointer<LLSDParser> parser = new LLSDXMLParser();
-		parser->parse(day_cycle_xml, day_data, LLSDSerialize::SIZE_UNLIMITED);
-
-		// add each key
-		for(S32 i = 0; i < day_data.size(); ++i)
+		// make sure it's a two array
+		if(day_data[i].size() != 2)
+		{
+			continue;
+		}
+		
+		// check each param key exists in param manager
+		bool success;
+		LLWLParamSet pset;
+		LLWLParamKey frame = LLWLParamKey(day_data[i][1].asString(), scope);
+		success =
+			LLWLParamManager::getInstance()->getParamSet(frame, pset);
+		if(!success)
 		{
-			// make sure it's a two array
-			if(day_data[i].size() != 2)
+			// *HACK: If loading region day cycle, try local sky presets as well.
+			// Local presets may be referenced by a region day cycle after
+			// it has been edited but the changes have not been uploaded.
+			if (scope == LLEnvKey::SCOPE_REGION)
 			{
-				continue;
+				frame.scope = LLEnvKey::SCOPE_LOCAL;
+				success = LLWLParamManager::getInstance()->getParamSet(frame, pset);
 			}
-			
-			// check each param name exists in param manager
-			bool success;
-			LLWLParamSet pset;
-			success = LLWLParamManager::instance()->getParamSet(day_data[i][1].asString(), pset);
-			if(!success)
+
+			if (!success)
 			{
 				// alert the user
 				LLSD args;
 				args["SKY"] = day_data[i][1].asString();
-				LLNotificationsUtil::add("WLMissingSky", args);
+				LLNotifications::instance().add("WLMissingSky", args, LLSD());
 				continue;
 			}
-			
-			// then add the key
-			addKey((F32)day_data[i][0].asReal(), day_data[i][1].asString());
 		}
+		
+		// then add the keyframe
+		addKeyframe((F32)day_data[i][0].asReal(), frame);
+	}
+}
+
+void LLWLDayCycle::loadDayCycleFromFile(const std::string & fileName)
+{
+	loadDayCycle(loadCycleDataFromFile(fileName), LLWLParamKey::SCOPE_LOCAL);
+}
 
+/*static*/ LLSD LLWLDayCycle::loadCycleDataFromFile(const std::string & fileName)
+{
+	// *FIX: Cannot load user day cycles.
+	std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, 
+		"windlight/days", fileName));
+
+	return loadDayCycleFromPath(pathName);
+}
+
+// static
+LLSD LLWLDayCycle::loadDayCycleFromPath(const std::string& file_path)
+{
+	LL_INFOS("Windlight") << "Loading DayCycle settings from " << file_path << LL_ENDL;
+	
+	llifstream day_cycle_xml(file_path);
+	if (day_cycle_xml.is_open())
+	{
+		// load and parse it
+		LLSD day_data(LLSD::emptyArray());
+		LLPointer<LLSDParser> parser = new LLSDXMLParser();
+		parser->parse(day_cycle_xml, day_data, LLSDSerialize::SIZE_UNLIMITED);
 		day_cycle_xml.close();
+		return day_data;
+	}
+	else
+	{
+		return LLSD();
 	}
 }
 
 void LLWLDayCycle::saveDayCycle(const std::string & fileName)
 {
-	LLSD day_data(LLSD::emptyArray());
-
 	std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/days", fileName));
 	//llinfos << "Saving WindLight settings to " << pathName << llendl;
 
-	for(std::map<F32, std::string>::const_iterator mIt = mTimeMap.begin();
-		mIt != mTimeMap.end();
-		++mIt) 
+	save(pathName);
+}
+
+void LLWLDayCycle::save(const std::string& file_path)
+{
+	LLSD day_data = asLLSD();
+
+	llofstream day_cycle_xml(file_path);
+	LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
+	formatter->format(day_data, day_cycle_xml, LLSDFormatter::OPTIONS_PRETTY);
+	day_cycle_xml.close();
+}
+
+LLSD LLWLDayCycle::asLLSD()
+{
+	LLSD day_data(LLSD::emptyArray());
+	for(std::map<F32, LLWLParamKey>::const_iterator mIt = mTimeMap.begin(); mIt != mTimeMap.end(); ++mIt) 
 	{
 		LLSD key(LLSD::emptyArray());
 		key.append(mIt->first);
-		key.append(mIt->second);
+		key.append(mIt->second.name);
 		day_data.append(key);
 	}
 
-	llofstream day_cycle_xml(pathName);
-	LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
-	formatter->format(day_data, day_cycle_xml, LLSDFormatter::OPTIONS_PRETTY);
-	day_cycle_xml.close();
+	lldebugs << "Dumping day cycle (" << mTimeMap.size() << ") to LLSD: " << day_data << llendl;
+	return day_data;
 }
 
+bool LLWLDayCycle::getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const
+{
+	bool result = true;
+	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
+
+	refs.clear();
+	for (std::map<F32, LLWLParamKey>::const_iterator iter = mTimeMap.begin(); iter != mTimeMap.end(); ++iter)
+	{
+		const LLWLParamKey& key = iter->second;
+		if (!wl_mgr.getParamSet(key, refs[key]))
+		{
+			llwarns << "Cannot find sky [" << key.name << "] referenced by a day cycle" << llendl;
+			result = false;
+		}
+	}
+
+	return result;
+}
 
-void LLWLDayCycle::clearKeys()
+bool LLWLDayCycle::getSkyMap(LLSD& sky_map) const
 {
+	std::map<LLWLParamKey, LLWLParamSet> refs;
+
+	if (!getSkyRefs(refs))
+	{
+		return false;
+	}
+
+	sky_map = LLWLParamManager::createSkyMap(refs);
+	return true;
+}
+
+void LLWLDayCycle::clearKeyframes()
+{
+	lldebugs << "Clearing key frames" << llendl;
 	mTimeMap.clear();
 }
 
 
-bool LLWLDayCycle::addKey(F32 newTime, const std::string & paramName)
+bool LLWLDayCycle::addKeyframe(F32 newTime, LLWLParamKey frame)
 {
 	// no adding negative time
 	if(newTime < 0) 
@@ -134,48 +209,58 @@ bool LLWLDayCycle::addKey(F32 newTime, const std::string & paramName)
 	// if time not being used, add it and return true
 	if(mTimeMap.find(newTime) == mTimeMap.end()) 
 	{
-		mTimeMap.insert(std::pair<F32, std::string>(newTime, paramName));
+		mTimeMap.insert(std::pair<F32, LLWLParamKey>(newTime, frame));
+		lldebugs << "Adding key frame (" << newTime << ", " << frame.toLLSD() << ")" << llendl;
 		return true;
 	}
 
 	// otherwise, don't add, and return error
+	llwarns << "Error adding key frame (" << newTime << ", " << frame.toLLSD() << ")" << llendl;
 	return false;
 }
 
-bool LLWLDayCycle::changeKeyTime(F32 oldTime, F32 newTime)
+bool LLWLDayCycle::changeKeyframeTime(F32 oldTime, F32 newTime)
 {
+	lldebugs << "Changing key frame time (" << oldTime << " => " << newTime << ")" << llendl;
+
 	// just remove and add back
-	std::string name = mTimeMap[oldTime];
+	LLWLParamKey frame = mTimeMap[oldTime];
 
-	bool stat = removeKey(oldTime);
+	bool stat = removeKeyframe(oldTime);
 	if(stat == false) 
 	{
+		lldebugs << "Failed to change key frame time (" << oldTime << " => " << newTime << ")" << llendl;
 		return stat;
 	}
 
-	return addKey(newTime, name);
+	return addKeyframe(newTime, frame);
 }
 
-bool LLWLDayCycle::changeKeyParam(F32 time, const std::string & name)
+bool LLWLDayCycle::changeKeyframeParam(F32 time, LLWLParamKey key)
 {
+	lldebugs << "Changing key frame param (" << time << ", " << key.toLLSD() << ")" << llendl;
+
 	// just remove and add back
 	// make sure param exists
 	LLWLParamSet tmp;
-	bool stat = LLWLParamManager::instance()->getParamSet(name, tmp);
+	bool stat = LLWLParamManager::getInstance()->getParamSet(key, tmp);
 	if(stat == false) 
 	{
+		lldebugs << "Failed to change key frame param (" << time << ", " << key.toLLSD() << ")" << llendl;
 		return stat;
 	}
 
-	mTimeMap[time] = name;
+	mTimeMap[time] = key;
 	return true;
 }
 
 
-bool LLWLDayCycle::removeKey(F32 time)
+bool LLWLDayCycle::removeKeyframe(F32 time)
 {
+	lldebugs << "Removing key frame (" << time << ")" << llendl;
+
 	// look for the time.  If there, erase it
-	std::map<F32, std::string>::iterator mIt = mTimeMap.find(time);
+	std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time);
 	if(mIt != mTimeMap.end()) 
 	{
 		mTimeMap.erase(mIt);
@@ -185,15 +270,15 @@ bool LLWLDayCycle::removeKey(F32 time)
 	return false;
 }
 
-bool LLWLDayCycle::getKey(const std::string & name, F32& key)
+bool LLWLDayCycle::getKeytime(LLWLParamKey frame, F32& key_time) const
 {
-	// scroll through till we find the 
-	std::map<F32, std::string>::iterator mIt = mTimeMap.begin();
+	// scroll through till we find the correct value in the map
+	std::map<F32, LLWLParamKey>::const_iterator mIt = mTimeMap.begin();
 	for(; mIt != mTimeMap.end(); ++mIt) 
 	{
-		if(name == mIt->second) 
+		if(frame == mIt->second) 
 		{
-			key = mIt->first;
+			key_time = mIt->first;
 			return true;
 		}
 	}
@@ -204,26 +289,52 @@ bool LLWLDayCycle::getKey(const std::string & name, F32& key)
 bool LLWLDayCycle::getKeyedParam(F32 time, LLWLParamSet& param)
 {
 	// just scroll on through till you find it
-	std::map<F32, std::string>::iterator mIt = mTimeMap.find(time);
-	if(mIt != mTimeMap.end()) 
+	std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time);
+	if(mIt != mTimeMap.end())
 	{
-		return LLWLParamManager::instance()->getParamSet(mIt->second, param);
+		return LLWLParamManager::getInstance()->getParamSet(mIt->second, param);
 	}
 
 	// return error if not found
+	lldebugs << "Key " << time << " not found" << llendl;
 	return false;
 }
 
 bool LLWLDayCycle::getKeyedParamName(F32 time, std::string & name)
 {
 	// just scroll on through till you find it
-	std::map<F32, std::string>::iterator mIt = mTimeMap.find(time);
+	std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time);
 	if(mIt != mTimeMap.end()) 
 	{
-		name = mTimeMap[time];
+		name = mTimeMap[time].name;
 		return true;
 	}
 
 	// return error if not found
+	lldebugs << "Key " << time << " not found" << llendl;
 	return false;
 }
+
+bool LLWLDayCycle::hasReferencesTo(const LLWLParamKey& keyframe) const
+{
+	F32 dummy;
+	return getKeytime(keyframe, dummy);
+}
+
+void LLWLDayCycle::removeReferencesTo(const LLWLParamKey& keyframe)
+{
+	lldebugs << "Removing references to key frame " << keyframe.toLLSD() << llendl;
+	F32 keytime;
+	bool might_exist;
+	do 
+	{
+		// look for it
+		might_exist = getKeytime(keyframe, keytime);
+		if(!might_exist)
+		{
+			return;
+		}
+		might_exist = removeKeyframe(keytime);
+
+	} while(might_exist); // might be another one
+}