livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Automated merge with ssh://hg.lindenlab.com/richard/viewer-experience-merge

master
Richard Linden 2011-11-26 21:21:56 -08:00
parent 5a31ac4aee 61570bf84f
commit 6293746b59
19 changed files with 672 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/cmake/00-Common.cmake
View File

@ -46,7 +46,7 @@ if (WINDOWS)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /MDd /MP -D_SCL_SECURE_NO_WARNINGS=1"
CACHE STRING "C++ compiler debug options" FORCE)
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
"${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od /Zi /MD /MP /Ob2 -D_SECURE_STL=0"
"${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Od /Zi /MD /MP /Ob0 -D_SECURE_STL=0"
CACHE STRING "C++ compiler release-with-debug options" FORCE)
set(CMAKE_CXX_FLAGS_RELEASE
"${CMAKE_CXX_FLAGS_RELEASE} ${LL_CXX_FLAGS} /O2 /Zi /MD /MP /Ob2 -D_SECURE_STL=0 -D_HAS_ITERATOR_DEBUGGING=0"

2
indra/llui/llbutton.cpp
View File

@ -115,7 +115,7 @@ LLButton::Params::Params()
LLButton::LLButton(const LLButton::Params& p)
: LLUICtrl(p),
LLBadgeOwner(LLView::getHandle()),
LLBadgeOwner(getHandle()),
mMouseDownFrame(0),
mMouseHeldDownCount(0),
mBorderEnabled( FALSE ),

22
indra/llui/llfloater.cpp
View File

@ -111,7 +111,6 @@ LLFloater::click_callback LLFloater::sButtonCallbacks[BUTTON_COUNT] =
LLMultiFloater* LLFloater::sHostp = NULL;
BOOL LLFloater::sQuitting = FALSE; // Flag to prevent storing visibility controls while quitting
LLFloater::handle_map_t LLFloater::sFloaterMap;
LLFloaterView* gFloaterView = NULL;
@ -268,7 +267,6 @@ LLFloater::LLFloater(const LLSD& key, const LLFloater::Params& p)
mMinimizeSignal(NULL)
// mNotificationContext(NULL)
{
mHandle.bind(this);
// mNotificationContext = new LLFloaterNotificationContext(getHandle());
// Clicks stop here.
@ -323,9 +321,6 @@ void LLFloater::initFloater(const Params& p)
// Floaters are created in the invisible state
setVisible(FALSE);
// add self to handle->floater map
sFloaterMap[mHandle] = this;
if (!getParent())
{
gFloaterView->addChild(this);
@ -532,8 +527,6 @@ LLFloater::~LLFloater()
// correct, non-minimized positions.
setMinimized( FALSE );
sFloaterMap.erase(mHandle);
delete mDragHandle;
for (S32 i = 0; i < 4; i++)
{
@ -1038,7 +1031,9 @@ BOOL LLFloater::canSnapTo(const LLView* other_view)
if (other_view != getParent())
{
const LLFloater* other_floaterp = dynamic_cast<const LLFloater*>(other_view);
if (other_floaterp && other_floaterp->getSnapTarget() == getHandle() && mDependents.find(other_floaterp->getHandle()) != mDependents.end())
if (other_floaterp
&& other_floaterp->getSnapTarget() == getHandle()
&& mDependents.find(other_floaterp->getHandle()) != mDependents.end())
{
// this is a dependent that is already snapped to us, so don't snap back to it
return FALSE;
@ -1677,18 +1672,17 @@ void LLFloater::onClickHelp( LLFloater* self )
LLFloater* LLFloater::getClosableFloaterFromFocus()
{
LLFloater* focused_floater = NULL;
handle_map_iter_t iter;
for(iter = sFloaterMap.begin(); iter != sFloaterMap.end(); ++iter)
LLInstanceTracker<LLFloater>::instance_iter it = beginInstances();
LLInstanceTracker<LLFloater>::instance_iter end_it = endInstances();
for (; it != end_it; ++it)
{
focused_floater = iter->second;
if (focused_floater->hasFocus())
if (it->hasFocus())
{
break;
}
}
if (iter == sFloaterMap.end())
if (it == endInstances())
{
// nothing found, return
return NULL;

11
indra/llui/llfloater.h
View File

@ -83,7 +83,7 @@ namespace LLInitParam
}
class LLFloater : public LLPanel
class LLFloater : public LLPanel, public LLInstanceTracker<LLFloater>
{
friend class LLFloaterView;
friend class LLFloaterReg;
@ -282,7 +282,7 @@ public:
void clearSnapTarget() { mSnappedTo.markDead(); }
LLHandle<LLFloater> getSnapTarget() const { return mSnappedTo; }
LLHandle<LLFloater> getHandle() const { return mHandle; }
LLHandle<LLFloater> getHandle() const { return getDerivedHandle<LLFloater>(); }
const LLSD& getKey() { return mKey; }
virtual bool matchesKey(const LLSD& key) { return mSingleInstance || KeyCompare::equate(key, mKey); }
@ -460,16 +460,9 @@ private:
typedef void(*click_callback)(LLFloater*);
static click_callback sButtonCallbacks[BUTTON_COUNT];
typedef std::map<LLHandle<LLFloater>, LLFloater*> handle_map_t;
typedef std::map<LLHandle<LLFloater>, LLFloater*>::iterator handle_map_iter_t;
static handle_map_t sFloaterMap;
BOOL mHasBeenDraggedWhileMinimized;
S32 mPreviousMinimizedBottom;
S32 mPreviousMinimizedLeft;
// LLFloaterNotificationContext* mNotificationContext;
LLRootHandle<LLFloater> mHandle;
};

67
indra/llui/llhandle.h
View File

@ -28,17 +28,18 @@
#define LLHANDLE_H
#include "llpointer.h"
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
template <typename T>
class LLTombStone : public LLRefCount
{
public:
LLTombStone(T* target = NULL) : mTarget(target) {}
LLTombStone(void* target = NULL) : mTarget(target) {}
void setTarget(T* target) { mTarget = target; }
T* getTarget() const { return mTarget; }
void setTarget(void* target) { mTarget = target; }
void* getTarget() const { return mTarget; }
private:
T* mTarget;
mutable void* mTarget;
};
// LLHandles are used to refer to objects whose lifetime you do not control or influence.
@ -53,13 +54,15 @@ private:
template <typename T>
class LLHandle
{
template <typename U> friend class LLHandle;
template <typename U> friend class LLHandleProvider;
public:
LLHandle() : mTombStone(getDefaultTombStone()) {}
const LLHandle<T>& operator =(const LLHandle<T>& other)
{
mTombStone = other.mTombStone;
return *this;
}
template<typename U>
LLHandle(const LLHandle<U>& other, typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0)
: mTombStone(other.mTombStone)
{}
bool isDead() const
{
@ -73,7 +76,7 @@ public:
T* get() const
{
return mTombStone->getTarget();
return reinterpret_cast<T*>(mTombStone->getTarget());
}
friend bool operator== (const LLHandle<T>& lhs, const LLHandle<T>& rhs)
@ -94,12 +97,13 @@ public:
}
protected:
LLPointer<LLTombStone<T> > mTombStone;
LLPointer<LLTombStone> mTombStone;
private:
static LLPointer<LLTombStone<T> >& getDefaultTombStone()
typedef T* pointer_t;
static LLPointer<LLTombStone>& getDefaultTombStone()
{
static LLPointer<LLTombStone<T> > sDefaultTombStone = new LLTombStone<T>;
static LLPointer<LLTombStone> sDefaultTombStone = new LLTombStone;
return sDefaultTombStone;
}
};
@ -108,23 +112,26 @@ template <typename T>
class LLRootHandle : public LLHandle<T>
{
public:
typedef LLRootHandle<T> self_t;
typedef LLHandle<T> base_t;
LLRootHandle(T* object) { bind(object); }
LLRootHandle() {};
~LLRootHandle() { unbind(); }
// this is redundant, since a LLRootHandle *is* an LLHandle
LLHandle<T> getHandle() { return LLHandle<T>(*this); }
// this is redundant, since an LLRootHandle *is* an LLHandle
//LLHandle<T> getHandle() { return LLHandle<T>(*this); }
void bind(T* object)
{
// unbind existing tombstone
if (LLHandle<T>::mTombStone.notNull())
{
if (LLHandle<T>::mTombStone->getTarget() == object) return;
if (LLHandle<T>::mTombStone->getTarget() == (void*)object) return;
LLHandle<T>::mTombStone->setTarget(NULL);
}
// tombstone reference counted, so no paired delete
LLHandle<T>::mTombStone = new LLTombStone<T>(object);
LLHandle<T>::mTombStone = new LLTombStone((void*)object);
}
void unbind()
@ -142,6 +149,15 @@ private:
template <typename T>
class LLHandleProvider
{
public:
LLHandle<T> getHandle() const
{
// perform lazy binding to avoid small tombstone allocations for handle
// providers whose handles are never referenced
mHandle.bind(static_cast<T*>(const_cast<LLHandleProvider<T>* >(this)));
return mHandle;
}
protected:
typedef LLHandle<T> handle_type_t;
LLHandleProvider()
@ -149,16 +165,17 @@ protected:
// provided here to enforce T deriving from LLHandleProvider<T>
}
LLHandle<T> getHandle()
{
// perform lazy binding to avoid small tombstone allocations for handle
// providers whose handles are never referenced
mHandle.bind(static_cast<T*>(this));
return mHandle;
template <typename U>
typename LLHandle<U> getDerivedHandle(typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0) const
{
LLHandle<U> downcast_handle;
downcast_handle.mTombStone = getHandle().mTombStone;
return downcast_handle;
}
private:
LLRootHandle<T> mHandle;
mutable LLRootHandle<T> mHandle;
};
#endif

2
indra/llui/llmenugl.h
View File

@ -681,7 +681,7 @@ public:
BOOL appendContextSubMenu(LLContextMenu *menu);
LLHandle<LLContextMenu> getHandle() { mHandle.bind(this); return mHandle; }
LLHandle<LLContextMenu> getHandle() { return getDerivedHandle<LLContextMenu>(); }
protected:
BOOL mHoveredAnyItem;

2
indra/llui/llpanel.cpp
View File

@ -122,8 +122,6 @@ LLPanel::LLPanel(const LLPanel::Params& p)
{
addBorder(p.border);
}
mPanelHandle.bind(this);
}
LLPanel::~LLPanel()

3
indra/llui/llpanel.h
View File

@ -153,7 +153,7 @@ public:
void setCtrlsEnabled(BOOL b);
LLHandle<LLPanel> getHandle() const { return mPanelHandle; }
LLHandle<LLPanel> getHandle() const { return getDerivedHandle<LLPanel>(); }
const LLCallbackMap::map_t& getFactoryMap() const { return mFactoryMap; }
@ -278,7 +278,6 @@ private:
LLViewBorder* mBorder;
LLButton* mDefaultBtn;
LLUIString mLabel;
LLRootHandle<LLPanel> mPanelHandle;
typedef std::map<std::string, std::string> ui_string_map_t;
ui_string_map_t mUIStrings;

11
indra/llui/lluictrl.cpp
View File

@ -118,7 +118,6 @@ LLUICtrl::LLUICtrl(const LLUICtrl::Params& p, const LLViewModelPtr& viewmodel)
mDoubleClickSignal(NULL),
mTransparencyType(TT_DEFAULT)
{
mUICtrlHandle.bind(this);
}
void LLUICtrl::initFromParams(const Params& p)
@ -460,7 +459,7 @@ void LLUICtrl::setControlVariable(LLControlVariable* control)
if (control)
{
mControlVariable = control;
mControlConnection = mControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("value")));
mControlConnection = mControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getHandle(), std::string("value")));
setValue(mControlVariable->getValue());
}
}
@ -491,7 +490,7 @@ void LLUICtrl::setEnabledControlVariable(LLControlVariable* control)
if (control)
{
mEnabledControlVariable = control;
mEnabledControlConnection = mEnabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("enabled")));
mEnabledControlConnection = mEnabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getHandle(), std::string("enabled")));
setEnabled(mEnabledControlVariable->getValue().asBoolean());
}
}
@ -506,7 +505,7 @@ void LLUICtrl::setDisabledControlVariable(LLControlVariable* control)
if (control)
{
mDisabledControlVariable = control;
mDisabledControlConnection = mDisabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("disabled")));
mDisabledControlConnection = mDisabledControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getHandle(), std::string("disabled")));
setEnabled(!(mDisabledControlVariable->getValue().asBoolean()));
}
}
@ -521,7 +520,7 @@ void LLUICtrl::setMakeVisibleControlVariable(LLControlVariable* control)
if (control)
{
mMakeVisibleControlVariable = control;
mMakeVisibleControlConnection = mMakeVisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("visible")));
mMakeVisibleControlConnection = mMakeVisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getHandle(), std::string("visible")));
setVisible(mMakeVisibleControlVariable->getValue().asBoolean());
}
}
@ -536,7 +535,7 @@ void LLUICtrl::setMakeInvisibleControlVariable(LLControlVariable* control)
if (control)
{
mMakeInvisibleControlVariable = control;
mMakeInvisibleControlConnection = mMakeInvisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getUICtrlHandle(), std::string("invisible")));
mMakeInvisibleControlConnection = mMakeInvisibleControlVariable->getSignal()->connect(boost::bind(&controlListener, _2, getHandle(), std::string("invisible")));
setVisible(!(mMakeInvisibleControlVariable->getValue().asBoolean()));
}
}

