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

MAINT-119 FIXED (PUBLIC]no-transfer textures not searchable via texture picker) 

- Implemented Richard's and Leo's spec
- Also fixed an issue when applying no-transfer texture for an object using texture picker, creates redundant copies of the texture in the object's content
master
Paul ProductEngine 2012-05-22 20:01:22 +03:00
parent 534168c452
commit 890c583289
16 changed files with 254 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/newview/app_settings/settings.xml
View File

@ -148,7 +148,7 @@
<key>Value</key>
<integer>1</integer>
</map>
<key>ApplyTextureImmediately</key>
<key>TextureLivePreview</key>
<map>
<key>Comment</key>
<string>Preview selections in texture picker immediately</string>

1
indra/newview/llfloaterland.cpp
View File

@ -1901,6 +1901,7 @@ BOOL LLPanelLandOptions::postBuild()
mSnapshotCtrl->setCommitCallback( onCommitAny, this );
mSnapshotCtrl->setAllowNoTexture ( TRUE );
mSnapshotCtrl->setImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
mSnapshotCtrl->setDnDFilterPermMask(PERM_COPY | PERM_TRANSFER);
mSnapshotCtrl->setNonImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
}
else

1
indra/newview/llpaneleditwearable.cpp
View File

@ -574,6 +574,7 @@ static void init_texture_ctrl(LLPanelEditWearable* self, LLPanel* panel, const L
texture_ctrl->setAllowNoTexture(entry->mAllowNoTexture);
// Don't allow (no copy) or (notransfer) textures to be selected.
texture_ctrl->setImmediateFilterPermMask(PERM_NONE);
texture_ctrl->setDnDFilterPermMask(PERM_NONE);
texture_ctrl->setNonImmediateFilterPermMask(PERM_NONE);
}
}

78
indra/newview/llpanelface.cpp
View File

@ -38,6 +38,7 @@
#include "llfontgl.h"
// project includes
#include "llagentdata.h"
#include "llbutton.h"
#include "llcheckboxctrl.h"
#include "llcolorswatch.h"
@ -46,6 +47,7 @@
#include "llface.h"
#include "lllineeditor.h"
#include "llmediaentry.h"
#include "llnotificationsutil.h"
#include "llresmgr.h"
#include "llselectmgr.h"
#include "llspinctrl.h"
@ -104,27 +106,11 @@ BOOL LLPanelFace::postBuild()
mTextureCtrl->setOnCancelCallback( boost::bind(&LLPanelFace::onCancelTexture, this, _2) );
mTextureCtrl->setOnSelectCallback( boost::bind(&LLPanelFace::onSelectTexture, this, _2) );
mTextureCtrl->setDragCallback(boost::bind(&LLPanelFace::onDragTexture, this, _2));
mTextureCtrl->setOnTextureSelectedCallback(boost::bind(&LLPanelFace::onTextureSelectionChanged, this, _1));
mTextureCtrl->setFollowsTop();
mTextureCtrl->setFollowsLeft();
// Don't allow (no copy) or (no transfer) textures to be selected during immediate mode
mTextureCtrl->setImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
// Allow any texture to be used during non-immediate mode.
mTextureCtrl->setNonImmediateFilterPermMask(PERM_NONE);
LLAggregatePermissions texture_perms;
if (LLSelectMgr::getInstance()->selectGetAggregateTexturePermissions(texture_perms))
{
BOOL can_copy =
texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_EMPTY ||
texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_ALL;
BOOL can_transfer =
texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_EMPTY ||
texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_ALL;
mTextureCtrl->setCanApplyImmediately(can_copy && can_transfer);
}
else
{
mTextureCtrl->setCanApplyImmediately(FALSE);
}
mTextureCtrl->setImmediateFilterPermMask(PERM_NONE);
mTextureCtrl->setDnDFilterPermMask(PERM_COPY | PERM_TRANSFER);
}
mColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
@ -595,28 +581,6 @@ void LLPanelFace::getState()
}
LLAggregatePermissions texture_perms;
if(texture_ctrl)
{
// texture_ctrl->setValid( editable );
if (LLSelectMgr::getInstance()->selectGetAggregateTexturePermissions(texture_perms))
{
BOOL can_copy =
texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_EMPTY ||
texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_ALL;
BOOL can_transfer =
texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_EMPTY ||
texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_ALL;
texture_ctrl->setCanApplyImmediately(can_copy && can_transfer);
}
else
{
texture_ctrl->setCanApplyImmediately(FALSE);
}
}
// planar align
bool align_planar = false;
bool identical_planar_aligned = false;
@ -1190,3 +1154,35 @@ void LLPanelFace::onCommitPlanarAlign(LLUICtrl* ctrl, void* userdata)
self->sendTextureInfo();
}
void LLPanelFace::onTextureSelectionChanged(LLInventoryItem* itemp)
{
LLTextureCtrl* texture_ctrl = getChild<LLTextureCtrl>("texture control");
if (texture_ctrl)
{
LLUUID obj_owner_id;
std::string obj_owner_name;
LLSelectMgr::instance().selectGetOwner(obj_owner_id, obj_owner_name);
LLSaleInfo sale_info;
LLSelectMgr::instance().selectGetSaleInfo(sale_info);
bool can_copy = itemp->getPermissions().allowCopyBy(gAgentID); // do we have perm to copy this texture?
bool can_transfer = itemp->getPermissions().allowOperationBy(PERM_TRANSFER, gAgentID); // do we have perm to transfer this texture?
bool is_object_owner = gAgentID == obj_owner_id; // does object for which we are going to apply texture belong to the agent?
bool not_for_sale = !sale_info.isForSale(); // is object for which we are going to apply texture not for sale?
if (can_copy && can_transfer)
{
texture_ctrl->setCanApply(true, true);
return;
}
// if texture has (no-transfer) attribute it can be applied only for object which we own and is not for sale
texture_ctrl->setCanApply(false, can_transfer ? true : is_object_owner && not_for_sale);
if (gSavedSettings.getBOOL("TextureLivePreview"))
{
LLNotificationsUtil::add("LivePreviewUnavailable");
}
}
}

