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

Settings inventory picker.

master
Rider Linden 2018-06-08 16:40:01 -07:00
parent 363f7f84a1
commit 8365945f8a
22 changed files with 2567 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llcommon/llassettype.cpp
View File

@ -95,7 +95,7 @@ LLAssetDictionary::LLAssetDictionary()
addEntry(LLAssetType::AT_MESH, new AssetEntry("MESH", "mesh", "mesh", false, false, false));
addEntry(LLAssetType::AT_WIDGET, new AssetEntry("WIDGET", "widget", "widget", false, false, false));
addEntry(LLAssetType::AT_PERSON, new AssetEntry("PERSON", "person", "person", false, false, false));
addEntry(LLAssetType::AT_SETTINGS, new AssetEntry("SETTINGS", "settings", "settings blob", false, true, true));
addEntry(LLAssetType::AT_SETTINGS, new AssetEntry("SETTINGS", "settings", "settings blob", true, true, true));
addEntry(LLAssetType::AT_NONE, new AssetEntry("NONE", "-1", NULL, FALSE, FALSE, FALSE));
};

2
indra/llinventory/llsettingsbase.cpp
View File

@ -284,7 +284,7 @@ bool LLSettingsBase::validate()
if (!mSettings.has(SETTING_TYPE))
{
mSettings[SETTING_TYPE] = getSettingType();
mSettings[SETTING_TYPE] = getSettingsType();
}
LLSD result = LLSettingsBase::settingValidation(mSettings, validations);

4
indra/llinventory/llsettingsbase.h
View File

@ -75,9 +75,9 @@ public:
virtual ~LLSettingsBase() { };
//---------------------------------------------------------------------
virtual std::string getSettingType() const = 0;
virtual std::string getSettingsType() const = 0;
virtual LLSettingsType::type_e getSettingTypeValue() const = 0;
virtual LLSettingsType::type_e getSettingsTypeValue() const = 0;
//---------------------------------------------------------------------
// Settings status

10
indra/llinventory/llsettingsdaycycle.cpp
View File

@ -145,7 +145,7 @@ LLSD LLSettingsDay::getSettings() const
if (mSettings.has(SETTING_ID))
settings[SETTING_ID] = mSettings[SETTING_ID];
settings[SETTING_TYPE] = getSettingType();
settings[SETTING_TYPE] = getSettingsType();
std::map<std::string, LLSettingsBase::ptr_t> in_use;
@ -236,18 +236,18 @@ bool LLSettingsDay::initialize()
if (i == TRACK_WATER)
{
setting = used[(*it)[SETTING_KEYNAME]];
if (setting && setting->getSettingType() != "water")
if (setting && setting->getSettingsType() != "water")
{
LL_WARNS("DAYCYCLE") << "Water track referencing " << setting->getSettingType() << " frame at " << keyframe << "." << LL_ENDL;
LL_WARNS("DAYCYCLE") << "Water track referencing " << setting->getSettingsType() << " frame at " << keyframe << "." << LL_ENDL;
setting.reset();
}
}
else
{
setting = used[(*it)[SETTING_KEYNAME]];
if (setting && setting->getSettingType() != "sky")
if (setting && setting->getSettingsType() != "sky")
{
LL_WARNS("DAYCYCLE") << "Sky track #" << i << " referencing " << setting->getSettingType() << " frame at " << keyframe << "." << LL_ENDL;
LL_WARNS("DAYCYCLE") << "Sky track #" << i << " referencing " << setting->getSettingsType() << " frame at " << keyframe << "." << LL_ENDL;
setting.reset();
}
}

4
indra/llinventory/llsettingsdaycycle.h
View File

@ -78,11 +78,11 @@ public:
virtual ptr_t buildClone() = 0;
virtual LLSD getSettings() const SETTINGS_OVERRIDE;
virtual LLSettingsType::type_e getSettingTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_DAYCYCLE; }
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_DAYCYCLE; }
//---------------------------------------------------------------------
virtual std::string getSettingType() const SETTINGS_OVERRIDE { return std::string("daycycle"); }
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("daycycle"); }
// Settings status
virtual void blend(const LLSettingsBase::ptr_t &other, F64 mix) SETTINGS_OVERRIDE;

4
indra/llinventory/llsettingssky.h
View File