3
indra/llui/lluictrl.h
View File

@ -223,7 +223,7 @@ public:
BOOL focusLastItem(BOOL prefer_text_fields = FALSE);
// Non Virtuals
LLHandle<LLUICtrl> getUICtrlHandle() const { return mUICtrlHandle; }
LLHandle<LLUICtrl> getHandle() const { return getDerivedHandle<LLUICtrl>(); }
BOOL getIsChrome() const;
void setTabStop( BOOL b );
@ -313,7 +313,6 @@ private:
BOOL mRequestsFront;
BOOL mTabStop;
BOOL mTentative;
LLRootHandle<LLUICtrl> mUICtrlHandle;
ETypeTransparency mTransparencyType;

9
indra/llui/llview.h
View File

@ -97,7 +97,11 @@ private:
static std::vector<LLViewDrawContext*> sDrawContextStack;
};
class LLView : public LLMouseHandler, public LLMortician, public LLFocusableElement
class LLView
: public LLMouseHandler, // handles mouse events
public LLFocusableElement, // handles keyboard events
public LLMortician, // lazy deletion
public LLHandleProvider<LLView> // passes out weak references to self
{
public:
struct Follows : public LLInitParam::ChoiceBlock<Follows>
@ -306,8 +310,6 @@ public:
void popVisible() { setVisible(mLastVisible); }
BOOL getLastVisible() const { return mLastVisible; }
LLHandle<LLView> getHandle() { mHandle.bind(this); return mHandle; }
U32 getFollows() const { return mReshapeFlags; }
BOOL followsLeft() const { return mReshapeFlags & FOLLOWS_LEFT; }
BOOL followsRight() const { return mReshapeFlags & FOLLOWS_RIGHT; }
@ -606,7 +608,6 @@ private:
BOOL mIsFocusRoot;
BOOL mUseBoundingRect; // hit test against bounding rectangle that includes all child elements
LLRootHandle<LLView> mHandle;
BOOL mLastVisible;
S32 mNextInsertionOrdinal;

1
indra/llxuixml/llinitparam.cpp
View File

@ -478,6 +478,7 @@ namespace LLInitParam
if (merge_func)
{
Param* paramp = getParamFromHandle((*it)->mParamHandle);
llassert(paramp->mEnclosingBlockOffset == (*it)->mParamHandle);
some_param_changed |= merge_func(*paramp, *other_paramp, overwrite);
}
}