9
indra/newview/llpanelface.h
View File

@ -91,6 +91,15 @@ protected:
static void onClickAutoFix(void*);
static F32 valueGlow(LLViewerObject* object, S32 face);
private:
/*
* Checks whether the selected texture from the LLFloaterTexturePicker can be applied to the currently selected object.
* If agent selects texture which is not allowed to be applied for the currently selected object,
* all controls of the floater texture picker which allow to apply the texture will be disabled.
*/
void onTextureSelectionChanged(LLInventoryItem* itemp);
};
#endif

1
indra/newview/llpanellandmedia.cpp
View File

@ -85,6 +85,7 @@ BOOL LLPanelLandMedia::postBuild()
mMediaTextureCtrl->setCommitCallback( onCommitAny, this );
mMediaTextureCtrl->setAllowNoTexture ( TRUE );
mMediaTextureCtrl->setImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
mMediaTextureCtrl->setDnDFilterPermMask(PERM_COPY | PERM_TRANSFER);
mMediaTextureCtrl->setNonImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
mMediaAutoScaleCheck = getChild<LLCheckBoxCtrl>("media_auto_scale");

1
indra/newview/llpanelobject.cpp
View File

@ -245,6 +245,7 @@ BOOL LLPanelObject::postBuild()
mCtrlSculptTexture->setDropCallback( boost::bind(&LLPanelObject::onDropSculpt, this, _2 ));
// Don't allow (no copy) or (no transfer) textures to be selected during immediate mode
mCtrlSculptTexture->setImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
mCtrlSculptTexture->setDnDFilterPermMask(PERM_COPY | PERM_TRANSFER);
// Allow any texture to be used during non-immediate mode.
mCtrlSculptTexture->setNonImmediateFilterPermMask(PERM_NONE);
LLAggregatePermissions texture_perms;

57
indra/newview/llselectmgr.cpp
View File

