Merge branch 'animesh' of https://github.com/Lirusaito/SingularityViewer.git into animesh

indra/llcommon/lluuid.h

@@ -57,10 +57,10 @@ public:
 	LLUUID();
 	explicit LLUUID(const char *in_string); // Convert from string.
 	explicit LLUUID(const std::string& in_string); // Convert from string.
-	LLUUID(const LLUUID &in);
+	LLUUID(const LLUUID &in) = default;
-	LLUUID &operator=(const LLUUID &rhs);
+	LLUUID &operator=(const LLUUID &rhs) = default;
 
-	~LLUUID();
+	~LLUUID() = default;
 
 	//
 	// MANIPULATORS
@@ -193,24 +193,6 @@ inline BOOL LLUUID::isNull() const
 	return !memcmp(mData, null.mData, sizeof(mData)); // <alchemy/>
 }
 
-// Copy constructor
-inline LLUUID::LLUUID(const LLUUID& rhs)
-{
-	memcpy(mData, rhs.mData, sizeof(mData)); // <alchemy/>
-}
-
-inline LLUUID::~LLUUID()
-{
-}
-
-// Assignment
-inline LLUUID& LLUUID::operator=(const LLUUID& rhs)
-{
-	memcpy(mData, rhs.mData, sizeof(mData)); // <alchemy/>
-	return *this;
-}
-
-
 inline LLUUID::LLUUID(const char *in_string)
 {
 	if (!in_string || in_string[0] == 0)
@@ -289,6 +271,8 @@ inline U32 LLUUID::getCRC32() const
 	// </alchemy>
 }
 
+static_assert(std::is_trivially_copyable<LLUUID>{}, "LLUUID must be a trivially copyable type");
+
 typedef std::vector<LLUUID> uuid_vec_t;
 typedef boost::unordered_set<LLUUID> uuid_set_t;
 

indra/llmath/llmatrix3a.h

@@ -127,4 +127,6 @@ public:
 	inline bool isOkRotation() const;		
 } LL_ALIGN_POSTFIX(16);
 
+static_assert(std::is_trivially_copyable<LLMatrix3a>{}, "LLMatrix3a must be a trivially copyable type");
+static_assert(std::is_trivially_copyable<LLRotation>{}, "LLRotation must be a trivially copyable type");
 #endif

indra/llmath/llmatrix4a.h

@@ -708,4 +708,6 @@ inline std::ostream& operator<<(std::ostream& s, const LLMatrix4a& m)
 } 
 
 void matMulBoundBox(const LLMatrix4a &a, const LLVector4a *in_extents, LLVector4a *out_extents);
+
+static_assert(std::is_trivially_copyable<LLMatrix4a>{}, "LLMatrix4a must be a trivially copyable type");
 #endif

indra/llmath/llquaternion.h

@@ -191,6 +191,8 @@ inline void LLQuaternion::setValue(const LLSD& sd)
     mQ[3] = sd[3].asReal();
 }
 
+static_assert(std::is_trivially_copyable<LLQuaternion>{}, "LLQuaternion must be a trivially copyable type");
+
 // checker
 inline BOOL	LLQuaternion::isFinite() const
 {

indra/llmath/llquaternion2.h

@@ -105,4 +105,6 @@ protected:
 
 } LL_ALIGN_POSTFIX(16);
 
+static_assert(std::is_trivially_copyable<LLQuaternion2>{}, "LLQuaternion2 must be a trivially copyable type");
+
 #endif

indra/llmath/llsimdtypes.h

@@ -121,4 +121,7 @@ private:
 	LLQuad mQ;
 };
 
+static_assert(std::is_trivially_copyable<LLBool32>{}, "LLBool32 must be a trivially copyable type");
+static_assert(std::is_trivially_copyable<LLSimdScalar>{}, "LLSimdScalar must be a trivially copyable type");
+
 #endif //LL_SIMD_TYPES_H

indra/llmath/llvector4a.h