496
indra/llxuixml/llinitparam.h
View File

@ -51,7 +51,7 @@ namespace LLInitParam
return a == b;
}
};
// boost function types are not comparable
template<typename T>
struct ParamCompare<T, true>
@ -74,6 +74,7 @@ namespace LLInitParam
static bool equals(const Flag& a, const Flag& b) { return false; }
};
// helper functions and classes
typedef ptrdiff_t param_handle_t;
@ -82,8 +83,11 @@ namespace LLInitParam
template <typename T>
class TypeValues
{
private:
struct Inaccessable{};
public:
typedef std::map<std::string, T> value_name_map_t;
typedef Inaccessable name_t;
void setValueName(const std::string& key) {}
std::string getValueName() const { return ""; }
@ -113,6 +117,7 @@ namespace LLInitParam
{
public:
typedef typename std::map<std::string, T> value_name_map_t;
typedef std::string name_t;
//TODO: cache key by index to save on param block size
void setValueName(const std::string& value_name)
@ -293,36 +298,7 @@ namespace LLInitParam
parser_inspect_func_map_t* mParserInspectFuncs;
};
class BaseBlock;
class Param
{
public:
// public to allow choice blocks to clear provided flag on stale choices
void setProvided(bool is_provided) { mIsProvided = is_provided; }
protected:
bool anyProvided() const { return mIsProvided; }
Param(BaseBlock* enclosing_block);
// store pointer to enclosing block as offset to reduce space and allow for quick copying
BaseBlock& enclosingBlock() const
{
const U8* my_addr = reinterpret_cast<const U8*>(this);
// get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class
return *const_cast<BaseBlock*>
(reinterpret_cast<const BaseBlock*>
(my_addr - (ptrdiff_t)(S32)mEnclosingBlockOffset));
}
private:
friend class BaseBlock;
U32 mEnclosingBlockOffset:31;
U32 mIsProvided:1;
};
class Param;
// various callbacks and constraints associated with an individual param
struct ParamDescriptor
@ -390,12 +366,91 @@ namespace LLInitParam
all_params_list_t mAllParams; // all parameters, owns descriptors
size_t mMaxParamOffset;
EInitializationState mInitializationState; // whether or not static block data has been initialized
BaseBlock* mCurrentBlockPtr; // pointer to block currently being constructed
class BaseBlock* mCurrentBlockPtr; // pointer to block currently being constructed
};
class BaseBlock
{
public:
//TODO: implement in terms of owned_ptr
template<typename T>
class Lazy
{
public:
Lazy()
: mPtr(NULL)
{}
~Lazy()
{
delete mPtr;
}
Lazy(const Lazy& other)
{
if (other.mPtr)
{
mPtr = new T(*other.mPtr);
}
else
{
mPtr = NULL;
}
}
Lazy<T>& operator = (const Lazy<T>& other)
{
if (other.mPtr)
{
mPtr = new T(*other.mPtr);
}
else
{
mPtr = NULL;
}
return *this;
}
bool empty() const
{
return mPtr == NULL;
}
void set(const T& other)
{
delete mPtr;
mPtr = new T(other);
}
const T& get() const
{
return ensureInstance();
}
T& get()
{
return ensureInstance();
}
private:
// lazily allocate an instance of T
T* ensureInstance() const
{
if (mPtr == NULL)
{
mPtr = new T();
}
return mPtr;
}
private:
// if you get a compilation error with this, that means you are using a forward declared struct for T
// unfortunately, the type traits we rely on don't work with forward declared typed
//static const int dummy = sizeof(T);
mutable T* mPtr;
};
// "Multiple" constraint types, put here in root class to avoid ambiguity during use
struct AnyAmount
{
@ -511,6 +566,51 @@ namespace LLInitParam
const std::string& getParamName(const BlockDescriptor& block_data, const Param* paramp) const;
};
template<typename T>
struct ParamCompare<BaseBlock::Lazy<T>, false >
{
static bool equals(const BaseBlock::Lazy<T>& a, const BaseBlock::Lazy<T>& b) { return !a.empty() || !b.empty(); }
};
class Param
{
public:
void setProvided(bool is_provided = true)
{
mIsProvided = is_provided;
enclosingBlock().paramChanged(*this, is_provided);
}
Param& operator =(const Param& other)
{
mIsProvided = other.mIsProvided;
// don't change mEnclosingblockoffset
return *this;
}
protected:
bool anyProvided() const { return mIsProvided; }
Param(BaseBlock* enclosing_block);
// store pointer to enclosing block as offset to reduce space and allow for quick copying
BaseBlock& enclosingBlock() const
{
const U8* my_addr = reinterpret_cast<const U8*>(this);
// get address of enclosing BLOCK class using stored offset to enclosing BaseBlock class
return *const_cast<BaseBlock*>
(reinterpret_cast<const BaseBlock*>
(my_addr - (ptrdiff_t)(S32)mEnclosingBlockOffset));
}
private:
friend class BaseBlock;
U32 mEnclosingBlockOffset:31;
U32 mIsProvided:1;
};
// these templates allow us to distinguish between template parameters
// that derive from BaseBlock and those that don't
template<typename T, typename Void = void>
@ -530,6 +630,7 @@ namespace LLInitParam
{
public:
typedef const T& value_assignment_t;
typedef ParamValue<T, NAME_VALUE_LOOKUP, VALUE_IS_BLOCK> self_t;
ParamValue(): mValue() {}
ParamValue(value_assignment_t other) : mValue(other) {}
@ -559,8 +660,22 @@ namespace LLInitParam
return mValue;
}
void operator ()(const typename NAME_VALUE_LOOKUP::name_t& name)
{
*this = name;
}
private:
self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name)
{
if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue))
{
setValueName(name);
}
return *this;
}
protected:
T mValue;
};
@ -571,17 +686,16 @@ namespace LLInitParam
{
public:
typedef const T& value_assignment_t;
typedef ParamValue<T, NAME_VALUE_LOOKUP, true> self_t;
ParamValue()
: T(),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{}
ParamValue(value_assignment_t other)
: T(other),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{}
@ -611,13 +725,74 @@ namespace LLInitParam
return *this;
}
S32 mKeyVersion;
void operator ()(const typename NAME_VALUE_LOOKUP::name_t& name)
{
*this = name;
}
self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name)
{
if (NAME_VALUE_LOOKUP::getValueFromName(name, mValue))
{
setValueName(name);
}
return *this;
}
protected:
mutable S32 mValidatedVersion;
mutable bool mValidated; // lazy validation flag
};
template<typename NAME_VALUE_LOOKUP>
class ParamValue<std::string, NAME_VALUE_LOOKUP, false>
: public NAME_VALUE_LOOKUP
{
public:
typedef const std::string& value_assignment_t;
typedef ParamValue<std::string, NAME_VALUE_LOOKUP, false> self_t;
ParamValue(): mValue() {}
ParamValue(value_assignment_t other) : mValue(other) {}
void setValue(value_assignment_t val)
{
if (NAME_VALUE_LOOKUP::getValueFromName(val, mValue))
{
setValueName(val);
}
else
{
mValue = val;
}
}
value_assignment_t getValue() const
{
return mValue;
}
std::string& getValue()
{
return mValue;
}
operator value_assignment_t() const
{
return mValue;
}
value_assignment_t operator()() const
{
return mValue;
}
protected:
std::string mValue;
};
template<typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> >
struct ParamIterator
{
@ -641,6 +816,8 @@ namespace LLInitParam
typedef NAME_VALUE_LOOKUP name_value_lookup_t;
typedef ParamValue<T, NAME_VALUE_LOOKUP> param_value_t;
using param_value_t::operator();
TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count)
: Param(block_descriptor.mCurrentBlockPtr)
{
@ -671,8 +848,7 @@ namespace LLInitParam
if (parser.readValue(typed_param.getValue()))
{
typed_param.clearValueName();
typed_param.setProvided(true);
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setProvided();
return true;
}
@ -687,8 +863,7 @@ namespace LLInitParam
if (name_value_lookup_t::getValueFromName(name, typed_param.getValue()))
{
typed_param.setValueName(name);
typed_param.setProvided(true);
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setProvided();
return true;
}
@ -746,14 +921,25 @@ namespace LLInitParam
void set(value_assignment_t val, bool flag_as_provided = true)
{
setValue(val);
param_value_t::clearValueName();
setValue(val);
setProvided(flag_as_provided);
Param::enclosingBlock().paramChanged(*this, flag_as_provided);
}
self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name)
{
return static_cast<self_t&>(param_value_t::operator =(name));
}
protected:
self_t& operator =(const self_t& other)
{
param_value_t::operator =(other);
Param::operator =(other);
return *this;
}
static bool mergeWith(Param& dst, const Param& src, bool overwrite)
{
const self_t& src_typed_param = static_cast<const self_t&>(src);
@ -783,6 +969,8 @@ namespace LLInitParam
typedef NAME_VALUE_LOOKUP name_value_lookup_t;
typedef ParamValue<T, NAME_VALUE_LOOKUP> param_value_t;
using param_value_t::operator();
TypedParam(BlockDescriptor& block_descriptor, const char* name, value_assignment_t value, ParamDescriptor::validation_func_t validate_func, S32 min_count, S32 max_count)
: Param(block_descriptor.mCurrentBlockPtr),
param_value_t(value)
@ -808,8 +996,7 @@ namespace LLInitParam
if(typed_param.deserializeBlock(parser, name_stack_range, new_name))
{
typed_param.clearValueName();
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setProvided(true);
typed_param.setProvided();
return true;
}
@ -822,10 +1009,8 @@ namespace LLInitParam
// try to parse a per type named value
if (name_value_lookup_t::getValueFromName(name, typed_param.getValue()))
{
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setValueName(name);
typed_param.setProvided(true);
typed_param.mKeyVersion = typed_param.getLastChangeVersion();
typed_param.setProvided();
return true;
}
@ -845,7 +1030,7 @@ namespace LLInitParam
}
std::string key = typed_param.getValueName();
if (!key.empty() && typed_param.mKeyVersion == typed_param.getLastChangeVersion())
if (!key.empty())
{
if (!parser.writeValue(key, name_stack))
{
@ -888,24 +1073,39 @@ namespace LLInitParam
// next call to isProvided() will update provision status based on validity
param_value_t::mValidatedVersion = -1;
setProvided(flag_as_provided);
Param::enclosingBlock().paramChanged(*this, flag_as_provided);
}
self_t& operator =(const typename NAME_VALUE_LOOKUP::name_t& name)
{
return static_cast<self_t&>(param_value_t::operator =(name));
}
// propagate changed status up to enclosing block
/*virtual*/ void paramChanged(const Param& changed_param, bool user_provided)
{
param_value_t::paramChanged(changed_param, user_provided);
Param::enclosingBlock().paramChanged(*this, user_provided);
if (user_provided)
{
// a child param has been explicitly changed
// so *some* aspect of this block is now provided
setProvided(true);
setProvided();
param_value_t::clearValueName();
}
else
{
Param::enclosingBlock().paramChanged(*this, user_provided);
}
}
protected:
self_t& operator =(const self_t& other)
{
param_value_t::operator =(other);
Param::operator =(other);
return *this;
}
static bool mergeWith(Param& dst, const Param& src, bool overwrite)
{
const self_t& src_typed_param = static_cast<const self_t&>(src);
@ -917,7 +1117,6 @@ namespace LLInitParam
{
dst_typed_param.clearValueName();
dst_typed_param.setProvided(true);
dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true);
return true;
}
}
@ -1004,7 +1203,7 @@ namespace LLInitParam
it != end_it;
++it)
{
std::string key = it->getValue();
std::string key = it->getValueName();
name_stack.back().second = true;
if(key.empty())
@ -1013,7 +1212,7 @@ namespace LLInitParam
bool value_written = parser.writeValue(*it, name_stack);
if (!value_written)
{
std::string calculated_key = it->calcValueName(key);
std::string calculated_key = it->calcValueName(it->getValue());
if (!parser.writeValue(calculated_key, name_stack))
{
break;
@ -1043,22 +1242,33 @@ namespace LLInitParam
{
mValues = val;
setProvided(flag_as_provided);
Param::enclosingBlock().paramChanged(*this, flag_as_provided);
}
value_t& add()
param_value_t& add()
{
mValues.push_back(param_value_t(value_t()));
setProvided(true);
Param::enclosingBlock().paramChanged(*this, true);
Param::setProvided();
return mValues.back();
}
void add(const value_t& item)
{
mValues.push_back(param_value_t(item));
setProvided(true);
Param::enclosingBlock().paramChanged(*this, true);
param_value_t param_value;
param_value.setValue(item);
mValues.push_back(param_value);
setProvided();
}
void add(typename const name_value_lookup_t::name_t& name)
{
value_t value;
// try to parse a per type named value
if (name_value_lookup_t::getValueFromName(name, value))
{
add(value);
mValues.back().setValueName(name);
}
}
// implicit conversion
@ -1099,8 +1309,7 @@ namespace LLInitParam
if (src_typed_param.begin() != src_typed_param.end())
{
dst_typed_param.setProvided(true);
dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true);
dst_typed_param.setProvided();
}
return true;
}
@ -1116,7 +1325,7 @@ namespace LLInitParam
public:
typedef TypedParam<VALUE_TYPE, NAME_VALUE_LOOKUP, true, true> self_t;
typedef ParamValue<VALUE_TYPE, NAME_VALUE_LOOKUP> param_value_t;
typedef typename std::vector<param_value_t> container_t;
typedef typename std::vector<param_value_t> container_t;
typedef const container_t& value_assignment_t;
typedef VALUE_TYPE value_t;
typedef NAME_VALUE_LOOKUP name_value_lookup_t;
@ -1158,8 +1367,7 @@ namespace LLInitParam
// attempt to parse block...
if(value.deserializeBlock(parser, name_stack_range, new_name))
{
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setProvided(true);
typed_param.setProvided();
return true;
}
else if(name_value_lookup_t::valueNamesExist())
@ -1172,9 +1380,7 @@ namespace LLInitParam
if (name_value_lookup_t::getValueFromName(name, value.getValue()))
{
typed_param.mValues.back().setValueName(name);
typed_param.mValues.back().mKeyVersion = value.getLastChangeVersion();
typed_param.enclosingBlock().paramChanged(param, true);
typed_param.setProvided(true);
typed_param.setProvided();
return true;
}
@ -1201,7 +1407,7 @@ namespace LLInitParam
name_stack.back().second = true;
std::string key = it->getValueName();
if (!key.empty() && it->mKeyVersion == it->getLastChangeVersion())
if (!key.empty())
{
parser.writeValue(key, name_stack);
}
@ -1224,22 +1430,31 @@ namespace LLInitParam
{
mValues = val;
setProvided(flag_as_provided);
Param::enclosingBlock().paramChanged(*this, flag_as_provided);
}
value_t& add()
param_value_t& add()
{
mValues.push_back(value_t());
setProvided(true);
Param::enclosingBlock().paramChanged(*this, true);
setProvided();
return mValues.back();
}
void add(const value_t& item)
{
mValues.push_back(item);
setProvided(true);
Param::enclosingBlock().paramChanged(*this, true);
setProvided();
}
void add(typename const name_value_lookup_t::name_t& name)
{
value_t value;
// try to parse a per type named value
if (name_value_lookup_t::getValueFromName(name, value))
{
add(value);
mValues.back().setValueName(name);
}
}
// implicit conversion
@ -1288,8 +1503,7 @@ namespace LLInitParam
if (src_typed_param.begin() != src_typed_param.end())
{
dst_typed_param.setProvided(true);
dst_typed_param.enclosingBlock().paramChanged(dst_typed_param, true);
dst_typed_param.setProvided();
}
return true;
@ -1298,24 +1512,25 @@ namespace LLInitParam
container_t mValues;
};
template <typename DERIVED_BLOCK>
class ChoiceBlock : public BaseBlock
template <typename DERIVED_BLOCK, typename BASE_BLOCK = BaseBlock>
class ChoiceBlock : public BASE_BLOCK
{
typedef ChoiceBlock<DERIVED_BLOCK> self_t;
typedef ChoiceBlock<DERIVED_BLOCK> enclosing_block_t;
typedef ChoiceBlock<DERIVED_BLOCK, BASE_BLOCK> self_t;
typedef ChoiceBlock<DERIVED_BLOCK, BASE_BLOCK> enclosing_block_t;
typedef BASE_BLOCK base_block_t;
LOG_CLASS(self_t);
public:
// take all provided params from other and apply to self
bool overwriteFrom(const self_t& other)
{
return mergeBlock(selfBlockDescriptor(), other, true);
return static_cast<DERIVED_BLOCK*>(this)->mergeBlock(selfBlockDescriptor(), other, true);
}
// take all provided params that are not already provided, and apply to self
bool fillFrom(const self_t& other)
{
return mergeBlock(selfBlockDescriptor(), other, false);
return static_cast<DERIVED_BLOCK*>(this)->mergeBlock(selfBlockDescriptor(), other, false);
}
bool mergeBlockParam(bool source_provided, bool dest_provided, BlockDescriptor& block_data, const self_t& source, bool overwrite)
@ -1333,25 +1548,25 @@ namespace LLInitParam
bool mergeBlock(BlockDescriptor& block_data, const self_t& other, bool overwrite)
{
mCurChoice = other.mCurChoice;
return BaseBlock::mergeBlock(selfBlockDescriptor(), other, overwrite);
return base_block_t::mergeBlock(selfBlockDescriptor(), other, overwrite);
}
// clear out old choice when param has changed
/*virtual*/ void paramChanged(const Param& changed_param, bool user_provided)
{
param_handle_t changed_param_handle = BaseBlock::getHandleFromParam(&changed_param);
param_handle_t changed_param_handle = base_block_t::getHandleFromParam(&changed_param);
// if we have a new choice...
if (changed_param_handle != mCurChoice)
{
// clear provided flag on previous choice
Param* previous_choice = BaseBlock::getParamFromHandle(mCurChoice);
Param* previous_choice = base_block_t::getParamFromHandle(mCurChoice);
if (previous_choice)
{
previous_choice->setProvided(false);
}
mCurChoice = changed_param_handle;
}
BaseBlock::paramChanged(changed_param, user_provided);
base_block_t::paramChanged(changed_param, user_provided);
}
virtual const BlockDescriptor& mostDerivedBlockDescriptor() const { return selfBlockDescriptor(); }
@ -1361,7 +1576,7 @@ namespace LLInitParam
ChoiceBlock()
: mCurChoice(0)
{
BaseBlock::init(selfBlockDescriptor(), BaseBlock::selfBlockDescriptor(), sizeof(DERIVED_BLOCK));
BaseBlock::init(selfBlockDescriptor(), base_block_t::selfBlockDescriptor(), sizeof(DERIVED_BLOCK));
}
// Alternatives are mutually exclusive wrt other Alternatives in the same block.
@ -1377,6 +1592,8 @@ namespace LLInitParam
typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> super_t;
typedef typename super_t::value_assignment_t value_assignment_t;
using super_t::operator =;
explicit Alternative(const char* name = "", value_assignment_t val = defaultValue<T>())
: super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1),
mOriginalValue(val)
@ -1402,7 +1619,7 @@ namespace LLInitParam
super_t::set(val);
}
void operator=(value_assignment_t val)
void operator =(value_assignment_t val)
{
super_t::set(val);
}
@ -1447,7 +1664,7 @@ namespace LLInitParam
const Param* getCurrentChoice() const
{
return BaseBlock::getParamFromHandle(mCurChoice);
return base_block_t::getParamFromHandle(mCurChoice);
}
};
@ -1493,13 +1710,16 @@ namespace LLInitParam
typedef TypedParam<T, NAME_VALUE_LOOKUP, false, IsBlock<ParamValue<T, NAME_VALUE_LOOKUP> >::value> super_t;
typedef typename super_t::value_assignment_t value_assignment_t;
using super_t::operator();
using super_t::operator =;
explicit Optional(const char* name = "", value_assignment_t val = defaultValue<T>())
: super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, NULL, 0, 1)
{
//#pragma message("Parsing LLInitParam::Block::Optional")
}
Optional& operator=(value_assignment_t val)
Optional& operator =(value_assignment_t val)
{
set(val);
return *this;
@ -1510,7 +1730,6 @@ namespace LLInitParam
super_t::set(val);
return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock());
}
using super_t::operator();
};
template <typename T, typename NAME_VALUE_LOOKUP = TypeValues<T> >
@ -1521,12 +1740,15 @@ namespace LLInitParam
typedef Mandatory<T, NAME_VALUE_LOOKUP> self_t;
typedef typename super_t::value_assignment_t value_assignment_t;
using super_t::operator();
using super_t::operator =;
// mandatory parameters require a name to be parseable
explicit Mandatory(const char* name = "", value_assignment_t val = defaultValue<T>())
: super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, val, &validate, 1, 1)
{}
Mandatory& operator=(value_assignment_t val)
Mandatory& operator =(value_assignment_t val)
{
set(val);
return *this;
@ -1537,7 +1759,6 @@ namespace LLInitParam
super_t::set(val);
return static_cast<DERIVED_BLOCK&>(Param::enclosingBlock());
}
using super_t::operator();
static bool validate(const Param* p)
{
@ -1562,7 +1783,7 @@ namespace LLInitParam
: super_t(DERIVED_BLOCK::selfBlockDescriptor(), name, container_t(), &validate, RANGE::minCount, RANGE::maxCount)
{}
Multiple& operator=(value_assignment_t val)
Multiple& operator =(value_assignment_t val)
{
set(val);
return *this;
@ -1693,14 +1914,12 @@ namespace LLInitParam
ParamValue()
: block_t(),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{}
ParamValue(value_assignment_t other)
: block_t(other),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{
@ -1731,11 +1950,82 @@ namespace LLInitParam
return *this;
}
S32 mKeyVersion;
protected:
mutable S32 mValidatedVersion;
mutable bool mValidated; // lazy validation flag
};
template<typename T>
class ParamValue <BaseBlock::Lazy<T>,
TypeValues<T>,
false>
{
public:
typedef ParamValue <BaseBlock::Lazy<T>, TypeValues<T>, false> self_t;
typedef const T& value_assignment_t;
ParamValue()
: mValue(),
mValidatedVersion(-1),
mValidated(false)
{}
ParamValue(value_assignment_t other)
: mValue(other),
mValidatedVersion(-1),
mValidated(false)
{}
void setValue(value_assignment_t val)
{
mValue.set(val);
}
value_assignment_t getValue() const
{
return mValue.get();
}
T& getValue()
{
return mValue.get();
}
operator value_assignment_t() const
{
return mValue.get();
}
value_assignment_t operator()() const
{
return mValue.get();
}
bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name)
{
return mValue.get().deserializeBlock(p, name_stack_range, new_name);
}
void serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block = NULL) const
{
if (mValue.empty()) return;
mValue.get().serializeBlock(p, name_stack, diff_block);
}
bool inspectBlock(Parser& p, Parser::name_stack_t name_stack = Parser::name_stack_t(), S32 min_count = 0, S32 max_count = S32_MAX) const
{
if (mValue.empty()) return false;
return mValue.get().inspectBlock(p, name_stack, min_count, max_count);
}
protected:
mutable S32 mValidatedVersion;
mutable bool mValidated; // lazy validation flag
private:
BaseBlock::Lazy<T> mValue;
};
template <>
@ -1750,14 +2040,12 @@ namespace LLInitParam
typedef const LLSD& value_assignment_t;
ParamValue()
: mKeyVersion(0),
mValidatedVersion(-1),
: mValidatedVersion(-1),
mValidated(false)
{}
ParamValue(value_assignment_t other)
: mValue(other),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{}
@ -1770,7 +2058,6 @@ namespace LLInitParam
operator value_assignment_t() const { return mValue; }
value_assignment_t operator()() const { return mValue; }
S32 mKeyVersion;
// block param interface
bool deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool new_name);
@ -1812,7 +2099,6 @@ namespace LLInitParam
CustomParamValue(const T& value = T())
: mValue(value),
mValueAge(VALUE_AUTHORITATIVE),
mKeyVersion(0),
mValidatedVersion(-1),
mValidated(false)
{}
@ -1966,8 +2252,6 @@ namespace LLInitParam
return getValue();
}
S32 mKeyVersion;
protected:
// use this from within updateValueFromBlock() to set the value without making it authoritative

