Second Life viewer sources 1.23.0-RC

1 files changed, 299 insertions, 0 deletions

diff --git a/linden/indra/llui/lltextparser.cpp b/linden/indra/llui/lltextparser.cpp
new file mode 100644
index 0000000..925b118
--- /dev/null
+++ b/linden/indra/llui/lltextparser.cpp
@@ -0,0 +1,299 @@
+/** 
+ * @file lltexteditor.cpp
+ * @brief LLTextEditor base class
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llsd.h"
+#include "llsdserialize.h"
+#include "llerror.h"
+#include "lluuid.h"
+#include "llstring.h"
+#include "message.h"
+#include "llmath.h"
+#include "v4color.h"
+#include "audioengine.h"
+#include "llwindow.h"
+#include "lldir.h"
+
+#include "lltextparser.h"
+//#include "lltexttospeech.h"
+
+// Routines used for parsing text for TextParsers and html
+
+LLTextParser* LLTextParser::sInstance = NULL;
+
+//
+// Constants
+//
+const F32 SOUND_GAIN = 1.0f;
+
+//
+// Member Functions
+//
+
+LLTextParser::~LLTextParser()
+{
+        sInstance=NULL;
+}
+
+// static
+LLTextParser* LLTextParser::getInstance()
+{
+        if (!sInstance)
+        {
+                sInstance = new LLTextParser();
+                sInstance->loadFromDisk();
+        }
+        return sInstance;
+}
+
+void LLTextParser::triggerAlerts(LLUUID agent_id, LLVector3d position, std::string text, LLWindow* viewer_window)
+{
+//    bool spoken=FALSE;
+        for (S32 i=0;i<mHighlights.size();i++)
+        {
+                if (findPattern(text,mHighlights[i]) >= 0 )
+                {
+                        if(gAudiop)
+                        {
+                                if ((std::string)mHighlights[i]["sound_lluuid"] != LLUUID::null.asString())
+                                {
+                                        gAudiop->triggerSound(mHighlights[i]["sound_lluuid"].asUUID(), agent_id, SOUND_GAIN, LLAudioEngine::AUDIO_TYPE_UI, position);
+                                }
+/*                              
+                                if (!spoken) 
+                                {
+                                        LLTextToSpeech* text_to_speech = NULL;
+                                        text_to_speech = LLTextToSpeech::getInstance();
+                                        spoken = text_to_speech->speak((LLString)mHighlights[i]["voice"],text); 
+                                }
+ */
+                        }
+                        if (mHighlights[i]["flash"])
+                        {
+                                if (viewer_window && viewer_window->getMinimized())
+                                {
+                                        viewer_window->flashIcon(5.f);
+                                }
+                        }
+                }
+        }
+}
+
+S32 LLTextParser::findPattern(const std::string &text, LLSD highlight)
+{
+        if (!highlight.has("pattern")) return -1;
+        
+        std::string pattern=std::string(highlight["pattern"]);
+        std::string ltext=text;
+        
+        if (!(bool)highlight["case_sensitive"])
+        {
+                ltext   = utf8str_tolower(text);
+                pattern= utf8str_tolower(pattern);
+        }
+
+        size_t found=std::string::npos;
+        
+        switch ((S32)highlight["condition"])
+        {
+                case CONTAINS:
+                        found = ltext.find(pattern); 
+                        break;
+                case MATCHES:
+                    found = (! ltext.compare(pattern) ? 0 : std::string::npos);
+                        break;
+                case STARTS_WITH:
+                        found = (! ltext.find(pattern) ? 0 : std::string::npos);
+                        break;
+                case ENDS_WITH:
+                        S32 pos = ltext.rfind(pattern); 
+                        if (pos >= 0 && (ltext.length()-pattern.length()==pos)) found = pos;
+                        break;
+        }
+        return found;
+}
+
+LLSD LLTextParser::parsePartialLineHighlights(const std::string &text, const LLColor4 &color, S32 part, S32 index)
+{
+        //evil recursive string atomizer.
+        LLSD ret_llsd, start_llsd, middle_llsd, end_llsd;
+
+        for (S32 i=index;i<mHighlights.size();i++)
+        {
+                S32 condition = mHighlights[i]["condition"];
+                if ((S32)mHighlights[i]["highlight"]==PART && condition!=MATCHES)
+                {
+                        if ( (condition==STARTS_WITH && part==START) ||
+                             (condition==ENDS_WITH   && part==END)   ||
+                                  condition==CONTAINS    || part==WHOLE )
+                        {
+                                S32 start = findPattern(text,mHighlights[i]);
+                                if (start >= 0 )
+                                {
+                                        S32 end =  std::string(mHighlights[i]["pattern"]).length();
+                                        S32 len = text.length();
+                                        S32 newpart;
+                                        if (start==0)
+                                        {
+                                                start_llsd[0]["text"] =text.substr(0,end);
+                                                start_llsd[0]["color"]=mHighlights[i]["color"];
+                                                
+                                                if (end < len)
+                                                {
+                                                        if (part==END   || part==WHOLE) newpart=END; else newpart=MIDDLE;
+                                                        end_llsd=parsePartialLineHighlights(text.substr( end ),color,newpart,i);
+                                                }
+                                        }
+                                        else
+                                        {
+                                                if (part==START || part==WHOLE) newpart=START; else newpart=MIDDLE;
+
+                                                start_llsd=parsePartialLineHighlights(text.substr(0,start),color,newpart,i+1);
+                                                
+                                                if (end < len)
+                                                {
+                                                        middle_llsd[0]["text"] =text.substr(start,end);
+                                                        middle_llsd[0]["color"]=mHighlights[i]["color"];
+                                                
+                                                        if (part==END   || part==WHOLE) newpart=END; else newpart=MIDDLE;
+
+                                                        end_llsd=parsePartialLineHighlights(text.substr( (start+end) ),color,newpart,i);
+                                                }
+                                                else
+                                                {
+                                                        end_llsd[0]["text"] =text.substr(start,end);
+                                                        end_llsd[0]["color"]=mHighlights[i]["color"];
+                                                }
+                                        }
+                                                
+                                        S32 retcount=0;
+                                        
+                                        //FIXME These loops should be wrapped into a subroutine.
+                                        for (LLSD::array_iterator iter = start_llsd.beginArray();
+                                                 iter != start_llsd.endArray();++iter)
+                                        {
+                                                LLSD highlight = *iter;
+                                                ret_llsd[retcount++]=highlight;
+                                        }
+                                                   
+                                        for (LLSD::array_iterator iter = middle_llsd.beginArray();
+                                                 iter != middle_llsd.endArray();++iter)
+                                        {
+                                                LLSD highlight = *iter;
+                                                ret_llsd[retcount++]=highlight;
+                                        }
+                                                   
+                                        for (LLSD::array_iterator iter = end_llsd.beginArray();
+                                                 iter != end_llsd.endArray();++iter)
+                                        {
+                                                LLSD highlight = *iter;
+                                                ret_llsd[retcount++]=highlight;
+                                        }
+                                                   
+                                        return ret_llsd;
+                                }
+                        }
+                }
+        }
+        
+        //No patterns found.  Just send back what was passed in.
+        ret_llsd[0]["text"] =text;
+        LLSD color_sd = color.getValue();
+        ret_llsd[0]["color"]=color_sd;
+        return ret_llsd;
+}
+
+bool LLTextParser::parseFullLineHighlights(const std::string &text, LLColor4 *color)
+{
+        for (S32 i=0;i<mHighlights.size();i++)
+        {
+                if ((S32)mHighlights[i]["highlight"]==ALL || (S32)mHighlights[i]["condition"]==MATCHES)
+                {
+                        if (findPattern(text,mHighlights[i]) >= 0 )
+                        {
+                                LLSD color_llsd = mHighlights[i]["color"];
+                                color->setValue(color_llsd);
+                                return TRUE;
+                        }
+                }
+        }
+        return FALSE;   //No matches found.
+}
+
+std::string LLTextParser::getFileName()
+{
+        std::string path=gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "");
+        
+        if (!path.empty())
+        {
+                path = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "highlights.xml");
+        }
+        return path;  
+}
+
+LLSD LLTextParser::loadFromDisk()
+{
+        std::string filename=getFileName();
+        if (filename.empty())
+        {
+                llwarns << "LLTextParser::loadFromDisk() no valid user directory." << llendl; 
+        }
+        else
+        {
+                llifstream file;
+                file.open(filename.c_str());
+                if (file.is_open())
+                {
+                        LLSDSerialize::fromXML(mHighlights, file);
+                }
+                file.close();
+        }
+
+        return mHighlights;
+}
+
+bool LLTextParser::saveToDisk(LLSD highlights)
+{
+        mHighlights=highlights;
+        std::string filename=getFileName();
+        if (filename.empty())
+        {
+                llwarns << "LLTextParser::saveToDisk() no valid user directory." << llendl; 
+                return FALSE;
+        }       
+        llofstream file;
+        file.open(filename.c_str());
+        LLSDSerialize::toPrettyXML(mHighlights, file);
+        file.close();
+        return TRUE;
+}