@@ -96,12 +96,12 @@ public:
 	{ //DO NOT INITIALIZE -- The overhead is completely unnecessary
 		ll_assert_aligned(this,16);
 	}
-	
+
 	LLVector4a(F32 x, F32 y, F32 z, F32 w = 0.f)
 	{
-		set(x,y,z,w);
+		set(x, y, z, w);
 	}
-	
+
 	LLVector4a(F32 x)
 	{
 		splat(x);
@@ -320,9 +320,13 @@ public:
 	////////////////////////////////////	
 	
 	// Do NOT add aditional operators without consulting someone with SSE experience
-	inline const LLVector4a& operator= ( const LLVector4a& rhs );
+	//inline const LLVector4a& operator= ( const LLVector4a& rhs );
+	//{
+	//	mQ = rhs.mQ;
+	//	return *this;
+	//}
 	
-	inline const LLVector4a& operator= ( const LLQuad& rhs );
+	inline const LLVector4a& operator= (const LLQuad& rhs);
 
 	inline operator LLQuad() const;	
 
@@ -341,4 +345,6 @@ inline std::ostream& operator<<(std::ostream& s, const LLVector4a& v)
 	s << "(" << v[0] << ", " << v[1] << ", " << v[2] << ", " << v[3] << ")";
 	return s;
 }
+
+static_assert(std::is_trivially_copyable<LLVector4a>{}, "LLVector4a must be a trivially copyable type");
 #endif

indra/llmath/llvector4a.inl

@@ -605,13 +605,7 @@ inline bool LLVector4a::equals3(const LLVector4a& rhs, F32 tolerance ) const
 ////////////////////////////////////	
 
 // Do NOT add aditional operators without consulting someone with SSE experience
-inline const LLVector4a& LLVector4a::operator= ( const LLVector4a& rhs )
+inline const LLVector4a& LLVector4a::operator= (const LLQuad& rhs)
-{
-	mQ = rhs.mQ;
-	return *this;
-}
-
-inline const LLVector4a& LLVector4a::operator= ( const LLQuad& rhs )
 {
 	mQ = rhs;
 	return *this;

indra/llmath/m3math.h

@@ -144,6 +144,8 @@ class LLMatrix3
 		friend std::ostream&	 operator<<(std::ostream& s, const LLMatrix3 &a);	// Stream a
 };
 
+static_assert(std::is_trivially_copyable<LLMatrix3>{}, "LLMatrix3 must be a trivially copyable type");
+
 inline LLMatrix3::LLMatrix3(void)
 {
 	mMatrix[0][0] = 1.f;

indra/llmath/m4math.cpp

@@ -152,10 +152,6 @@ LLMatrix4::LLMatrix4(const F32 roll, const F32 pitch, const F32 yaw)
 	mMatrix[3][3] = 1.f;
 }
 
-LLMatrix4::~LLMatrix4(void)
-{
-}
-
 // Clear and Assignment Functions
 
 const LLMatrix4& LLMatrix4::setZero()

indra/llmath/m4math.h

@@ -117,7 +117,7 @@ public:
 			  const LLVector4 &pos);						// Initializes Matrix with Euler angles
 	LLMatrix4(const F32 roll, const F32 pitch, const F32 yaw);				// Initializes Matrix with Euler angles
 
-	~LLMatrix4(void);										// Destructor
+	~LLMatrix4() = default;									// Destructor
 
 	LLSD getValue() const;
 	void setValue(const LLSD&);
@@ -246,6 +246,8 @@ public:
 	friend std::ostream&	 operator<<(std::ostream& s, const LLMatrix4 &a);	// Stream a
 };
 
+static_assert(std::is_trivially_copyable<LLMatrix4>{}, "LLMatrix4 must be a trivially copyable type");
+
 inline const LLMatrix4&	LLMatrix4::setIdentity()
 {
 	mMatrix[0][0] = 1.f;

indra/llmath/v2math.h

@@ -110,6 +110,7 @@ class LLVector2
 		friend std::ostream&	 operator<<(std::ostream& s, const LLVector2 &a);		// Stream a
 };
 