280
indra/llxuixml/llxuiparser.cpp
View File

@ -59,28 +59,24 @@ const char* NO_VALUE_MARKER = "no_value";
const S32 LINE_NUMBER_HERE = 0;
struct MaxOccur : public LLInitParam::ChoiceBlock<MaxOccur>
struct MaxOccursValues : public LLInitParam::TypeValuesHelper<U32, MaxOccursValues>
{
Alternative<int> count;
Alternative<std::string> unbounded;
MaxOccur()
: unbounded("", "unbounded")
{}
static void declareValues()
{
declare("unbounded", U32_MAX);
}
};
struct Occurs : public LLInitParam::Block<Occurs>
{
Optional<S32> minOccurs;
Optional<MaxOccur> maxOccurs;
Optional<U32> minOccurs;
Optional<U32, MaxOccursValues> maxOccurs;
Occurs()
: minOccurs("minOccurs"),
maxOccurs("maxOccurs")
{
minOccurs = 0;
maxOccurs.unbounded.choose();
}
: minOccurs("minOccurs", 0),
maxOccurs("maxOccurs", U32_MAX)
{}
};
@ -103,18 +99,15 @@ namespace LLInitParam
};
}
struct Name : public LLInitParam::Block<Name>
{
Mandatory<std::string> name;
Name()
: name("name")
{}
};
struct Element;
struct Group;
struct Choice;
struct Sequence;
struct Any;
struct Attribute : public LLInitParam::Block<Attribute>
{
Mandatory<Name> name;
Mandatory<std::string> name;
Mandatory<std::string> type;
Mandatory<EUse> use;
@ -122,41 +115,170 @@ struct Attribute : public LLInitParam::Block<Attribute>
: name("name"),
type("type"),
use("use")
{
}
};
struct ComplexType : public LLInitParam::Block<ComplexType>
{
Multiple<Attribute> attribute;
//Multiple<struct Element> elements;
Optional<bool> mixed;
ComplexType()
: attribute("xs:attribute"),
//elements("xs:element"),
mixed("mixed")
{
mixed = true;
}
};
struct Element : public LLInitParam::Block<Element, Occurs>
{
Mandatory<ComplexType> complexType;
Mandatory<Name> name;
Element()
: complexType("xs:complexType")
{}
};
struct Elements : public LLInitParam::Block<Elements, Occurs>
struct Any : public LLInitParam::Block<Any, Occurs>
{
Multiple<Element> elements;
Optional<std::string> _namespace;
Elements()
: elements("xs:element")
Any()
: _namespace("namespace")
{}
};
struct All : public LLInitParam::Block<All, Occurs>
{
Multiple<Lazy<Element>> elements;
All()
: elements("element")
{
maxOccurs = 1;
}
};
struct Choice : public LLInitParam::ChoiceBlock<Choice, Occurs>
{
Alternative<Lazy<Element>> element;
Alternative<Lazy<Group>> group;
Alternative<Lazy<Choice>> choice;
Alternative<Lazy<Sequence>> sequence;
Alternative<Lazy<Any>> any;
Choice()
: element("element"),
group("group"),
choice("choice"),
sequence("sequence"),
any("any")
{}
};
struct Sequence : public LLInitParam::ChoiceBlock<Sequence, Occurs>
{
Alternative<Lazy<Element>> element;
Alternative<Lazy<Group>> group;
Alternative<Lazy<Choice>> choice;
Alternative<Lazy<Sequence>> sequence;
Alternative<Lazy<Any>> any;
};
struct GroupContents : public LLInitParam::ChoiceBlock<GroupContents, Occurs>
{
Alternative<All> all;
Alternative<Choice> choice;
Alternative<Sequence> sequence;
GroupContents()
: all("all"),
choice("choice"),
sequence("sequence")
{}
};
struct Group : public LLInitParam::Block<Group, GroupContents>
{
Optional<std::string> name,
ref;
Group()
: name("name"),
ref("ref")
{}
};
struct Restriction : public LLInitParam::Block<Restriction>
{
};
struct Extension : public LLInitParam::Block<Extension>
{
};
struct SimpleContent : public LLInitParam::ChoiceBlock<SimpleContent>
{
Alternative<Restriction> restriction;
Alternative<Extension> extension;
SimpleContent()
: restriction("restriction"),
extension("extension")
{}
};
struct SimpleType : public LLInitParam::Block<SimpleType>
{
// TODO
};
struct ComplexContent : public LLInitParam::Block<ComplexContent, SimpleContent>
{
Optional<bool> mixed;
ComplexContent()
: mixed("mixed", true)
{}
};
struct ComplexTypeContents : public LLInitParam::ChoiceBlock<ComplexTypeContents>
{
Alternative<SimpleContent> simple_content;
Alternative<ComplexContent> complex_content;
Alternative<Group> group;
Alternative<All> all;
Alternative<Choice> choice;
Alternative<Sequence> sequence;
ComplexTypeContents()
: simple_content("simpleContent"),
complex_content("complexContent"),
group("group"),
all("all"),
choice("choice"),
sequence("sequence")
{}
};
struct ComplexType : public LLInitParam::Block<ComplexType, ComplexTypeContents>
{
Optional<std::string> name;
Optional<bool> mixed;
Multiple<Attribute> attribute;
Multiple<Lazy<Element>> elements;
ComplexType()
: name("name"),
attribute("xs:attribute"),
elements("xs:element"),
mixed("mixed")
{
}
};
struct ElementContents : public LLInitParam::ChoiceBlock<ElementContents, Occurs>
{
Alternative<SimpleType> simpleType;
Alternative<ComplexType> complexType;
ElementContents()
: simpleType("simpleType"),
complexType("complexType")
{}
};
struct Element : public LLInitParam::Block<Element, ElementContents>
{
Optional<std::string> name,
ref,
type;
Element()
: name("xs:name"),
ref("xs:ref"),
type("xs:type")
{}
};
@ -164,28 +286,32 @@ struct Schema : public LLInitParam::Block<Schema>
{
private:
Mandatory<std::string> targetNamespace,
xmlns;
xmlns,
xs;
public:
Optional<std::string> attributeFormDefault,
elementFormDefault,
xs;
elementFormDefault;
Optional<Elements> elements;
Mandatory<Element> root_element;
void setNameSpace(const std::string& ns) {targetNamespace = ns; xmlns = ns;}
Schema()
Schema(const std::string& ns = LLStringUtil::null)
: attributeFormDefault("attributeFormDefault"),
elementFormDefault("elementFormDefault"),
xs("xmlns:xs"),
targetNamespace("targetNamespace"),
xmlns("xmlns"),
elements("xs:choice")
root_element("xs:element")
{
attributeFormDefault = "unqualified";
elementFormDefault = "qualified";
xs = "http://www.w3.org/2001/XMLSchema";
if (!ns.empty())
{
setNameSpace(ns);
};
}
};
@ -214,22 +340,30 @@ LLXSDWriter::LLXSDWriter()
void LLXSDWriter::writeXSD(const std::string& type_name, LLXMLNodePtr node, const LLInitParam::BaseBlock& block, const std::string& xml_namespace)
{
Schema schema(xml_namespace);
schema.root_element.name = type_name;
Choice& choice = schema.root_element.complexType.choice;
choice.minOccurs = 0;
choice.maxOccurs = "unbounded";
mSchemaNode = node;
node->setName("xs:schema");
node->createChild("attributeFormDefault", true)->setStringValue("unqualified");
node->createChild("elementFormDefault", true)->setStringValue("qualified");
node->createChild("targetNamespace", true)->setStringValue(xml_namespace);
node->createChild("xmlns:xs", true)->setStringValue("http://www.w3.org/2001/XMLSchema");
node->createChild("xmlns", true)->setStringValue(xml_namespace);
//node->setName("xs:schema");
//node->createChild("attributeFormDefault", true)->setStringValue("unqualified");
//node->createChild("elementFormDefault", true)->setStringValue("qualified");
//node->createChild("targetNamespace", true)->setStringValue(xml_namespace);
//node->createChild("xmlns:xs", true)->setStringValue("http://www.w3.org/2001/XMLSchema");
//node->createChild("xmlns", true)->setStringValue(xml_namespace);
node = node->createChild("xs:complexType", false);
node->createChild("name", true)->setStringValue(type_name);
node->createChild("mixed", true)->setStringValue("true");
//node = node->createChild("xs:complexType", false);
//node->createChild("name", true)->setStringValue(type_name);
//node->createChild("mixed", true)->setStringValue("true");
mAttributeNode = node;
mElementNode = node->createChild("xs:choice", false);
mElementNode->createChild("minOccurs", true)->setStringValue("0");
mElementNode->createChild("maxOccurs", true)->setStringValue("unbounded");
//mAttributeNode = node;
//mElementNode = node->createChild("xs:choice", false);
//mElementNode->createChild("minOccurs", true)->setStringValue("0");
//mElementNode->createChild("maxOccurs", true)->setStringValue("unbounded");
block.inspectBlock(*this);
// duplicate element choices

2
indra/newview/llfloatercamera.cpp
View File

@ -346,7 +346,7 @@ LLFloaterCamera::LLFloaterCamera(const LLSD& val)
mCurrMode(CAMERA_CTRL_MODE_PAN),
mPrevMode(CAMERA_CTRL_MODE_PAN)
{
LLHints::registerHintTarget("view_popup", LLView::getHandle());
LLHints::registerHintTarget("view_popup", getHandle());
mCommitCallbackRegistrar.add("CameraPresets.ChangeView", boost::bind(&LLFloaterCamera::onClickCameraItem, _2));
}

4
indra/newview/llfloaterwebcontent.cpp
View File

@ -167,7 +167,7 @@ LLFloater* LLFloaterWebContent::create( Params p)
//static
void LLFloaterWebContent::closeRequest(const std::string &uuid)
{
LLFloaterWebContent* floaterp = getInstance(uuid);
LLFloaterWebContent* floaterp = instance_tracker_t::getInstance(uuid);
if (floaterp)
{
floaterp->closeFloater(false);
@ -177,7 +177,7 @@ void LLFloaterWebContent::closeRequest(const std::string &uuid)
//static
void LLFloaterWebContent::geometryChanged(const std::string &uuid, S32 x, S32 y, S32 width, S32 height)
{
LLFloaterWebContent* floaterp = getInstance(uuid);
LLFloaterWebContent* floaterp = instance_tracker_t::getInstance(uuid);
if (floaterp)
{
floaterp->geometryChanged(x, y, width, height);

1
indra/newview/llfloaterwebcontent.h
View File

@ -43,6 +43,7 @@ class LLFloaterWebContent :
public LLInstanceTracker<LLFloaterWebContent, std::string>
{
public:
typedef LLInstanceTracker<LLFloaterWebContent, std::string> instance_tracker_t;
LOG_CLASS(LLFloaterWebContent);
struct _Params : public LLInitParam::Block<_Params>

2
indra/newview/llnavigationbar.cpp
View File

@ -317,7 +317,7 @@ BOOL LLNavigationBar::postBuild()
LLTeleportHistory::getInstance()->setHistoryChangedCallback(
boost::bind(&LLNavigationBar::onTeleportHistoryChanged, this));
LLHints::registerHintTarget("nav_bar", LLView::getHandle());
LLHints::registerHintTarget("nav_bar", getHandle());
return TRUE;
}

4
indra/newview/lltoast.h
View File

@ -196,7 +196,7 @@ public:
virtual S32 notifyParent(const LLSD& info);
LLHandle<LLToast> getHandle() { mHandle.bind(this); return mHandle; }
LLHandle<LLToast> getHandle() const { return getDerivedHandle<LLToast>(); }
protected:
void updateTransparency();
@ -215,7 +215,7 @@ private:
LLUUID mSessionID;
LLNotificationPtr mNotification;
LLRootHandle<LLToast> mHandle;
//LLRootHandle<LLToast> mHandle;
LLPanel* mWrapperPanel;