@ -97,8 +97,8 @@ public:
virtual ptr_t buildClone() = 0;
//---------------------------------------------------------------------
virtual std::string getSettingType() const SETTINGS_OVERRIDE { return std::string("sky"); }
virtual LLSettingsType::type_e getSettingTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_SKY; }
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("sky"); }
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_SKY; }
// Settings status
virtual void blend(const LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;

4
indra/llinventory/llsettingswater.h
View File

@ -55,8 +55,8 @@ public:
virtual ptr_t buildClone() = 0;
//---------------------------------------------------------------------
virtual std::string getSettingType() const SETTINGS_OVERRIDE { return std::string("water"); }
virtual LLSettingsType::type_e getSettingTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_WATER; }
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("water"); }
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_WATER; }
// Settings status
virtual void blend(const LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;

2
indra/newview/CMakeLists.txt
View File

@ -539,6 +539,7 @@ set(viewer_SOURCE_FILES
llsecapi.cpp
llsechandler_basic.cpp
llselectmgr.cpp
llsettingspicker.cpp
llsettingsvo.cpp
llshareavatarhandler.cpp
llsidepanelappearance.cpp
@ -1149,6 +1150,7 @@ set(viewer_HEADER_FILES
llsecapi.h
llsechandler_basic.h
llselectmgr.h
llsettingspicker.h
llsettingsvo.h
llsidepanelappearance.h
llsidepanelinventory.h

10
indra/newview/llenvironment.cpp
View File

@ -550,7 +550,7 @@ void LLEnvironment::setEnvironment(LLEnvironment::EnvSelection_t env, const LLSe
return;
}
if (settings->getSettingType() == "daycycle")
if (settings->getSettingsType() == "daycycle")
{
LLSettingsDay::Seconds daylength(LLSettingsDay::DEFAULT_DAYLENGTH);
LLSettingsDay::Seconds dayoffset(LLSettingsDay::DEFAULT_DAYOFFSET);
@ -561,7 +561,7 @@ void LLEnvironment::setEnvironment(LLEnvironment::EnvSelection_t env, const LLSe
}
setEnvironment(env, std::static_pointer_cast<LLSettingsDay>(settings), daylength, dayoffset);
}
else if (settings->getSettingType() == "sky")
else if (settings->getSettingsType() == "sky")
{
fixedEnvironment_t fixedenv(std::static_pointer_cast<LLSettingsSky>(settings), LLSettingsWater::ptr_t());
if (environment)
@ -570,7 +570,7 @@ void LLEnvironment::setEnvironment(LLEnvironment::EnvSelection_t env, const LLSe
}
setEnvironment(env, fixedenv);
}
else if (settings->getSettingType() == "water")
else if (settings->getSettingsType() == "water")
{
fixedEnvironment_t fixedenv(LLSettingsSky::ptr_t(), std::static_pointer_cast<LLSettingsWater>(settings));
if (environment)
@ -1201,7 +1201,7 @@ void LLEnvironment::onUpdateParcelAssetLoaded(LLUUID asset_id, LLSettingsBase::p
LLSettingsDay::ptr_t pday;
if (settings->getSettingType() == "daycycle")
if (settings->getSettingsType() == "daycycle")
pday = std::static_pointer_cast<LLSettingsDay>(settings);
else
{
@ -1561,7 +1561,7 @@ LLSettingsDay::ptr_t LLEnvironment::createDayCycleFromLegacyPreset(const std::st
LLSettingsDay::ptr_t LLEnvironment::createDayCycleFromEnvironment(EnvSelection_t env, LLSettingsBase::ptr_t settings)
{
std::string type(settings->getSettingType());
std::string type(settings->getSettingsType());
if (type == "daycycle")
return std::static_pointer_cast<LLSettingsDay>(settings);

74
indra/newview/llfloatereditextdaycycle.cpp
View File

@ -46,6 +46,8 @@
#include "llinventorymodel.h"
#include "llviewerparcelmgr.h"
#include "llsettingspicker.h"
// newview
#include "llagent.h"
#include "llparcel.h"
@ -55,6 +57,8 @@
#include "llpaneleditwater.h"
#include "llpaneleditsky.h"
#include "llui.h"
#include "llenvironment.h"
#include "lltrans.h"
@ -266,18 +270,31 @@ void LLFloaterEditExtDayCycle::onClose(bool app_quitting)
stopPlay();
}
void LLFloaterEditExtDayCycle::onFocusReceived()
{
updateEditEnvironment();
LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_EDIT, LLEnvironment::TRANSITION_FAST);
}
void LLFloaterEditExtDayCycle::onFocusLost()
{
stopPlay();
LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_LOCAL);
}
void LLFloaterEditExtDayCycle::onVisibilityChange(BOOL new_visibility)
{
if (new_visibility)
{
LLEnvironment::instance().setEnvironment(LLEnvironment::ENV_EDIT, mScratchSky, mScratchWater);
LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_EDIT);
}
else
{
LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_LOCAL);
stopPlay();
}
// if (new_visibility)
// {
// LLEnvironment::instance().setEnvironment(LLEnvironment::ENV_EDIT, mScratchSky, mScratchWater);
// LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_EDIT);
// }
// else
// {
// LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_LOCAL);
// stopPlay();
// }
}
void LLFloaterEditExtDayCycle::refresh()
@ -335,7 +352,7 @@ void LLFloaterEditExtDayCycle::onButtonImport()
void LLFloaterEditExtDayCycle::onButtonLoadFrame()
{
doOpenInventoryFloater((mCurrentTrack == LLSettingsDay::TRACK_WATER) ? LLSettingsType::ST_WATER : LLSettingsType::ST_SKY);
}
void LLFloaterEditExtDayCycle::onAddTrack()
@ -818,6 +835,7 @@ void LLFloaterEditExtDayCycle::onAssetLoaded(LLUUID asset_id, LLSettingsBase::pt
}
mEditDay = std::dynamic_pointer_cast<LLSettingsDay>(settings);
updateEditEnvironment();
LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_EDIT);
syncronizeTabs();
refresh();
}
@ -848,7 +866,8 @@ void LLFloaterEditExtDayCycle::loadLiveEnvironment(LLEnvironment::EnvSelection_t
void LLFloaterEditExtDayCycle::updateEditEnvironment(void)
{
if (!mEditDay)
return;
S32 skytrack = (mCurrentTrack) ? mCurrentTrack : 1;
mSkyBlender = std::make_shared<LLTrackBlenderLoopingManual>(mScratchSky, mEditDay, skytrack);
mWaterBlender = std::make_shared<LLTrackBlenderLoopingManual>(mScratchWater, mEditDay, LLSettingsDay::TRACK_WATER);
@ -1104,4 +1123,35 @@ void LLFloaterEditExtDayCycle::onIdlePlay(void* user_data)
}
void LLFloaterEditExtDayCycle::doOpenInventoryFloater(LLSettingsType::type_e type)
{
// LLUI::sWindow->setCursor(UI_CURSOR_WAIT);
LLFloater* floaterp = mInventoryFloater.get();
// Show the dialog
if (!floaterp)
{
LLFloaterSettingsPicker *picker = new LLFloaterSettingsPicker(
this,
LLUUID::null, "SELECT SETTINGS");
mInventoryFloater = picker->getHandle();
picker->setCommitCallback([this](LLUICtrl *, const LLSD &data){ onPickerCommitSetting(data.asUUID()); });
// texture_floaterp->setTextureSelectedCallback(boost::bind(&LLOutfitGallery::onTextureSelectionChanged, this, _1));
// texture_floaterp->setOnFloaterCommitCallback(boost::bind(&LLOutfitGallery::onTexturePickerCommit, this, _1, _2));
// texture_floaterp->setOnUpdateImageStatsCallback(boost::bind(&LLOutfitGallery::onTexturePickerUpdateImageStats, this, _1));
// texture_floaterp->setLocalTextureEnabled(FALSE);
floaterp = picker;
}
((LLFloaterSettingsPicker *)floaterp)->setSettingsFilter(type);
floaterp->openFloater();
floaterp->setFocus(TRUE);
}
void LLFloaterEditExtDayCycle::onPickerCommitSetting(LLUUID asset_id)
{
LL_WARNS("LAPRAS") << "Got asset ID=" << asset_id << LL_ENDL;
}

123
indra/newview/llfloatereditextdaycycle.h
View File

@ -60,84 +60,85 @@ public:
static const std::string KEY_DAY_LENGTH;
// **RIDER**
typedef boost::signals2::signal<void(LLSettingsDay::ptr_t)> edit_commit_signal_t;
typedef boost::signals2::connection connection_t;
typedef boost::signals2::signal<void(LLSettingsDay::ptr_t)> edit_commit_signal_t;
typedef boost::signals2::connection connection_t;
LLFloaterEditExtDayCycle(const LLSD &key);
~LLFloaterEditExtDayCycle();
LLFloaterEditExtDayCycle(const LLSD &key);
virtual ~LLFloaterEditExtDayCycle();
//void openFloater(LLSettingsDay::ptr_t settings, S64Seconds daylength = S64Seconds(0), S64Seconds dayoffset = S64Seconds(0));
virtual BOOL postBuild() override;
virtual void onOpen(const LLSD& key) override;
virtual void onClose(bool app_quitting) override;
virtual void onFocusReceived() override;
virtual void onFocusLost() override;
virtual void onVisibilityChange(BOOL new_visibility) override;
BOOL postBuild();
void onOpen(const LLSD& key);
void onClose(bool app_quitting);
connection_t setEditCommitSignal(edit_commit_signal_t::slot_type cb);
void onVisibilityChange(BOOL new_visibility);
connection_t setEditCommitSignal(edit_commit_signal_t::slot_type cb);
virtual void refresh();
virtual void refresh() override;
private:
// flyout response/click
void onButtonApply(LLUICtrl *ctrl, const LLSD &data);
void onBtnCancel();
void onButtonImport();
void onButtonLoadFrame();
void onAddTrack();
void onRemoveTrack();
void onCommitName(class LLLineEditor* caller, void* user_data);
void onTrackSelectionCallback(const LLSD& user_data);
void onPlayActionCallback(const LLSD& user_data);
void onButtonApply(LLUICtrl *ctrl, const LLSD &data);
void onBtnCancel();
void onButtonImport();
void onButtonLoadFrame();
void onAddTrack();
void onRemoveTrack();
void onCommitName(class LLLineEditor* caller, void* user_data);
void onTrackSelectionCallback(const LLSD& user_data);
void onPlayActionCallback(const LLSD& user_data);
// time slider moved
void onTimeSliderMoved();
void onTimeSliderMoved();
// a frame moved or frame selection changed
void onFrameSliderCallback(const LLSD &);
void onFrameSliderDoubleClick(S32 x, S32 y, MASK mask);
void onFrameSliderMouseDown(S32 x, S32 y, MASK mask);
void onFrameSliderMouseUp(S32 x, S32 y, MASK mask);
void onFrameSliderCallback(const LLSD &);
void onFrameSliderDoubleClick(S32 x, S32 y, MASK mask);
void onFrameSliderMouseDown(S32 x, S32 y, MASK mask);
void onFrameSliderMouseUp(S32 x, S32 y, MASK mask);
void selectTrack(U32 track_index, bool force = false);
void selectFrame(F32 frame);
void clearTabs();
void updateTabs();
void updateWaterTabs(const LLSettingsWaterPtr_t &p_water);
void updateSkyTabs(const LLSettingsSkyPtr_t &p_sky);
void setWaterTabsEnabled(BOOL enable);
void setSkyTabsEnabled(BOOL enable);
void updateButtons();
void updateSlider(); //track to slider
void updateTimeAndLabel();
void addSliderFrame(const F32 frame, LLSettingsBase::ptr_t &setting, bool update_ui = true);
void removeCurrentSliderFrame();
void selectTrack(U32 track_index, bool force = false);
void selectFrame(F32 frame);
void clearTabs();
void updateTabs();
void updateWaterTabs(const LLSettingsWaterPtr_t &p_water);
void updateSkyTabs(const LLSettingsSkyPtr_t &p_sky);
void setWaterTabsEnabled(BOOL enable);
void setSkyTabsEnabled(BOOL enable);
void updateButtons();
void updateSlider(); //track to slider
void updateTimeAndLabel();
void addSliderFrame(const F32 frame, LLSettingsBase::ptr_t &setting, bool update_ui = true);
void removeCurrentSliderFrame();
// **RIDER**
void loadInventoryItem(const LLUUID &inventoryId);
void onAssetLoaded(LLUUID asset_id, LLSettingsBase::ptr_t settings, S32 status);
void loadLiveEnvironment(LLEnvironment::EnvSelection_t env);
void loadInventoryItem(const LLUUID &inventoryId);
void onAssetLoaded(LLUUID asset_id, LLSettingsBase::ptr_t settings, S32 status);
void loadLiveEnvironment(LLEnvironment::EnvSelection_t env);
void doImportFromDisk();
void doApplyCreateNewInventory();
void doApplyUpdateInventory();
void doApplyEnvironment(const std::string &where);
void onInventoryCreated(LLUUID asset_id, LLUUID inventory_id, LLSD results);
void onInventoryUpdated(LLUUID asset_id, LLUUID inventory_id, LLSD results);
void doImportFromDisk();
void doApplyCreateNewInventory();
void doApplyUpdateInventory();
void doApplyEnvironment(const std::string &where);
void onInventoryCreated(LLUUID asset_id, LLUUID inventory_id, LLSD results);
void onInventoryUpdated(LLUUID asset_id, LLUUID inventory_id, LLSD results);
bool canUseInventory() const;
bool canApplyRegion() const;
bool canApplyParcel() const;
void doOpenInventoryFloater(LLSettingsType::type_e type);
void onPickerCommitSetting(LLUUID asset_id);
void updateEditEnvironment();
void syncronizeTabs();
void reblendSettings();
bool canUseInventory() const;
bool canApplyRegion() const;
bool canApplyParcel() const;
void setTabsData(LLTabContainer * tabcontainer, const LLSettingsBase::ptr_t &settings, bool editable);
void updateEditEnvironment();
void syncronizeTabs();
void reblendSettings();
void setTabsData(LLTabContainer * tabcontainer, const LLSettingsBase::ptr_t &settings, bool editable);
// play functions
void startPlay();
void stopPlay();
static void onIdlePlay(void *);
void startPlay();
void stopPlay();
static void onIdlePlay(void *);
LLSettingsDay::ptr_t mEditDay; // edited copy
LLSettingsDay::Seconds mDayLength;
@ -157,6 +158,8 @@ private:
LLInventoryItem * mInventoryItem;
LLFlyoutComboBtnCtrl * mFlyoutControl;
LLHandle<LLFloater> mInventoryFloater;
LLTrackBlenderLoopingManual::ptr_t mSkyBlender;
LLTrackBlenderLoopingManual::ptr_t mWaterBlender;
LLSettingsSky::ptr_t mScratchSky;

8
indra/newview/llfloaterfixedenvironment.cpp
View File

@ -302,16 +302,16 @@ void LLFloaterFixedEnvironment::doApplyEnvironment(const std::string &where)
if (!parcel)
return;
if (mSettings->getSettingType() == "sky")
if (mSettings->getSettingsType() == "sky")
LLEnvironment::instance().updateParcel(parcel->getLocalID(), std::static_pointer_cast<LLSettingsSky>(mSettings), -1, -1);
else if (mSettings->getSettingType() == "water")
else if (mSettings->getSettingsType() == "water")
LLEnvironment::instance().updateParcel(parcel->getLocalID(), std::static_pointer_cast<LLSettingsWater>(mSettings), -1, -1);
}
else if (where == ACTION_APPLY_REGION)
{
if (mSettings->getSettingType() == "sky")
if (mSettings->getSettingsType() == "sky")
LLEnvironment::instance().updateRegion(std::static_pointer_cast<LLSettingsSky>(mSettings), -1, -1);
else if (mSettings->getSettingType() == "water")
else if (mSettings->getSettingsType() == "water")
LLEnvironment::instance().updateRegion(std::static_pointer_cast<LLSettingsWater>(mSettings), -1, -1);
}
else

5
indra/newview/llfolderviewmodelinventory.h
View File

@ -49,8 +49,9 @@ public:
virtual bool hasChildren() const = 0;
virtual LLInventoryType::EType getInventoryType() const = 0;
virtual void performAction(LLInventoryModel* model, std::string action) = 0;
virtual LLWearableType::EType getWearableType() const = 0;
virtual EInventorySortGroup getSortGroup() const = 0;
virtual LLWearableType::EType getWearableType() const = 0;
virtual LLSettingsType::type_e getSettingsType() const = 0;
virtual EInventorySortGroup getSortGroup() const = 0;
virtual LLInventoryObject* getInventoryObject() const = 0;
virtual void requestSort();
virtual void setPassedFilter(bool filtered, S32 filter_generation, std::string::size_type string_offset = std::string::npos, std::string::size_type string_size = 0);

28
indra/newview/llinventoryfilter.cpp
View File

@ -53,6 +53,7 @@ LLInventoryFilter::FilterOps::FilterOps(const Params& p)
: mFilterObjectTypes(p.object_types),
mFilterCategoryTypes(p.category_types),
mFilterWearableTypes(p.wearable_types),
mFilterSettingsTypes(p.settings_types),
mMinDate(p.date_range.min_date),
mMaxDate(p.date_range.max_date),
mHoursAgo(p.hours_ago),
@ -325,12 +326,26 @@ bool LLInventoryFilter::checkAgainstFilterType(const LLFolderViewModelItemInvent
if (filterTypes & FILTERTYPE_WEARABLE)
{
LLWearableType::EType type = listener->getWearableType();
if ((0x1LL << type & mFilterOps.mFilterWearableTypes) == 0)
if ((object_type == LLInventoryType::IT_WEARABLE) &&
(((0x1LL << type) & mFilterOps.mFilterWearableTypes) == 0))
{
return FALSE;
}
}
////////////////////////////////////////////////////////////////////////////////
// FILTERTYPE_SETTINGS
// Pass if this item is a setting of the appropriate type
if (filterTypes & FILTERTYPE_SETTINGS)
{
LLSettingsType::type_e type = listener->getSettingsType();
if ((object_type == LLInventoryType::IT_SETTINGS) &&
(((0x1LL << type) & mFilterOps.mFilterSettingsTypes) == 0))
{
return FALSE;
}
}
////////////////////////////////////////////////////////////////////////////////
// FILTERTYPE_EMPTYFOLDERS
// Pass if this item is a folder and is not a system folder that should be hidden
@ -626,6 +641,12 @@ void LLInventoryFilter::setFilterWearableTypes(U64 types)
mFilterOps.mFilterTypes |= FILTERTYPE_WEARABLE;
}
void LLInventoryFilter::setFilterSettingsTypes(U64 types)
{
updateFilterTypes(types, mFilterOps.mFilterSettingsTypes);
mFilterOps.mFilterTypes |= FILTERTYPE_SETTINGS;
}
void LLInventoryFilter::setFilterEmptySystemFolders()
{
mFilterOps.mFilterTypes |= FILTERTYPE_EMPTYFOLDERS;
@ -1241,6 +1262,11 @@ U64 LLInventoryFilter::getFilterWearableTypes() const
return mFilterOps.mFilterWearableTypes;
}
U64 LLInventoryFilter::getFilterSettingsTypes() const
{
return mFilterOps.mFilterSettingsTypes;
}
bool LLInventoryFilter::hasFilterString() const
{
return mFilterSubString.size() > 0;

31
indra/newview/llinventoryfilter.h
View File

@ -47,18 +47,19 @@ public:
enum EFilterType {
FILTERTYPE_NONE = 0,
FILTERTYPE_OBJECT = 0x1 << 0, // normal default search-by-object-type
FILTERTYPE_CATEGORY = 0x1 << 1, // search by folder type
FILTERTYPE_UUID = 0x1 << 2, // find the object with UUID and any links to it
FILTERTYPE_DATE = 0x1 << 3, // search by date range
FILTERTYPE_WEARABLE = 0x1 << 4, // search by wearable type
FILTERTYPE_OBJECT = 0x1 << 0, // normal default search-by-object-type
FILTERTYPE_CATEGORY = 0x1 << 1, // search by folder type
FILTERTYPE_UUID = 0x1 << 2, // find the object with UUID and any links to it
FILTERTYPE_DATE = 0x1 << 3, // search by date range
FILTERTYPE_WEARABLE = 0x1 << 4, // search by wearable type
FILTERTYPE_EMPTYFOLDERS = 0x1 << 5, // pass if folder is not a system folder to be hidden if empty
FILTERTYPE_MARKETPLACE_ACTIVE = 0x1 << 6, // pass if folder is a marketplace active folder
FILTERTYPE_MARKETPLACE_INACTIVE = 0x1 << 7, // pass if folder is a marketplace inactive folder
FILTERTYPE_MARKETPLACE_UNASSOCIATED = 0x1 << 8, // pass if folder is a marketplace non associated (no market ID) folder
FILTERTYPE_MARKETPLACE_LISTING_FOLDER = 0x1 << 9, // pass iff folder is a listing folder
FILTERTYPE_NO_MARKETPLACE_ITEMS = 0x1 << 10, // pass iff folder is not under the marketplace
FILTERTYPE_WORN = 0x1 << 11, // pass if item is worn
FILTERTYPE_WORN = 0x1 << 11, // pass if item is worn
FILTERTYPE_SETTINGS = 0x1 << 12, // pass if the item is a settings object
};
enum EFilterDateDirection
@ -80,7 +81,7 @@ public:
SO_DATE = 0x1, // Sort inventory by date
SO_FOLDERS_BY_NAME = 0x1 << 1, // Force folder sort by name
SO_SYSTEM_FOLDERS_TO_TOP = 0x1 << 2,// Force system folders to be on top
SO_FOLDERS_BY_WEIGHT = 0x1 << 3, // Force folder sort by weight, usually, amount of some elements in their descendents
SO_FOLDERS_BY_WEIGHT = 0x1 << 3, // Force folder sort by weight, usually, amount of some elements in their descendants
};
enum ESearchType
@ -118,6 +119,7 @@ public:
Optional<U32> types;
Optional<U64> object_types,
wearable_types,
settings_types,
category_types;
Optional<EFilterLink> links;
Optional<LLUUID> uuid;
@ -131,7 +133,8 @@ public:
: types("filter_types", FILTERTYPE_OBJECT),
object_types("object_types", 0xffffFFFFffffFFFFULL),
wearable_types("wearable_types", 0xffffFFFFffffFFFFULL),
category_types("category_types", 0xffffFFFFffffFFFFULL),
settings_types("settings_types", 0xffffFFFFffffFFFFULL),
category_types("category_types", 0xffffFFFFffffFFFFULL),
links("links", FILTERLINK_INCLUDE_LINKS),
uuid("uuid"),
date_range("date_range"),
@ -145,10 +148,11 @@ public:
FilterOps(const Params& = Params());
U32 mFilterTypes;
U64 mFilterObjectTypes, // For _OBJECT
mFilterWearableTypes,
mFilterLinks,
mFilterCategoryTypes; // For _CATEGORY
U64 mFilterObjectTypes, // For _OBJECT
mFilterWearableTypes,
mFilterSettingsTypes, // for _SETTINGS
mFilterLinks,
mFilterCategoryTypes; // For _CATEGORY
LLUUID mFilterUUID; // for UUID
time_t mMinDate,
@ -186,11 +190,14 @@ public:
U64 getFilterObjectTypes() const;
U64 getFilterCategoryTypes() const;
U64 getFilterWearableTypes() const;
U64 getFilterSettingsTypes() const;
bool isFilterObjectTypesWith(LLInventoryType::EType t) const;
void setFilterObjectTypes(U64 types);
void setFilterCategoryTypes(U64 types);
void setFilterUUID(const LLUUID &object_id);
void setFilterWearableTypes(U64 types);
void setFilterSettingsTypes(U64 types);
void setFilterEmptySystemFolders();
void setFilterWorn();
void setFilterMarketplaceActiveFolders();

5
indra/newview/llinventorypanel.cpp
View File

@ -377,6 +377,11 @@ void LLInventoryPanel::setFilterWearableTypes(U64 types)
getFilter().setFilterWearableTypes(types);
}
void LLInventoryPanel::setFilterSettingsTypes(U64 filter)
{
getFilter().setFilterSettingsTypes(filter);
}
void LLInventoryPanel::setFilterSubString(const std::string& string)
{
getFilter().setFilterSubString(string);

5
indra/newview/llinventorypanel.h
View File

@ -176,8 +176,9 @@ public:
U32 getFilterObjectTypes() const;
void setFilterPermMask(PermissionMask filter_perm_mask);
U32 getFilterPermMask() const;
void setFilterWearableTypes(U64 filter);
void setFilterSubString(const std::string& string);
void setFilterWearableTypes(U64 filter);
void setFilterSettingsTypes(U64 filter);
void setFilterSubString(const std::string& string);
const std::string getFilterSubString();
void setSinceLogoff(BOOL sl);
void setHoursAgo(U32 hours);

35
indra/newview/llpanelobjectinventory.cpp
View File

@ -145,6 +145,7 @@ public:
virtual bool hasChildren() const { return FALSE; }
virtual LLInventoryType::EType getInventoryType() const { return LLInventoryType::IT_NONE; }
virtual LLWearableType::EType getWearableType() const { return LLWearableType::WT_NONE; }
virtual LLSettingsType::type_e getSettingsType() const { return LLSettingsType::ST_NONE; }
virtual EInventorySortGroup getSortGroup() const { return SG_ITEM; }
virtual LLInventoryObject* getInventoryObject() const { return findInvObject(); }
@ -1413,6 +1414,34 @@ void LLTaskMeshBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
hide_context_entries(menu, items, disabled_items);
}
///----------------------------------------------------------------------------
/// Class LLTaskSettingsBridge
///----------------------------------------------------------------------------
class LLTaskSettingsBridge : public LLTaskInvFVBridge
{
public:
LLTaskSettingsBridge(LLPanelObjectInventory* panel,
const LLUUID& uuid,
const std::string& name,
U32 flags) :
LLTaskInvFVBridge(panel, uuid, name, flags) {}
virtual LLUIImagePtr getIcon() const;
virtual LLSettingsType::type_e getSettingsType() const;
};
LLUIImagePtr LLTaskSettingsBridge::getIcon() const
{
return LLInventoryIcon::getIcon(mAssetType, mInventoryType, mFlags, FALSE);
}
LLSettingsType::type_e LLTaskSettingsBridge::getSettingsType() const
{
return LLSettingsType::ST_NONE;
}
///----------------------------------------------------------------------------
/// LLTaskInvFVBridge impl
//----------------------------------------------------------------------------
@ -1499,6 +1528,12 @@ LLTaskInvFVBridge* LLTaskInvFVBridge::createObjectBridge(LLPanelObjectInventory*
object_id,
object_name);
break;
case LLAssetType::AT_SETTINGS:
new_bridge = new LLTaskSettingsBridge(panel,
object_id,
object_name,
itemflags);
break;
default:
LL_INFOS() << "Unhandled inventory type (llassetstorage.h): "
<< (S32)type << LL_ENDL;

