summaryrefslogtreecommitdiff
path: root/indra/llui
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llui')
-rw-r--r--indra/llui/llaccordionctrl.cpp2
-rw-r--r--indra/llui/llpanel.cpp101
-rw-r--r--indra/llui/llpanel.h62
-rw-r--r--indra/llui/lltextbase.h1
-rw-r--r--indra/llui/lluictrlfactory.cpp152
-rw-r--r--indra/llui/lluictrlfactory.h120
-rw-r--r--indra/llui/llview.cpp4
7 files changed, 180 insertions, 262 deletions
diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
index c3ef734823..9337626c8e 100644
--- a/indra/llui/llaccordionctrl.cpp
+++ b/indra/llui/llaccordionctrl.cpp
@@ -89,7 +89,7 @@ LLAccordionCtrl::LLAccordionCtrl() : LLPanel()
mSingleExpansion = false;
mFitParent = false;
- LLUICtrlFactory::getInstance()->buildPanel(this, "accordion_parent.xml");
+ buildPanel(this, "accordion_parent.xml");
}
//---------------------------------------------------------------------------------
diff --git a/indra/llui/llpanel.cpp b/indra/llui/llpanel.cpp
index 0f769bd6dc..bfca0bd45e 100644
--- a/indra/llui/llpanel.cpp
+++ b/indra/llui/llpanel.cpp
@@ -41,6 +41,7 @@
#include "llfontgl.h"
#include "llrect.h"
#include "llerror.h"
+#include "lldir.h"
#include "lltimer.h"
#include "llaccordionctrltab.h"
@@ -58,6 +59,8 @@
#include "lltabcontainer.h"
static LLDefaultChildRegistry::Register<LLPanel> r1("panel", &LLPanel::fromXML);
+LLPanel::factory_stack_t LLPanel::sFactoryStack;
+
// Compiler optimization, generate extern template
template class LLPanel* LLView::getChild<class LLPanel>(
@@ -400,7 +403,7 @@ LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parent, LLXMLNodePtr output_
if (!panelp)
{
- panelp = LLUICtrlFactory::getInstance()->createFactoryPanel(name);
+ panelp = createFactoryPanel(name);
llassert(panelp);
if (!panelp)
@@ -413,20 +416,20 @@ LLView* LLPanel::fromXML(LLXMLNodePtr node, LLView* parent, LLXMLNodePtr output_
// factory panels may have registered their own factory maps
if (!panelp->getFactoryMap().empty())
{
- LLUICtrlFactory::instance().pushFactoryFunctions(&panelp->getFactoryMap());
+ sFactoryStack.push_back(&panelp->getFactoryMap());
}
// for local registry callbacks; define in constructor, referenced in XUI or postBuild
panelp->mCommitCallbackRegistrar.pushScope();
panelp->mEnableCallbackRegistrar.pushScope();
- panelp->initPanelXML(node, parent, output_node);
+ panelp->initPanelXML(node, parent, output_node, LLUICtrlFactory::getDefaultParams<LLPanel>());
panelp->mCommitCallbackRegistrar.popScope();
panelp->mEnableCallbackRegistrar.popScope();
if (!panelp->getFactoryMap().empty())
{
- LLUICtrlFactory::instance().popFactoryFunctions();
+ sFactoryStack.pop_back();
}
return panelp;
@@ -493,11 +496,9 @@ static LLFastTimer::DeclareTimer FTM_PANEL_SETUP("Panel Setup");
static LLFastTimer::DeclareTimer FTM_EXTERNAL_PANEL_LOAD("Load Extern Panel Reference");
static LLFastTimer::DeclareTimer FTM_PANEL_POSTBUILD("Panel PostBuild");
-BOOL LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node)
+BOOL LLPanel::initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node, const LLPanel::Params& default_params)
{
- const LLPanel::Params& default_params(LLUICtrlFactory::getDefaultParams<LLPanel>());
Params params(default_params);
-
{
LLFastTimer timer(FTM_PANEL_SETUP);
@@ -965,3 +966,89 @@ boost::signals2::connection LLPanel::setVisibleCallback( const commit_signal_t::
return mVisibleSignal->connect(cb);
}
+
+static LLFastTimer::DeclareTimer FTM_BUILD_PANELS("Build Panels");
+
+//-----------------------------------------------------------------------------
+// buildPanel()
+//-----------------------------------------------------------------------------
+BOOL LLPanel::buildPanel(LLPanel* panelp, const std::string& filename, LLXMLNodePtr output_node, const LLPanel::Params& default_params)
+{
+ LLFastTimer timer(FTM_BUILD_PANELS);
+ BOOL didPost = FALSE;
+ LLXMLNodePtr root;
+
+ //if exporting, only load the language being exported,
+ //instead of layering localized version on top of english
+ if (output_node)
+ {
+ if (!LLUICtrlFactory::getLocalizedXMLNode(filename, root))
+ {
+ llwarns << "Couldn't parse panel from: " << LLUI::getLocalizedSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
+ return didPost;
+ }
+ }
+ else if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
+ {
+ llwarns << "Couldn't parse panel from: " << LLUI::getSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
+ return didPost;
+ }
+
+ // root must be called panel
+ if( !root->hasName("panel" ) )
+ {
+ llwarns << "Root node should be named panel in : " << filename << llendl;
+ return didPost;
+ }
+
+ lldebugs << "Building panel " << filename << llendl;
+
+ LLUICtrlFactory::instance().pushFileName(filename);
+ {
+ if (!panelp->getFactoryMap().empty())
+ {
+ sFactoryStack.push_back(&panelp->getFactoryMap());
+ }
+
+ // for local registry callbacks; define in constructor, referenced in XUI or postBuild
+ panelp->getCommitCallbackRegistrar().pushScope();
+ panelp->getEnableCallbackRegistrar().pushScope();
+
+ didPost = panelp->initPanelXML(root, NULL, output_node, default_params);
+
+ panelp->getCommitCallbackRegistrar().popScope();
+ panelp->getEnableCallbackRegistrar().popScope();
+
+ panelp->setXMLFilename(filename);
+
+ if (!panelp->getFactoryMap().empty())
+ {
+ sFactoryStack.pop_back();
+ }
+ }
+ LLUICtrlFactory::instance().popFileName();
+ return didPost;
+}
+
+//-----------------------------------------------------------------------------
+// createFactoryPanel()
+//-----------------------------------------------------------------------------
+LLPanel* LLPanel::createFactoryPanel(const std::string& name)
+{
+ std::deque<const LLCallbackMap::map_t*>::iterator itor;
+ for (itor = sFactoryStack.begin(); itor != sFactoryStack.end(); ++itor)
+ {
+ const LLCallbackMap::map_t* factory_map = *itor;
+
+ // Look up this panel's name in the map.
+ LLCallbackMap::map_const_iter_t iter = factory_map->find( name );
+ if (iter != factory_map->end())
+ {
+ // Use the factory to create the panel, instead of using a default LLPanel.
+ LLPanel *ret = (LLPanel*) iter->second.mCallback( iter->second.mData );
+ return ret;
+ }
+ }
+ LLPanel::Params panel_p;
+ return LLUICtrlFactory::create<LLPanel>(panel_p);
+} \ No newline at end of file
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
index 784054cd86..6fc8ca204f 100644
--- a/indra/llui/llpanel.h
+++ b/indra/llui/llpanel.h
@@ -110,7 +110,10 @@ protected:
LLPanel(const LLPanel::Params& params = getDefaultParams());
public:
-// LLPanel(const std::string& name, const LLRect& rect = LLRect(), BOOL bordered = TRUE);
+ static BOOL buildPanel(LLPanel* panelp, const std::string &filename, LLXMLNodePtr output_node = NULL, const LLPanel::Params&default_params = getDefaultParams());
+
+ static LLPanel* createFactoryPanel(const std::string& name);
+
/*virtual*/ ~LLPanel();
// LLView interface
@@ -163,7 +166,7 @@ public:
EnableCallbackRegistry::ScopedRegistrar& getEnableCallbackRegistrar() { return mEnableCallbackRegistrar; }
void initFromParams(const Params& p);
- BOOL initPanelXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node = NULL);
+ BOOL initPanelXML( LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node, const LLPanel::Params& default_params);
bool hasString(const std::string& name);
std::string getString(const std::string& name, const LLStringUtil::format_map_t& args) const;
@@ -283,6 +286,8 @@ private:
// for setting the xml filename when building panel in context dependent cases
std::string mXMLFilename;
+ typedef std::deque<const LLCallbackMap::map_t*> factory_stack_t;
+ static factory_stack_t sFactoryStack;
}; // end class LLPanel
// Build time optimization, generate once in .cpp file
@@ -291,4 +296,57 @@ extern template class LLPanel* LLView::getChild<class LLPanel>(
const std::string& name, BOOL recurse) const;
#endif
+typedef boost::function<LLPanel* (void)> LLPanelClassCreatorFunc;
+
+// local static instance for registering a particular panel class
+
+class LLRegisterPanelClass
+: public LLSingleton< LLRegisterPanelClass >
+{
+public:
+ // reigister with either the provided builder, or the generic templated builder
+ void addPanelClass(const std::string& tag,LLPanelClassCreatorFunc func)
+ {
+ mPanelClassesNames[tag] = func;
+ }
+
+ LLPanel* createPanelClass(const std::string& tag)
+ {
+ param_name_map_t::iterator iT = mPanelClassesNames.find(tag);
+ if(iT == mPanelClassesNames.end())
+ return 0;
+ return iT->second();
+ }
+ template<typename T>
+ static T* defaultPanelClassBuilder()
+ {
+ T* pT = new T();
+ return pT;
+ }
+
+private:
+ typedef std::map< std::string, LLPanelClassCreatorFunc> param_name_map_t;
+
+ param_name_map_t mPanelClassesNames;
+};
+
+
+// local static instance for registering a particular panel class
+template<typename T>
+class LLRegisterPanelClassWrapper
+: public LLRegisterPanelClass
+{
+public:
+ // reigister with either the provided builder, or the generic templated builder
+ LLRegisterPanelClassWrapper(const std::string& tag);
+};
+
+
+template<typename T>
+LLRegisterPanelClassWrapper<T>::LLRegisterPanelClassWrapper(const std::string& tag)
+{
+ LLRegisterPanelClass::instance().addPanelClass(tag,&LLRegisterPanelClass::defaultPanelClassBuilder<T>);
+}
+
+
#endif
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index db010d1cf6..2314ece6df 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -241,6 +241,7 @@ class LLTextBase
public:
friend class LLTextSegment;
friend class LLNormalTextSegment;
+ friend class LLUICtrlFactory;
struct LineSpacingParams : public LLInitParam::Choice<LineSpacingParams>
{
diff --git a/indra/llui/lluictrlfactory.cpp b/indra/llui/lluictrlfactory.cpp
index c5bd6c7fce..913c8bdb7d 100644
--- a/indra/llui/lluictrlfactory.cpp
+++ b/indra/llui/lluictrlfactory.cpp
@@ -218,7 +218,7 @@ bool LLUICtrlFactory::buildFloater(LLFloater* floaterp, const std::string& filen
{
if (!floaterp->getFactoryMap().empty())
{
- mFactoryStack.push_front(&floaterp->getFactoryMap());
+ LLPanel::sFactoryStack.push_front(&floaterp->getFactoryMap());
}
// for local registry callbacks; define in constructor, referenced in XUI or postBuild
@@ -234,7 +234,7 @@ bool LLUICtrlFactory::buildFloater(LLFloater* floaterp, const std::string& filen
if (!floaterp->getFactoryMap().empty())
{
- mFactoryStack.pop_front();
+ LLPanel::sFactoryStack.pop_front();
}
}
popFileName();
@@ -250,69 +250,6 @@ S32 LLUICtrlFactory::saveToXML(LLView* viewp, const std::string& filename)
return 0;
}
-static LLFastTimer::DeclareTimer FTM_BUILD_PANELS("Build Panels");
-
-//-----------------------------------------------------------------------------
-// buildPanel()
-//-----------------------------------------------------------------------------
-BOOL LLUICtrlFactory::buildPanel(LLPanel* panelp, const std::string& filename, LLXMLNodePtr output_node)
-{
- LLFastTimer timer(FTM_BUILD_PANELS);
- BOOL didPost = FALSE;
- LLXMLNodePtr root;
-
- //if exporting, only load the language being exported,
- //instead of layering localized version on top of english
- if (output_node)
- {
- if (!LLUICtrlFactory::getLocalizedXMLNode(filename, root))
- {
- llwarns << "Couldn't parse panel from: " << LLUI::getLocalizedSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
- return didPost;
- }
- }
- else if (!LLUICtrlFactory::getLayeredXMLNode(filename, root))
- {
- llwarns << "Couldn't parse panel from: " << LLUI::getSkinPath() + gDirUtilp->getDirDelimiter() + filename << llendl;
- return didPost;
- }
-
- // root must be called panel
- if( !root->hasName("panel" ) )
- {
- llwarns << "Root node should be named panel in : " << filename << llendl;
- return didPost;
- }
-
- lldebugs << "Building panel " << filename << llendl;
-
- pushFileName(filename);
- {
- if (!panelp->getFactoryMap().empty())
- {
- mFactoryStack.push_front(&panelp->getFactoryMap());
- }
-
- // for local registry callbacks; define in constructor, referenced in XUI or postBuild
- panelp->getCommitCallbackRegistrar().pushScope();
- panelp->getEnableCallbackRegistrar().pushScope();
-
- didPost = panelp->initPanelXML(root, NULL, output_node);
-
- panelp->getCommitCallbackRegistrar().popScope();
- panelp->getEnableCallbackRegistrar().popScope();
-
- panelp->setXMLFilename(filename);
-
- if (!panelp->getFactoryMap().empty())
- {
- mFactoryStack.pop_front();
- }
- }
- popFileName();
- return didPost;
-}
-
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
@@ -344,29 +281,6 @@ LLView *LLUICtrlFactory::createFromXML(LLXMLNodePtr node, LLView* parent, const
return view;
}
-//-----------------------------------------------------------------------------
-// createFactoryPanel()
-//-----------------------------------------------------------------------------
-LLPanel* LLUICtrlFactory::createFactoryPanel(const std::string& name)
-{
- std::deque<const LLCallbackMap::map_t*>::iterator itor;
- for (itor = mFactoryStack.begin(); itor != mFactoryStack.end(); ++itor)
- {
- const LLCallbackMap::map_t* factory_map = *itor;
-
- // Look up this panel's name in the map.
- LLCallbackMap::map_const_iter_t iter = factory_map->find( name );
- if (iter != factory_map->end())
- {
- // Use the factory to create the panel, instead of using a default LLPanel.
- LLPanel *ret = (LLPanel*) iter->second.mCallback( iter->second.mData );
- return ret;
- }
- }
- LLPanel::Params panel_p;
- return create<LLPanel>(panel_p);
-}
-
std::string LLUICtrlFactory::getCurFileName()
{
return mFileNames.empty() ? "" : gDirUtilp->getWorkingDir() + gDirUtilp->getDirDelimiter() + mFileNames.back();
@@ -383,36 +297,6 @@ void LLUICtrlFactory::popFileName()
mFileNames.pop_back();
}
-
-//-----------------------------------------------------------------------------
-
-//static
-BOOL LLUICtrlFactory::getAttributeColor(LLXMLNodePtr node, const std::string& name, LLColor4& color)
-{
- std::string colorstring;
- BOOL res = node->getAttributeString(name.c_str(), colorstring);
- if (res)
- {
- if (LLUIColorTable::instance().colorExists(colorstring))
- {
- color.setVec(LLUIColorTable::instance().getColor(colorstring));
- }
- else
- {
- res = FALSE;
- }
- }
- if (!res)
- {
- res = LLColor4::parseColor(colorstring, &color);
- }
- if (!res)
- {
- res = node->getAttributeColor(name.c_str(), color);
- }
- return res;
-}
-
//static
void LLUICtrlFactory::setCtrlParent(LLView* view, LLView* parent, S32 tab_group)
{
@@ -428,28 +312,22 @@ std::string LLUICtrlFactory::findSkinnedFilename(const std::string& filename)
return gDirUtilp->findSkinnedFilename(LLUI::getSkinPath(), filename);
}
-void LLUICtrlFactory::pushFactoryFunctions(const LLCallbackMap::map_t* map)
-{
- mFactoryStack.push_back(map);
-}
-
-void LLUICtrlFactory::popFactoryFunctions()
-{
- if (!mFactoryStack.empty())
- {
- mFactoryStack.pop_back();
- }
-}
-
//static
void LLUICtrlFactory::copyName(LLXMLNodePtr src, LLXMLNodePtr dest)
{
dest->setName(src->getName()->mString);
}
+template<typename T>
+const LLInitParam::BaseBlock& get_empty_param_block()
+{
+ static typename T::Params params;
+ return params;
+}
+
// adds a widget and its param block to various registries
//static
-void LLUICtrlFactory::registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, dummy_widget_creator_func_t creator_func, const std::string& tag)
+void LLUICtrlFactory::registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, const std::string& tag)
{
// associate parameter block type with template .xml file
std::string* existing_tag = LLWidgetNameRegistry::instance().getValue(param_block_type);
@@ -469,17 +347,9 @@ void LLUICtrlFactory::registerWidget(const std::type_info* widget_type, const st
}
}
LLWidgetNameRegistry::instance().defaultRegistrar().add(param_block_type, tag);
- // associate widget type with factory function
- LLDefaultWidgetRegistry::instance().defaultRegistrar().add(widget_type, creator_func);
//FIXME: comment this in when working on schema generation
//LLWidgetTypeRegistry::instance().defaultRegistrar().add(tag, widget_type);
- //LLDefaultParamBlockRegistry::instance().defaultRegistrar().add(widget_type, &getEmptyParamBlock<T>);
-}
-
-//static
-dummy_widget_creator_func_t* LLUICtrlFactory::getDefaultWidgetFunc(const std::type_info* widget_type)
-{
- return LLDefaultWidgetRegistry::instance().getValue(widget_type);
+ //LLDefaultParamBlockRegistry::instance().defaultRegistrar().add(widget_type, &get_empty_param_block<T>);
}
//static
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
index dc43b311a7..c4d3aa38d8 100644
--- a/indra/llui/lluictrlfactory.h
+++ b/indra/llui/lluictrlfactory.h
@@ -33,24 +33,14 @@
#ifndef LLUICTRLFACTORY_H
#define LLUICTRLFACTORY_H
-#include "llcallbackmap.h"
+#include "llfasttimer.h"
#include "llinitparam.h"
#include "llregistry.h"
-#include "v4color.h"
-#include "llfasttimer.h"
-
#include "llxuiparser.h"
-#include <boost/function.hpp>
-#include <iosfwd>
-#include <stack>
-#include <set>
-
-class LLPanel;
class LLFloater;
class LLView;
-
// sort functor for typeid maps
struct LLCompareTypeID
{
@@ -91,12 +81,6 @@ class LLWidgetNameRegistry
: public LLRegistrySingleton<const std::type_info*, std::string, LLWidgetNameRegistry , LLCompareTypeID>
{};
-// lookup factory functions for default widget instances by widget type
-typedef LLView* (*dummy_widget_creator_func_t)(const std::string&);
-class LLDefaultWidgetRegistry
-: public LLRegistrySingleton<const std::type_info*, dummy_widget_creator_func_t, LLDefaultWidgetRegistry, LLCompareTypeID>
-{};
-
// lookup function for generating empty param block by widget type
// this is used for schema generation
//typedef const LLInitParam::BaseBlock& (*empty_param_block_func_t)();
@@ -164,23 +148,16 @@ public:
}
bool buildFloater(LLFloater* floaterp, const std::string &filename, LLXMLNodePtr output_node);
- BOOL buildPanel(LLPanel* panelp, const std::string &filename, LLXMLNodePtr output_node = NULL);
// Does what you want for LLFloaters and LLPanels
// Returns 0 on success
S32 saveToXML(LLView* viewp, const std::string& filename);
+ // filename tracking for debugging info
std::string getCurFileName();
void pushFileName(const std::string& name);
void popFileName();
- static BOOL getAttributeColor(LLXMLNodePtr node, const std::string& name, LLColor4& color);
-
- LLPanel* createFactoryPanel(const std::string& name);
-
- void pushFactoryFunctions(const LLCallbackMap::map_t* map);
- void popFactoryFunctions();
-
template<typename T>
static T* createWidget(const typename T::Params& params, LLView* parent = NULL)
{
@@ -192,12 +169,10 @@ public:
//return NULL;
}
- {
- LLFastTimer timer(FTM_WIDGET_CONSTRUCTION);
+ { LLFastTimer _(FTM_WIDGET_CONSTRUCTION);
widget = new T(params);
}
- {
- LLFastTimer timer(FTM_INIT_FROM_PARAMS);
+ { LLFastTimer _(FTM_INIT_FROM_PARAMS);
widget->initFromParams(params);
}
@@ -272,17 +247,9 @@ fail:
template<class T>
static T* getDefaultWidget(const std::string& name)
{
- dummy_widget_creator_func_t* dummy_func = getDefaultWidgetFunc(&typeid(T));
- return dummy_func ? dynamic_cast<T*>((*dummy_func)(name)) : NULL;
- }
-
- template <class T>
- static LLView* createDefaultWidget(const std::string& name)
- {
- typename T::Params params;
- params.name(name);
-
- return create<T>(params);
+ T::Params widget_params;
+ widget_params.name = name;
+ return create<T>(widget_params);
}
static void copyName(LLXMLNodePtr src, LLXMLNodePtr dest);
@@ -335,12 +302,9 @@ fail:
static void loadWidgetTemplate(const std::string& widget_tag, LLInitParam::BaseBlock& block);
// helper function for adding widget type info to various registries
- static void registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, dummy_widget_creator_func_t creator_func, const std::string& tag);
+ static void registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, const std::string& tag);
private:
- // return default widget instance factory func for a given type
- static dummy_widget_creator_func_t* getDefaultWidgetFunc(const std::type_info* widget_type);
-
static const std::string* getWidgetTag(const std::type_info* widget_type);
// this exists to get around dependency on llview
@@ -349,20 +313,10 @@ private:
// Avoid directly using LLUI and LLDir in the template code
static std::string findSkinnedFilename(const std::string& filename);
- typedef std::deque<const LLCallbackMap::map_t*> factory_stack_t;
- factory_stack_t mFactoryStack;
-
- LLPanel* mDummyPanel;
+ class LLPanel* mDummyPanel;
std::vector<std::string> mFileNames;
};
-template<typename T>
-const LLInitParam::BaseBlock& getEmptyParamBlock()
-{
- static typename T::Params params;
- return params;
-}
-
// this is here to make gcc happy with reference to LLUICtrlFactory
template<typename DERIVED>
template<typename T>
@@ -370,7 +324,7 @@ LLChildRegistry<DERIVED>::Register<T>::Register(const char* tag, LLWidgetCreator
: LLChildRegistry<DERIVED>::StaticRegistrar(tag, func.empty() ? (LLWidgetCreatorFunc)&LLUICtrlFactory::defaultBuilder<T> : func)
{
// add this widget to various registries
- LLUICtrlFactory::instance().registerWidget(&typeid(T), &typeid(typename T::Params), &LLUICtrlFactory::createDefaultWidget<T>, tag);
+ LLUICtrlFactory::instance().registerWidget(&typeid(T), &typeid(typename T::Params), tag);
// since registry_t depends on T, do this in line here
// TODO: uncomment this for schema generation
@@ -378,58 +332,4 @@ LLChildRegistry<DERIVED>::Register<T>::Register(const char* tag, LLWidgetCreator
//LLChildRegistryRegistry::instance().defaultRegistrar().add(&typeid(T), registry_t::instance());
}
-
-typedef boost::function<LLPanel* (void)> LLPanelClassCreatorFunc;
-
-// local static instance for registering a particular panel class
-
-class LLRegisterPanelClass
-: public LLSingleton< LLRegisterPanelClass >
-{
-public:
- // reigister with either the provided builder, or the generic templated builder
- void addPanelClass(const std::string& tag,LLPanelClassCreatorFunc func)
- {
- mPanelClassesNames[tag] = func;
- }
-
- LLPanel* createPanelClass(const std::string& tag)
- {
- param_name_map_t::iterator iT = mPanelClassesNames.find(tag);
- if(iT == mPanelClassesNames.end())
- return 0;
- return iT->second();
- }
- template<typename T>
- static T* defaultPanelClassBuilder()
- {
- T* pT = new T();
- return pT;
- }
-
-private:
- typedef std::map< std::string, LLPanelClassCreatorFunc> param_name_map_t;
-
- param_name_map_t mPanelClassesNames;
-};
-
-
-// local static instance for registering a particular panel class
-template<typename T>
-class LLRegisterPanelClassWrapper
-: public LLRegisterPanelClass
-{
-public:
- // reigister with either the provided builder, or the generic templated builder
- LLRegisterPanelClassWrapper(const std::string& tag);
-};
-
-
-template<typename T>
-LLRegisterPanelClassWrapper<T>::LLRegisterPanelClassWrapper(const std::string& tag)
-{
- LLRegisterPanelClass::instance().addPanelClass(tag,&LLRegisterPanelClass::defaultPanelClassBuilder<T>);
-}
-
-
#endif //LLUICTRLFACTORY_H
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 4d3708302b..3ee4a85de0 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -1698,7 +1698,9 @@ LLView* LLView::getChildView(const std::string& name, BOOL recurse) const
child = getDefaultWidget<LLView>(name);
if (!child)
{
- child = LLUICtrlFactory::createDefaultWidget<LLView>(name);
+ LLView::Params view_params;
+ view_params.name = name;
+ child = LLUICtrlFactory::create<LLView>(view_params);
}
}
return child;
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-14 10:30:41 +0000