+static_assert(std::is_trivially_copyable<LLVector2>{}, "LLVector2 must be a trivially copyable type");
 
 // Non-member functions 
 

indra/llmath/v3color.h

@@ -140,6 +140,8 @@ public:
 	inline void exp();	// Do an exponential on the color
 };
 
+static_assert(std::is_trivially_copyable<LLColor3>{}, "LLColor3 must be a trivially copyable type");
+
 LLColor3 lerp(const LLColor3 &a, const LLColor3 &b, F32 u);
 
 

indra/llmath/v3dmath.h

@@ -130,6 +130,8 @@ class LLVector3d
 
 };
 
+static_assert(std::is_trivially_copyable<LLVector3d>{}, "LLVector3d must be a trivially copyable type");
+
 typedef LLVector3d LLGlobalVec;
 
 inline const LLVector3d &LLVector3d::set(const LLVector3 &vec)

indra/llmath/v3math.h

@@ -149,6 +149,8 @@ class LLVector3
 		static BOOL parseVector3(const std::string& buf, LLVector3* value);
 };
 
+static_assert(std::is_trivially_copyable<LLVector3>{}, "LLVector3 must be a trivially copyable type");
+
 typedef LLVector3 LLSimLocalVec;
 
 // Non-member functions 

indra/llmath/v4color.h

@@ -222,6 +222,7 @@ class LLColor4
 		inline void clamp();
 };
 
+static_assert(std::is_trivially_copyable<LLColor4>{}, "LLColor4 must be a trivially copyable type");
 
 // Non-member functions 
 F32		distVec(const LLColor4 &a, const LLColor4 &b);			// Returns distance between a and b

indra/llmath/v4coloru.h

@@ -139,6 +139,7 @@ public:
 	static LLColor4U blue;
 };
 
+static_assert(std::is_trivially_copyable<LLColor4U>{}, "LLColor4U must be a trivially copyable type");
 
 // Non-member functions 
 F32		distVec(const LLColor4U &a, const LLColor4U &b);			// Returns distance between a and b

indra/llmath/v4math.h

@@ -137,6 +137,8 @@ class LLVector4
 		friend LLVector4 operator-(const LLVector4 &a);					// Return vector -a
 };
 
+static_assert(std::is_trivially_copyable<LLVector4>{}, "LLVector4 must be a trivially copyable type");
+
 // Non-member functions 
 F32 angle_between(const LLVector4 &a, const LLVector4 &b);		// Returns angle (radians) between a and b
 BOOL are_parallel(const LLVector4 &a, const LLVector4 &b, F32 epsilon=F_APPROXIMATELY_ZERO);		// Returns TRUE if a and b are very close to parallel

indra/llprimitive/llmaterialid.cpp

@@ -56,15 +56,6 @@ LLMaterialID::LLMaterialID(const void* pMemory)
 	set(pMemory);
 }
 
-LLMaterialID::LLMaterialID(const LLMaterialID& pOtherMaterialID)
-{
-	copyFromOtherMaterialID(pOtherMaterialID);
-}
-
-LLMaterialID::~LLMaterialID()
-{
-}
-
 bool LLMaterialID::operator == (const LLMaterialID& pOtherMaterialID) const
 {
 	return (compareToOtherMaterialID(pOtherMaterialID) == 0);
@@ -95,12 +86,6 @@ bool LLMaterialID::operator >= (const LLMaterialID& pOtherMaterialID) const
 	return (compareToOtherMaterialID(pOtherMaterialID) >= 0);
 }
 
-LLMaterialID& LLMaterialID::operator = (const LLMaterialID& pOtherMaterialID)
-{
-	copyFromOtherMaterialID(pOtherMaterialID);
-	return (*this);
-}
-
 bool LLMaterialID::isNull() const
 {
 	return (compareToOtherMaterialID(LLMaterialID::null) == 0);
@@ -116,12 +101,12 @@ void LLMaterialID::set(const void* pMemory)
 	llassert(pMemory != NULL);
 
 	// assumes that the required size of memory is available
-	memcpy(mID, pMemory, MATERIAL_ID_SIZE * sizeof(U8));
+	memcpy(mID, pMemory, sizeof(mID));
 }
 
 void LLMaterialID::clear()
 {
-	memset(mID, 0, MATERIAL_ID_SIZE * sizeof(U8));
+	memset(mID, 0, sizeof(mID));
 }
 
 LLSD LLMaterialID::asLLSD() const