1761
indra/newview/llsettingspicker.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

451
indra/newview/llsettingspicker.h Normal file
View File

@ -0,0 +1,451 @@
/**
* @file llsettingspicker.h
* @author Rider Linden
* @brief LLSettingsPicker class header file including related functions
*
* $LicenseInfo:firstyear=2018&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2018, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LL_SETTINGSPICKER_H
#define LL_SETTINGSPICKER_H
#include "llinventorysettings.h"
#include "llfloater.h"
#include "llpermissionsflags.h"
#include "llfolderview.h"
#include <boost/signals2.hpp>
//=========================================================================
class LLFilterEditor;
class LLInventoryPanel;
//=========================================================================
class LLFloaterSettingsPicker : public LLFloater
{
public:
typedef std::function<void (LLUUID id)> commit_callback_t;
typedef std::function<void()> close_callback_t;
typedef std::function<void(const LLUUID& asset_id)> id_changed_callback_t;
LLFloaterSettingsPicker(LLView * owner, LLUUID setting_asset_id, const std::string &label, const LLSD &params = LLSD());
virtual ~LLFloaterSettingsPicker() override;
void setActive(bool active);
void setSettingsID(const LLUUID &settings_id, bool set_selection = true);
virtual BOOL postBuild() override;
virtual void onClose(bool app_quitting) override;
virtual void draw() override;
void setSettingsAssetID(LLUUID setting_asset_id);
LLUUID getSettingsAssetID() const { return mSettingAssetID; }
void setDefaultSettingsAssetID(LLUUID id) { mDefaultSettingsAssetID = id; }
LLUUID getDefaultSettingsAssetID() const { return mDefaultSettingsAssetID; }
void setSettingsFilter(LLSettingsType::type_e type);
LLSettingsType::type_e getSettingsFilter() const { return mSettingsType; }
// Takes a UUID, wraps get/setImageAssetID
virtual void setValue(const LLSD& value) override;
virtual LLSD getValue() const override;
private:
typedef std::deque<LLFolderViewItem *> itemlist_t;
void onFilterEdit(const std::string& search_string);
void onSelectionChange(const itemlist_t &items, bool user_action);
void onButtonCancel();
void onButtonSelect();
LLUUID findItemID(const LLUUID& asset_id, bool copyable_only, bool ignore_library = false);
LLView* mOwner;
std::string mLabel;
LLUUID mSettingAssetID;
LLUUID mDefaultSettingsAssetID;
LLFilterEditor * mFilterEdit;
LLInventoryPanel * mInventoryPanel;
LLSettingsType::type_e mSettingsType;
F32 mContextConeOpacity;
PermissionMask mImmediateFilterPermMask;
PermissionMask mDnDFilterPermMask;
PermissionMask mNonImmediateFilterPermMask;
bool mActive;
bool mNoCopySettingsSelected;
LLSaveFolderState mSavedFolderState;
// boost::signals2::signal<void(LLUUID id)> mCommitSignal;
boost::signals2::signal<void()> mCloseSignal;
boost::signals2::signal<void(const LLUUID& asset_id)> mChangeIDSignal;
};
#if 0
#include "llcoord.h"
#include "llfiltereditor.h"
#include "llfolderview.h"
#include "lllocalbitmaps.h"
#include "llstring.h"
#include "lluictrl.h"
#include "llradiogroup.h"
#include "lltextbox.h" // for params
#include "llviewerinventory.h"
#include "llviewborder.h" // for params
#include "llviewerobject.h"
#include "llviewertexture.h"
#include "llwindow.h"
class LLButton;
class LLFloaterTexturePicker;
class LLInventoryItem;
class LLViewerFetchedTexture;
// used for setting drag & drop callbacks.
typedef boost::function<BOOL (LLUICtrl*, LLInventoryItem*)> drag_n_drop_callback;
typedef boost::function<void (LLInventoryItem*)> texture_selected_callback;
//////////////////////////////////////////////////////////////////////////////////////////
// LLTextureCtrl
class LLTextureCtrl
: public LLUICtrl
{
public:
typedef enum e_texture_pick_op
{
TEXTURE_CHANGE,
TEXTURE_SELECT,
TEXTURE_CANCEL
} ETexturePickOp;
public:
struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
{
Optional<LLUUID> image_id;
Optional<LLUUID> default_image_id;
Optional<std::string> default_image_name;
Optional<bool> allow_no_texture;
Optional<bool> can_apply_immediately;
Optional<bool> no_commit_on_selection; // alternative mode: commit occurs and the widget gets dirty
// only on DnD or when OK is pressed in the picker
Optional<S32> label_width;
Optional<LLUIColor> border_color;
Optional<LLUIImage*> fallback_image;
Optional<LLTextBox::Params> multiselect_text,
caption_text;
Optional<LLViewBorder::Params> border;
Params()
: image_id("image"),
default_image_id("default_image_id"),
default_image_name("default_image_name"),
allow_no_texture("allow_no_texture"),
can_apply_immediately("can_apply_immediately"),
no_commit_on_selection("no_commit_on_selection", false),
label_width("label_width", -1),
border_color("border_color"),
fallback_image("fallback_image"),
multiselect_text("multiselect_text"),
caption_text("caption_text"),
border("border")
{}
};
protected:
LLTextureCtrl(const Params&);
friend class LLUICtrlFactory;
public:
virtual ~LLTextureCtrl();
// LLView interface
virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
EAcceptance *accept,
std::string& tooltip_msg);
virtual BOOL handleHover(S32 x, S32 y, MASK mask);
virtual BOOL handleUnicodeCharHere(llwchar uni_char);
virtual void draw();
virtual void setVisible( BOOL visible );
virtual void setEnabled( BOOL enabled );
void setValid(BOOL valid);
// LLUICtrl interface
virtual void clear();
// Takes a UUID, wraps get/setImageAssetID
virtual void setValue(const LLSD& value);
virtual LLSD getValue() const;
// LLTextureCtrl interface
void showPicker(BOOL take_focus);
bool isPickerShown() { return !mFloaterHandle.isDead(); }
void setLabel(const std::string& label);
void setLabelWidth(S32 label_width) {mLabelWidth =label_width;}
const std::string& getLabel() const { return mLabel; }
void setAllowNoTexture( BOOL b ) { mAllowNoTexture = b; }
bool getAllowNoTexture() const { return mAllowNoTexture; }
const LLUUID& getImageItemID() { return mImageItemID; }
virtual void setImageAssetName(const std::string& name);
void setImageAssetID(const LLUUID &image_asset_id);
const LLUUID& getImageAssetID() const { return mImageAssetID; }
void setDefaultImageAssetID( const LLUUID& id ) { mDefaultImageAssetID = id; }
const LLUUID& getDefaultImageAssetID() const { return mDefaultImageAssetID; }
const std::string& getDefaultImageName() const { return mDefaultImageName; }
void setBlankImageAssetID( const LLUUID& id ) { mBlankImageAssetID = id; }
const LLUUID& getBlankImageAssetID() const { return mBlankImageAssetID; }
void setCaption(const std::string& caption);
void setCanApplyImmediately(BOOL b);
void setCanApply(bool can_preview, bool can_apply);
void setImmediateFilterPermMask(PermissionMask mask)
{ mImmediateFilterPermMask = mask; }
void setDnDFilterPermMask(PermissionMask mask)
{ mDnDFilterPermMask = mask; }
void setNonImmediateFilterPermMask(PermissionMask mask)
{ mNonImmediateFilterPermMask = mask; }
PermissionMask getImmediateFilterPermMask() { return mImmediateFilterPermMask; }
PermissionMask getNonImmediateFilterPermMask() { return mNonImmediateFilterPermMask; }
void closeDependentFloater();
void onFloaterClose();
void onFloaterCommit(ETexturePickOp op, LLUUID id);
// This call is returned when a drag is detected. Your callback
// should return TRUE if the drag is acceptable.
void setDragCallback(drag_n_drop_callback cb) { mDragCallback = cb; }
// This callback is called when the drop happens. Return TRUE if
// the drop happened - resulting in an on commit callback, but not
// necessariliy any other change.
void setDropCallback(drag_n_drop_callback cb) { mDropCallback = cb; }
void setOnCancelCallback(commit_callback_t cb) { mOnCancelCallback = cb; }
void setOnCloseCallback(commit_callback_t cb) { mOnCloseCallback = cb; }
void setOnSelectCallback(commit_callback_t cb) { mOnSelectCallback = cb; }
/*
* callback for changing texture selection in inventory list of texture floater
*/
void setOnTextureSelectedCallback(texture_selected_callback cb);
void setShowLoadingPlaceholder(BOOL showLoadingPlaceholder);
LLViewerFetchedTexture* getTexture() { return mTexturep; }
private:
BOOL allowDrop(LLInventoryItem* item);
BOOL doDrop(LLInventoryItem* item);
private:
drag_n_drop_callback mDragCallback;
drag_n_drop_callback mDropCallback;
commit_callback_t mOnCancelCallback;
commit_callback_t mOnSelectCallback;
commit_callback_t mOnCloseCallback;
texture_selected_callback mOnTextureSelectedCallback;
LLPointer<LLViewerFetchedTexture> mTexturep;
LLUIColor mBorderColor;
LLUUID mImageItemID;
LLUUID mImageAssetID;
LLUUID mDefaultImageAssetID;
LLUUID mBlankImageAssetID;
LLUIImagePtr mFallbackImage;
std::string mDefaultImageName;
LLHandle<LLFloater> mFloaterHandle;
LLTextBox* mTentativeLabel;
LLTextBox* mCaption;
std::string mLabel;
BOOL mAllowNoTexture; // If true, the user can select "none" as an option
PermissionMask mImmediateFilterPermMask;
PermissionMask mDnDFilterPermMask;
PermissionMask mNonImmediateFilterPermMask;
BOOL mCanApplyImmediately;
BOOL mCommitOnSelection;
BOOL mNeedsRawImageData;
LLViewBorder* mBorder;
BOOL mValid;
BOOL mShowLoadingPlaceholder;
std::string mLoadingPlaceholderString;
S32 mLabelWidth;
};
//////////////////////////////////////////////////////////////////////////////////////////
// LLFloaterTexturePicker
typedef boost::function<void(LLTextureCtrl::ETexturePickOp op, LLUUID id)> floater_commit_callback;
typedef boost::function<void()> floater_close_callback;
typedef boost::function<void(const LLUUID& asset_id)> set_image_asset_id_callback;
typedef boost::function<void(LLPointer<LLViewerTexture> texture)> set_on_update_image_stats_callback;
class LLFloaterTexturePicker : public LLFloater
{
public:
LLFloaterTexturePicker(
LLView* owner,
LLUUID image_asset_id,
LLUUID default_image_asset_id,
LLUUID blank_image_asset_id,
BOOL tentative,
BOOL allow_no_texture,
const std::string& label,
PermissionMask immediate_filter_perm_mask,
PermissionMask dnd_filter_perm_mask,
PermissionMask non_immediate_filter_perm_mask,
BOOL can_apply_immediately,
LLUIImagePtr fallback_image_name
);
virtual ~LLFloaterTexturePicker();
// LLView overrides
/*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
EAcceptance *accept,
std::string& tooltip_msg);
/*virtual*/ void draw();
/*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
// LLFloater overrides
/*virtual*/ BOOL postBuild();
/*virtual*/ void onClose(bool app_settings);
// New functions
void setImageID(const LLUUID& image_asset_id, bool set_selection = true);
void updateImageStats();
const LLUUID& getAssetID() { return mImageAssetID; }
const LLUUID& findItemID(const LLUUID& asset_id, BOOL copyable_only, BOOL ignore_library = FALSE);
void setCanApplyImmediately(BOOL b);
void setActive(BOOL active);
LLView* getOwner() const { return mOwner; }
void setOwner(LLView* owner) { mOwner = owner; }
void stopUsingPipette();
PermissionMask getFilterPermMask();
void updateFilterPermMask();
void commitIfImmediateSet();
void commitCancel();
void onFilterEdit(const std::string& search_string);
void setCanApply(bool can_preview, bool can_apply);
void setTextureSelectedCallback(const texture_selected_callback& cb) { mTextureSelectedCallback = cb; }
void setOnFloaterCloseCallback(const floater_close_callback& cb) { mOnFloaterCloseCallback = cb; }
void setOnFloaterCommitCallback(const floater_commit_callback& cb) { mOnFloaterCommitCallback = cb; }
void setSetImageAssetIDCallback(const set_image_asset_id_callback& cb) { mSetImageAssetIDCallback = cb; }
void setOnUpdateImageStatsCallback(const set_on_update_image_stats_callback& cb) { mOnUpdateImageStatsCallback = cb; }
const LLUUID& getDefaultImageAssetID() { return mDefaultImageAssetID; }
const LLUUID& getBlankImageAssetID() { return mBlankImageAssetID; }
static void onBtnSetToDefault(void* userdata);
static void onBtnSelect(void* userdata);
static void onBtnCancel(void* userdata);
void onBtnPipette();
//static void onBtnRevert( void* userdata );
static void onBtnBlank(void* userdata);
static void onBtnNone(void* userdata);
static void onBtnClear(void* userdata);
void onSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action);
static void onShowFolders(LLUICtrl* ctrl, void* userdata);
static void onApplyImmediateCheck(LLUICtrl* ctrl, void* userdata);
void onTextureSelect(const LLTextureEntry& te);
static void onModeSelect(LLUICtrl* ctrl, void *userdata);
static void onBtnAdd(void* userdata);
static void onBtnRemove(void* userdata);
static void onBtnUpload(void* userdata);
static void onLocalScrollCommit(LLUICtrl* ctrl, void* userdata);
void setLocalTextureEnabled(BOOL enabled);
protected:
LLPointer<LLViewerTexture> mTexturep;
LLView* mOwner;
LLUUID mImageAssetID; // Currently selected texture
LLUIImagePtr mFallbackImage; // What to show if currently selected texture is null.
LLUUID mDefaultImageAssetID;
LLUUID mBlankImageAssetID;
BOOL mTentative;
BOOL mAllowNoTexture;
LLUUID mSpecialCurrentImageAssetID; // Used when the asset id has no corresponding texture in the user's inventory.
LLUUID mOriginalImageAssetID;
std::string mLabel;
LLTextBox* mTentativeLabel;
LLTextBox* mResolutionLabel;
std::string mPendingName;
BOOL mActive;
LLFilterEditor* mFilterEdit;
LLInventoryPanel* mInventoryPanel;
PermissionMask mImmediateFilterPermMask;
PermissionMask mDnDFilterPermMask;
PermissionMask mNonImmediateFilterPermMask;
BOOL mCanApplyImmediately;
BOOL mNoCopyTextureSelected;
F32 mContextConeOpacity;
LLSaveFolderState mSavedFolderState;
BOOL mSelectedItemPinned;
LLRadioGroup* mModeSelector;
LLScrollListCtrl* mLocalScrollCtrl;
private:
bool mCanApply;
bool mCanPreview;
bool mPreviewSettingChanged;
texture_selected_callback mTextureSelectedCallback;
floater_close_callback mOnFloaterCloseCallback;
floater_commit_callback mOnFloaterCommitCallback;
set_image_asset_id_callback mSetImageAssetIDCallback;
set_on_update_image_stats_callback mOnUpdateImageStatsCallback;
};
#endif
#endif // LL_LLTEXTURECTRL_H