@ -1508,6 +1508,49 @@ struct LLSelectMgrSendFunctor : public LLSelectedObjectFunctor
}
};
void LLObjectSelection::applyNoCopyTextureToTEs(LLViewerInventoryItem* item)
{
if (!item)
{
return;
}
LLViewerTexture* image = LLViewerTextureManager::getFetchedTexture(item->getAssetUUID());
for (iterator iter = begin(); iter != end(); ++iter)
{
LLSelectNode* node = *iter;
LLViewerObject* object = (*iter)->getObject();
if (!object)
{
continue;
}
S32 num_tes = llmin((S32)object->getNumTEs(), (S32)object->getNumFaces());
bool texture_copied = false;
for (S32 te = 0; te < num_tes; ++te)
{
if (node->isTESelected(te))
{
//(no-copy) textures must be moved to the object's inventory only once
// without making any copies
if (!texture_copied)
{
LLToolDragAndDrop::handleDropTextureProtections(object, item, LLToolDragAndDrop::SOURCE_AGENT, LLUUID::null);
texture_copied = true;
}
// apply texture for the selected faces
LLViewerStats::getInstance()->incStat(LLViewerStats::ST_EDIT_TEXTURE_COUNT );
object->setTEImage(te, image);
dialog_refresh_all();
// send the update to the simulator
object->sendTEUpdate();
}
}
}
}
//-----------------------------------------------------------------------------
// selectionSetImage()
//-----------------------------------------------------------------------------
@ -1559,8 +1602,18 @@ void LLSelectMgr::selectionSetImage(const LLUUID& imageid)
}
return true;
}
} setfunc(item, imageid);
getSelection()->applyToTEs(&setfunc);
};
if (item && !item->getPermissions().allowOperationBy(PERM_COPY, gAgent.getID()))
{
getSelection()->applyNoCopyTextureToTEs(item);
}
else
{
f setfunc(item, imageid);
getSelection()->applyToTEs(&setfunc);
}
struct g : public LLSelectedObjectFunctor
{

9
indra/newview/llselectmgr.h
View File

@ -307,6 +307,15 @@ public:
bool applyToRootNodes(LLSelectedNodeFunctor* func, bool firstonly = false);
bool applyToNodes(LLSelectedNodeFunctor* func, bool firstonly = false);
/*
* Used to apply (no-copy) textures to the selected object or
* selected face/faces of the object.
* This method moves (no-copy) texture to the object's inventory
* and doesn't make copy of the texture for each face.
* Then this only texture is used for all selected faces.
*/
void applyNoCopyTextureToTEs(LLViewerInventoryItem* item);
ESelectType getSelectType() const { return mSelectType; }
private:

68
indra/newview/lltexturectrl.cpp
View File

@ -92,6 +92,7 @@ public:
LLTextureCtrl* owner,
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);
@ -129,6 +130,9 @@ public:
void onFilterEdit(const std::string& search_string );
void setCanApply(bool can_preview, bool can_apply);
void setTextureSelectedCallback(texture_selected_callback cb) {mTextureSelectedCallback = cb;}
static void onBtnSetToDefault( void* userdata );
static void onBtnSelect( void* userdata );
static void onBtnCancel( void* userdata );
@ -164,6 +168,7 @@ protected:
LLFilterEditor* mFilterEdit;
LLInventoryPanel* mInventoryPanel;
PermissionMask mImmediateFilterPermMask;
PermissionMask mDnDFilterPermMask;
PermissionMask mNonImmediateFilterPermMask;
BOOL mCanApplyImmediately;
BOOL mNoCopyTextureSelected;
@ -171,12 +176,18 @@ protected:
LLSaveFolderState mSavedFolderState;
BOOL mSelectedItemPinned;
private:
bool mCanApply;
bool mCanPreview;
texture_selected_callback mTextureSelectedCallback;
};
LLFloaterTexturePicker::LLFloaterTexturePicker(
LLTextureCtrl* owner,
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)
@ -192,9 +203,12 @@ LLFloaterTexturePicker::LLFloaterTexturePicker(
mActive( TRUE ),
mFilterEdit(NULL),
mImmediateFilterPermMask(immediate_filter_perm_mask),
mDnDFilterPermMask(dnd_filter_perm_mask),
mNonImmediateFilterPermMask(non_immediate_filter_perm_mask),
mContextConeOpacity(0.f),
mSelectedItemPinned( FALSE )
mSelectedItemPinned( FALSE ),
mCanApply(true),
mCanPreview(true)
{
buildFromFile("floater_texture_ctrl.xml");
mCanApplyImmediately = can_apply_immediately;
@ -306,7 +320,7 @@ BOOL LLFloaterTexturePicker::handleDragAndDrop(
if (xfer) item_perm_mask |= PERM_TRANSFER;
//PermissionMask filter_perm_mask = getFilterPermMask(); Commented out due to no-copy texture loss.
PermissionMask filter_perm_mask = mImmediateFilterPermMask;
PermissionMask filter_perm_mask = mDnDFilterPermMask;
if ( (item_perm_mask & filter_perm_mask) == filter_perm_mask )
{
if (drop)
@ -440,7 +454,7 @@ BOOL LLFloaterTexturePicker::postBuild()
mNoCopyTextureSelected = FALSE;
getChild<LLUICtrl>("apply_immediate_check")->setValue(gSavedSettings.getBOOL("ApplyTextureImmediately"));
getChild<LLUICtrl>("apply_immediate_check")->setValue(gSavedSettings.getBOOL("TextureLivePreview"));
childSetCommitCallback("apply_immediate_check", onApplyImmediateCheck, this);
if (!mCanApplyImmediately)
@ -523,7 +537,7 @@ void LLFloaterTexturePicker::draw()
// if we're inactive, gray out "apply immediate" checkbox
getChildView("show_folders_check")->setEnabled(mActive && mCanApplyImmediately && !mNoCopyTextureSelected);
getChildView("Select")->setEnabled(mActive);
getChildView("Select")->setEnabled(mActive && mCanApply);
getChildView("Pipette")->setEnabled(mActive);
getChild<LLUICtrl>("Pipette")->setValue(LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance());
@ -682,8 +696,7 @@ PermissionMask LLFloaterTexturePicker::getFilterPermMask()
void LLFloaterTexturePicker::commitIfImmediateSet()
{
bool apply_immediate = getChild<LLUICtrl>("apply_immediate_check")->getValue().asBoolean();
if (!mNoCopyTextureSelected && apply_immediate && mOwner)
if (!mNoCopyTextureSelected && mOwner && mCanApply)
{
mOwner->onFloaterCommit(LLTextureCtrl::TEXTURE_CHANGE);
}
@ -693,6 +706,7 @@ void LLFloaterTexturePicker::commitIfImmediateSet()
void LLFloaterTexturePicker::onBtnSetToDefault(void* userdata)
{
LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
self->setCanApply(true, true);
if (self->mOwner)
{
self->setImageID( self->mOwner->getDefaultImageAssetID() );
@ -704,6 +718,7 @@ void LLFloaterTexturePicker::onBtnSetToDefault(void* userdata)
void LLFloaterTexturePicker::onBtnWhite(void* userdata)
{
LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
self->setCanApply(true, true);
self->setImageID( self->mWhiteImageAssetID );
self->commitIfImmediateSet();
}
@ -776,13 +791,14 @@ void LLFloaterTexturePicker::onSelectionChange(const std::deque<LLFolderViewItem
mNoCopyTextureSelected = FALSE;
if (itemp)
{
mTextureSelectedCallback(itemp);
if (!itemp->getPermissions().allowCopyBy(gAgent.getID()))
{
mNoCopyTextureSelected = TRUE;
}
mImageAssetID = itemp->getAssetUUID();
mViewModel->setDirty(); // *TODO: shouldn't we be using setValue() here?
if (user_action)
if (user_action && mCanPreview)
{
// only commit intentional selections, not implicit ones
commitIfImmediateSet();
@ -813,7 +829,7 @@ void LLFloaterTexturePicker::onApplyImmediateCheck(LLUICtrl* ctrl, void *user_da
LLFloaterTexturePicker* picker = (LLFloaterTexturePicker*)user_data;
LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
gSavedSettings.setBOOL("ApplyTextureImmediately", check_box->get());
gSavedSettings.setBOOL("TextureLivePreview", check_box->get());
picker->updateFilterPermMask();
picker->commitIfImmediateSet();
@ -824,6 +840,16 @@ void LLFloaterTexturePicker::updateFilterPermMask()
//mInventoryPanel->setFilterPermMask( getFilterPermMask() ); Commented out due to no-copy texture loss.
}
void LLFloaterTexturePicker::setCanApply(bool can_preview, bool can_apply)
{
getChildRef<LLUICtrl>("Select").setEnabled(can_apply);
getChildRef<LLUICtrl>("preview_disabled").setVisible(!can_preview);
getChildRef<LLUICtrl>("apply_immediate_check").setVisible(can_preview);
mCanApply = can_apply;
mCanPreview = can_preview ? gSavedSettings.getBOOL("TextureLivePreview") : false;
}
void LLFloaterTexturePicker::onFilterEdit(const std::string& search_string )
{
std::string upper_case_search_string = search_string;
@ -974,6 +1000,15 @@ void LLTextureCtrl::setCanApplyImmediately(BOOL b)
}
}
void LLTextureCtrl::setCanApply(bool can_preview, bool can_apply)
{
LLFloaterTexturePicker* floaterp = dynamic_cast<LLFloaterTexturePicker*>(mFloaterHandle.get());
if( floaterp )
{
floaterp->setCanApply(can_preview, can_apply);
}
}
void LLTextureCtrl::setVisible( BOOL visible )
{
if( !visible )
@ -1054,12 +1089,19 @@ void LLTextureCtrl::showPicker(BOOL take_focus)
this,
mLabel,
mImmediateFilterPermMask,
mDnDFilterPermMask,
mNonImmediateFilterPermMask,
mCanApplyImmediately,
mFallbackImage);
mFloaterHandle = floaterp->getHandle();
LLFloaterTexturePicker* texture_floaterp = dynamic_cast<LLFloaterTexturePicker*>(floaterp);
if (texture_floaterp && mOnTextureSelectedCallback)
{
texture_floaterp->setTextureSelectedCallback(mOnTextureSelectedCallback);
}
LLFloater* root_floater = gFloaterView->getParentFloater(this);
if (root_floater)
root_floater->addDependentFloater(floaterp);
@ -1174,6 +1216,16 @@ void LLTextureCtrl::onFloaterCommit(ETexturePickOp op)
}
}
void LLTextureCtrl::setOnTextureSelectedCallback(texture_selected_callback cb)
{
mOnTextureSelectedCallback = cb;
LLFloaterTexturePicker* floaterp = dynamic_cast<LLFloaterTexturePicker*>(mFloaterHandle.get());
if (floaterp)
{
floaterp->setTextureSelectedCallback(cb);
}
}
void LLTextureCtrl::setImageAssetName(const std::string& name)
{
LLPointer<LLUIImage> imagep = LLUI::getUIImage(name);

12
indra/newview/lltexturectrl.h
View File

@ -43,6 +43,7 @@ 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;
//////////////////////////////////////////////////////////////////////////////////////////
@ -147,8 +148,12 @@ public:
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; }
@ -172,6 +177,11 @@ public:
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; }
@ -185,6 +195,7 @@ private:
drag_n_drop_callback mDropCallback;
commit_callback_t mOnCancelCallback;
commit_callback_t mOnSelectCallback;
texture_selected_callback mOnTextureSelectedCallback;
LLPointer<LLViewerFetchedTexture> mTexturep;
LLUIColor mBorderColor;
LLUUID mImageItemID;
@ -198,6 +209,7 @@ private:
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;

14
indra/newview/lltooldraganddrop.h
View File

@ -93,6 +93,13 @@ public:
static S32 getOperationId() { return sOperationId; }
// deal with permissions of object, etc. returns TRUE if drop can
// proceed, otherwise FALSE.
static BOOL handleDropTextureProtections(LLViewerObject* hit_obj,
LLInventoryItem* item,
LLToolDragAndDrop::ESource source,
const LLUUID& src_id);
protected:
enum EDropTarget
{
@ -219,13 +226,6 @@ protected:
// inventory items to determine if a drop would be ok.
static EAcceptance willObjectAcceptInventory(LLViewerObject* obj, LLInventoryItem* item);
// deal with permissions of object, etc. returns TRUE if drop can
// proceed, otherwise FALSE.
static BOOL handleDropTextureProtections(LLViewerObject* hit_obj,
LLInventoryItem* item,
LLToolDragAndDrop::ESource source,
const LLUUID& src_id);
public:
// helper functions
static BOOL isInventoryDropAcceptable(LLViewerObject* obj, LLInventoryItem* item) { return (ACCEPT_YES_COPY_SINGLE <= willObjectAcceptInventory(obj, item)); }

34
indra/newview/llviewerobject.cpp
View File

@ -2793,6 +2793,23 @@ void LLViewerObject::processTaskInvFile(void** user_data, S32 error_code, LLExtS
(object = gObjectList.findObject(ft->mTaskID)))
{
object->loadTaskInvFile(ft->mFilename);
LLInventoryObject::object_list_t::iterator it = object->mInventory->begin();
LLInventoryObject::object_list_t::iterator end = object->mInventory->end();
std::list<LLUUID>& pending_lst = object->mPendingInventoryItemsIDs;
for (; it != end && pending_lst.size(); ++it)
{
LLViewerInventoryItem* item = dynamic_cast<LLViewerInventoryItem*>(it->get());
if(item && item->getType() != LLAssetType::AT_CATEGORY)
{
std::list<LLUUID>::iterator id_it = std::find(pending_lst.begin(), pending_lst.begin(), item->getAssetUUID());
if (id_it != pending_lst.end())
{
pending_lst.erase(id_it);
}
}
}
}
else
{
@ -2905,7 +2922,22 @@ void LLViewerObject::updateInventory(
bool is_new)
{
LLMemType mt(LLMemType::MTYPE_OBJECT);
std::list<LLUUID>::iterator begin = mPendingInventoryItemsIDs.begin();
std::list<LLUUID>::iterator end = mPendingInventoryItemsIDs.end();
bool is_fetching = std::find(begin, end, item->getAssetUUID()) != end;
bool is_fetched = getInventoryItemByAsset(item->getAssetUUID()) != NULL;
if (is_fetched || is_fetching)
{
return;
}
else
{
mPendingInventoryItemsIDs.push_back(item->getAssetUUID());
}
// This slices the object into what we're concerned about on the
// viewer. The simulator will take the permissions and transfer
// ownership.

4
indra/newview/llviewerobject.h
View File

@ -684,6 +684,10 @@ protected:
F32 mAppAngle; // Apparent visual arc in degrees
F32 mPixelArea; // Apparent area in pixels
// IDs of of all items in the object's content which are added to the object's content,
// but not updated on the server yet. After item was updated, its ID will be removed from this list.
std::list<LLUUID> mPendingInventoryItemsIDs;
// This is the object's inventory from the viewer's perspective.
LLInventoryObject::object_list_t* mInventory;
class LLInventoryCallbackInfo

12
indra/newview/skins/default/xui/en/floater_texture_ctrl.xml
View File

@ -92,12 +92,22 @@
follows="left|bottom"
height="20"
initial_value="true"
label="Apply now"
label="Live Preview"
layout="topleft"
left="4"
name="apply_immediate_check"
top="262"
width="120" />
<text
follows="left|bottom"
height="20"
layout="topleft"
left="8"
name="preview_disabled"
top="266"
value="Preview Disabled"
visible="false"
width="120" />
<filter_editor
follows="left|top|right"
height="23"

12
indra/newview/skins/default/xui/en/notifications.xml
View File

@ -7198,6 +7198,18 @@ You uploaded a [RESOLUTION] baked texture for '[BODYREGION]' after [TIME] second
You locally updated a [RESOLUTION] baked texture for '[BODYREGION]' after [TIME] seconds.
</notification>
<notification
icon="alertmodal.tga"
name="LivePreviewUnavailable"
type="alert">
We cannot display a preview of this texture because it is no-copy and/or no-transfer.
<usetemplate
ignoretext="Warn me that Live Preview mode is not available for no-copy and/or no-transfer textures"
name="okignore"
yestext="OK"/>
</notification>
<notification
icon="alertmodal.tga"
name="ConfirmLeaveCall"