@@ -156,18 +141,12 @@ std::ostream& operator<<(std::ostream& s, const LLMaterialID &material_id)
 	return s;
 }
 
-
 void LLMaterialID::parseFromBinary (const LLSD::Binary& pMaterialID)
 {
 	llassert(pMaterialID.size() == (MATERIAL_ID_SIZE * sizeof(U8)));
 	memcpy(mID, &pMaterialID[0], MATERIAL_ID_SIZE * sizeof(U8));
 }
 
-void LLMaterialID::copyFromOtherMaterialID(const LLMaterialID& pOtherMaterialID)
-{
-	memcpy(mID, pOtherMaterialID.get(), MATERIAL_ID_SIZE * sizeof(U8));
-}
-
 int LLMaterialID::compareToOtherMaterialID(const LLMaterialID& pOtherMaterialID) const
 {
 	int retVal = 0;

indra/llprimitive/llmaterialid.h

@@ -39,8 +39,8 @@ public:
 	LLMaterialID(const LLSD& pMaterialID);
 	LLMaterialID(const LLSD::Binary& pMaterialID);
 	LLMaterialID(const void* pMemory);
-	LLMaterialID(const LLMaterialID& pOtherMaterialID);
+	LLMaterialID(const LLMaterialID& pOtherMaterialID) = default;
-	~LLMaterialID();
+	~LLMaterialID() = default;
 
 	bool          operator == (const LLMaterialID& pOtherMaterialID) const;
 	bool          operator != (const LLMaterialID& pOtherMaterialID) const;
@@ -50,7 +50,7 @@ public:
 	bool          operator > (const LLMaterialID& pOtherMaterialID) const;
 	bool          operator >= (const LLMaterialID& pOtherMaterialID) const;
 
-	LLMaterialID& operator = (const LLMaterialID& pOtherMaterialID);
+	LLMaterialID& operator = (const LLMaterialID& pOtherMaterialID) = default;
 
 	bool          isNull() const;
 
@@ -67,11 +67,13 @@ public:
 
 private:
 	void parseFromBinary(const LLSD::Binary& pMaterialID);
-	void copyFromOtherMaterialID(const LLMaterialID& pOtherMaterialID);
 	int  compareToOtherMaterialID(const LLMaterialID& pOtherMaterialID) const;
 
 	U8 mID[MATERIAL_ID_SIZE];
 } ;
 
+static_assert(sizeof(LLMaterialID) == MATERIAL_ID_SIZE, "LLMaterialID must be sizeof(mID)");
+static_assert(std::is_trivially_copyable<LLMaterialID>{}, "LLMaterialID must be a trivially copyable type");
+
 #endif // LL_LLMATERIALID_H
 

indra/llui/lltexteditor.cpp

@@ -1592,6 +1592,11 @@ BOOL LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 	return TRUE;
 }
 