2
indra/newview/llsettingsvo.cpp
View File

@ -104,7 +104,7 @@ void LLSettingsVOBase::createInventoryItem(const LLSettingsBase::ptr_t &settings
create_inventory_settings(gAgent.getID(), gAgent.getSessionID(),
parentFolder, tid,
settings->getName(), "new settings collection.",
settings->getSettingTypeValue(), nextOwnerPerm, cb);
settings->getSettingsTypeValue(), nextOwnerPerm, cb);
}
void LLSettingsVOBase::onInventoryItemCreated(const LLUUID &inventoryId, LLSettingsBase::ptr_t settings, inventory_result_fn callback)

118
indra/newview/skins/default/xui/en/floater_settings_picker.xml
View File

@ -1,11 +1,115 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<floater
height="602"
legacy_header_height="18"
can_minimize="false"
can_resize="true"
height="330"
layout="topleft"
name="floater_settings_picker"
help_topic=""
save_rect="true"
title="Settings Selector"
width="705">
min_height="330"
min_width="225"
name="settings picker"
help_topic="settings_picker"
title="PICK: SETTINGS"
width="225">
<!-- top static -->
<floater.string
name="choose_picture">
Click to choose a picture
</floater.string>
<floater.string
name="pick title">
Pick:
</floater.string>
<layout_stack name="test_stack"
follows="all"
animate="false"
top="20"
left="6"
right="-6"
bottom="-10"
auto_resize="true"
user_resize="true"
orientation="vertical">
<layout_panel name="temp"
border="false"
auto_resize="true"
user_resize="true"
height="29"
min_height="29"
bg_alpha_color="blue"
background_visible="false">
<filter_editor
follows="left|top|right"
height="23"
label="Filter Textures"
layout="topleft"
left="4"
name="flt_inventory_search"
top="4"
right="-2" />
<inventory_panel
allow_multi_select="false"
bg_visible="true"
bg_alpha_color="DkGray2"
border="false"
follows="left|top|right|bottom"
left_delta="0"
name="pnl_inventory"
top="31"
right="-4"
bottom="-26"
/>
<check_box
follows="left|bottom"
height="14"
initial_value="false"
label="Show folders"
layout="topleft"
name="chk_showfolders"
top="-20"
top_pad="0"
left_delta="-3"
width="200" />
</layout_panel>
<layout_panel name="temp"
border="false"
auto_resize="false"
user_resize="false"
height="29"
min_height="29">
<!-- bg_alpha_color="red"
background_visible="true" -->
<button
follows="top|left"
height="20"
label="OK"
label_selected="OK"
layout="topleft"
left="2"
top="2"
name="btn_select"
width="100" />
<button
follows="top|left"
height="20"
label="Cancel"
label_selected="Cancel"
layout="topleft"
left_delta="110"
top_delta="0"
name="btn_cancel"
width="100" />
</layout_panel>
</layout_stack>
<!-- middle: inventory mode -->
<!--
-->
<!-- bottom static -->
<!--
-->
</floater>