+bool always_underline_links()
+{
+	static const LLUICachedControl<bool> always_underline("SinguAlwaysUnderlineLinks");
+	return always_underline;
+}
 
 BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 {
@@ -1684,7 +1689,7 @@ BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 
 	if (old_hover != mHoverSegment)
 	{
-		if (old_hover)
+		if (old_hover && !always_underline_links())
 			old_hover->underlineOnHover(false);
 		if (mHoverSegment)
 			mHoverSegment->underlineOnHover(true);
@@ -1699,7 +1704,7 @@ BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 
 void LLTextEditor::onMouseLeave(S32 x, S32 y, MASK mask)
 {
-	if (mHoverSegment)
+	if (mHoverSegment && !always_underline_links())
 	{
 		mHoverSegment->underlineOnHover(false);
 		mHoverSegment = nullptr;
@@ -4308,7 +4313,9 @@ void LLTextEditor::appendTextImpl(const std::string &new_text, const LLStyleSP s
 			}
 			// Hack around colors looking bad on some backgrounds by allowing setting link color for this editor
 			if (mLinkColor) link_style->setColor(*mLinkColor);
-			appendAndHighlightText(link, part, link_style, true/*match.underlineOnHoverOnly()*/);
+			const auto always_underline(always_underline_links());
+			if (always_underline) link_style->mUnderline = true;
+			appendAndHighlightText(link, part, link_style, !always_underline/*match.underlineOnHoverOnly()*/);
 		};
 		const auto&& cb = force_replace_links ? boost::bind(&LLTextEditor::replaceUrl, this, _1, _2, _3) : LLUrlLabelCallback::slot_function_type();
 		while (!text.empty() && LLUrlRegistry::instance().findUrl(text, match, cb))

indra/llui/lluistring.cpp

@@ -32,6 +32,7 @@
 
 #include "linden_common.h"
 #include "lluistring.h"
+#include "llfasttimer.h"
 #include "llsd.h"
 #include "lltrans.h"
 

indra/newview/app_settings/settings_ascent.xml

@@ -1131,6 +1131,17 @@ Changing this setting only affects new text.</string>
       <key>Value</key>
       <integer>0</integer>
     </map>
+    <key>SinguAlwaysUnderlineLinks</key>
+    <map>
+      <key>Comment</key>
+      <string>Enable to always underline new links in text editors (and any you hover over after enabling this)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
     <key>SingularitySplashPagePrefix</key>
     <map>
       <key>Comment</key>

indra/newview/llavataractions.cpp

@@ -771,21 +771,21 @@ namespace action_give_inventory
 		std::string items;
 		build_items_string(inventory_selected_uuids, items);
 
-		bool folders_count = false; // Singu Note: Was a count, but break right after == 1, so bool.
+		auto folders_count = 0;
 		//traverse through selected inventory items and count folders among them
 		for (const auto& id : inventory_selected_uuids)
 		{
 			if (gInventory.getCategory(id))
 			{
-				folders_count = true;
+				if (++folders_count == 2)
-				break;
+					break;
 			}
 		}
 
 		// EXP-1599
 		// In case of sharing multiple folders, make the confirmation
 		// dialog contain a warning that only one folder can be shared at a time.
-		std::string notification = folders_count ? "ShareFolderConfirmation" : "ShareItemsConfirmation";
+		std::string notification = folders_count == 2 ? "ShareFolderConfirmation" : "ShareItemsConfirmation";
 		LLSD substitutions;
 		substitutions["RESIDENTS"] = residents;
 		substitutions["ITEMS"] = items;

indra/newview/llviewermedia.cpp

@@ -423,6 +423,7 @@ viewer_media_t LLViewerMedia::newMediaImpl(
 		media_impl->mMediaAutoScale = media_auto_scale;
 		media_impl->mMediaLoop = media_loop;
 	}
+	media_impl->setPageZoomFactor(media_impl->mZoomFactor);
 
 	return media_impl;
 }
@@ -1711,6 +1712,7 @@ LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_
 			media_source->setTarget(target);
 			media_source->setSize(default_width, default_height);
 			media_source->setZoomFactor(zoom_factor);
+			media_source->set_page_zoom_factor(zoom_factor);
 						
 			return media_source;
 		}
@@ -2700,6 +2702,9 @@ bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask)
 			case 'C': mMediaSource->copy(); break;
 			case 'V': mMediaSource->paste(); break;
 			case 'X': mMediaSource->cut(); break;
+			case '=': setPageZoomFactor(mZoomFactor + .1); break;
+			case '-': setPageZoomFactor(mZoomFactor - .1);  break;
+			case '0': setPageZoomFactor(1.0);  break;
 
 			default: result = false; break;
 			}