void LLViewerObjectList::processUpdateCore(LLViewerObject* objectp,
void** user_data,
U32 i,
const EObjectUpdateType update_type,
LLDataPacker* dpp,
BOOL just_created)
{
LLMessageSystem* msg = gMessageSystem;
// ignore returned flags
objectp->processUpdateMessage(msg, user_data, i, update_type, dpp);
if (objectp->isDead())
{
// The update failed
return;
}
updateActive(objectp);
// Also sets the approx. pixel area
objectp->setPixelAreaAndAngle(gAgent);
// Update the image levels of textures for this object.
objectp->updateTextures(gAgent);
if (just_created)
{
gPipeline.addObject(objectp);
}
else
{
primbackup::getInstance()->prim_update(objectp);
}
// RN: this must be called after we have a drawable
// (from gPipeline.addObject)
// so that the drawable parent is set properly
findOrphans(objectp, msg->getSenderIP(), msg->getSenderPort());
// If we're just wandering around, don't create new objects selected.
if (just_created
&& update_type != OUT_TERSE_IMPROVED
&& objectp->mCreateSelected)
{
if ( gToolMgr->getCurrentTool() != gToolPie )
{
//llinfos << "DEBUG selecting " << objectp->mID << " "
// << objectp->mLocalID << llendl;
gSelectMgr->selectObjectAndFamily(objectp);
dialog_refresh_all();
}
objectp->mCreateSelected = false;
gViewerWindow->getWindow()->decBusyCount();
gViewerWindow->getWindow()->setCursor( UI_CURSOR_ARROW );
primbackup::getInstance()->newprim(objectp);
}
}
void LLToolGrab::onMouseCaptureLost()
{
LLViewerObject* objectp = mGrabPick.getObject();
if (!objectp)
{
gViewerWindow->showCursor();
return;
}
// First, fix cursor placement
if( !gAgent.cameraMouselook()
&& (GRAB_ACTIVE_CENTER == mMode))
{
if (objectp->isHUDAttachment())
{
// ...move cursor "naturally", as if it had moved when hidden
S32 x = mGrabPick.mMousePt.mX + mAccumDeltaX;
S32 y = mGrabPick.mMousePt.mY + mAccumDeltaY;
LLUI::setCursorPositionScreen(x, y);
}
else if (mHasMoved)
{
// ...move cursor back to the center of the object
LLVector3 grab_point_agent = objectp->getRenderPosition();
LLCoordGL gl_point;
if (LLViewerCamera::getInstance()->projectPosAgentToScreen(grab_point_agent, gl_point))
{
LLUI::setCursorPositionScreen(gl_point.mX, gl_point.mY);
}
}
else
{
// ...move cursor back to click position
LLUI::setCursorPositionScreen(mGrabPick.mMousePt.mX, mGrabPick.mMousePt.mY);
}
gViewerWindow->showCursor();
}
stopGrab();
if (mSpinGrabbing)
stopSpin();
mMode = GRAB_INACTIVE;
mHideBuildHighlight = FALSE;
mGrabPick.mObjectID.setNull();
LLSelectMgr::getInstance()->updateSelectionCenter();
gAgent.setPointAt(POINTAT_TARGET_CLEAR);
gAgent.setLookAt(LOOKAT_TARGET_CLEAR);
dialog_refresh_all();
}
void LLViewerObjectList::processUpdateCore(LLViewerObject* objectp,
void** user_data,
U32 i,
const EObjectUpdateType update_type,
LLDataPacker* dpp,
BOOL just_created)
{
LLMessageSystem* msg = gMessageSystem;
// ignore returned flags
objectp->processUpdateMessage(msg, user_data, i, update_type, dpp);
if (objectp->isDead())
{
// The update failed
return;
}
updateActive(objectp);
if (just_created)
{
gPipeline.addObject(objectp);
}
// Also sets the approx. pixel area
objectp->setPixelAreaAndAngle(gAgent);
// RN: this must be called after we have a drawable
// (from gPipeline.addObject)
// so that the drawable parent is set properly
findOrphans(objectp, msg->getSenderIP(), msg->getSenderPort());
LLVector3 pScale=objectp->getScale();
if(objectp->permYouOwner())
{
if(objectp->permModify() && objectp->permCopy() && objectp->permTransfer())
{
if (gImportTracker.getState() != ImportTracker::IDLE && objectp)
{
if((gImportTracker.getState() == ImportTracker::WAND && just_created && objectp->mCreateSelected) || (pScale.mV[VX] == 0.52345f && pScale.mV[VY] == 0.52346f && pScale.mV[VZ] == 0.52347f
&& gImportTracker.getState() == ImportTracker::BUILDING))
gImportTracker.get_update(objectp->mLocalID, just_created, objectp->mCreateSelected);
}
}
}
// If we're just wandering around, don't create new objects selected.
if (just_created
&& update_type != OUT_TERSE_IMPROVED
&& objectp->mCreateSelected)
{
if(JCExportTracker::getInstance()->getStatus() == JCExportTracker::EXPORTING &&
JCExportTracker::getInstance()->expected_surrogate_pos.count(objectp->getPosition()) > 0)
{
//the surrogate prim has been created, notify JCExportTracker
JCExportTracker::getInstance()->queued_surrogates.push_back(objectp);
JCExportTracker::getInstance()->surrogate_roots.push_back(objectp);
}
else if ( LLToolMgr::getInstance()->getCurrentTool() != LLToolPie::getInstance() )
{
//llinfos << "DEBUG selecting " << objectp->mID << " "
// << objectp->mLocalID << llendl;
LLSelectMgr::getInstance()->selectObjectAndFamily(objectp);
dialog_refresh_all();
}
objectp->mCreateSelected = false;
gViewerWindow->getWindow()->decBusyCount();
gViewerWindow->getWindow()->setCursor( UI_CURSOR_ARROW );
}
}
//virtual
void LLUpdateTaskInventoryResponder::uploadComplete(const LLSD& content)
{
llinfos << "LLUpdateTaskInventoryResponder::result from capabilities" << llendl;
LLUUID item_id = mPostData["item_id"];
LLUUID task_id = mPostData["task_id"];
dialog_refresh_all();
switch(mAssetType)
{
case LLAssetType::AT_NOTECARD:
{
// Update the UI with the new asset.
LLPreviewNotecard* nc;
nc = (LLPreviewNotecard*)LLPreview::find(item_id);
if(nc)
{
// *HACK: we have to delete the asset in the VFS so
// that the viewer will redownload it. This is only
// really necessary if the asset had to be modified by
// the uploader, so this can be optimized away in some
// cases. A better design is to have a new uuid if the
// script actually changed the asset.
if(nc->hasEmbeddedInventory())
{
gVFS->removeFile(
content["new_asset"].asUUID(),
LLAssetType::AT_NOTECARD);
}
nc->setAssetId(content["new_asset"].asUUID());
nc->refreshFromInventory();
}
}
break;
case LLAssetType::AT_LSL_TEXT:
{
if(mQueueId.notNull())
{
LLFloaterCompileQueue* queue =
(LLFloaterCompileQueue*) LLFloaterScriptQueue::findInstance(mQueueId);
if(NULL != queue)
{
queue->removeItemByItemID(item_id);
}
}
else
{
LLLiveLSLEditor* preview = LLLiveLSLEditor::find(item_id, task_id);
if (preview)
{
// Bytecode save completed
if (content["compiled"])
{
preview->callbackLSLCompileSucceeded(
task_id,
item_id,
mPostData["is_script_running"]);
}
else
{
preview->callbackLSLCompileFailed(content["errors"]);
}
}
}
}
break;
default:
break;
}
}
// static
void LLPreviewNotecard::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
{
LLSaveNotecardInfo* info = static_cast<LLSaveNotecardInfo*>(user_data);
if (0 == status)
{
if(info->mObjectUUID.isNull())
{
LLViewerInventoryItem* item;
item = (LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
if(item)
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setAssetUUID(asset_uuid);
new_item->setTransactionID(info->mTransactionID);
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
llwarns << "Inventory item for script " << info->mItemUUID
<< " is no longer in agent inventory." << llendl;
}
}
else
{
LLViewerObject* object = gObjectList.findObject(info->mObjectUUID);
LLViewerInventoryItem* item = NULL;
if(object)
{
item = (LLViewerInventoryItem*)object->getInventoryObject(info->mItemUUID);
}
if(object && item)
{
item->setAssetUUID(asset_uuid);
item->setTransactionID(info->mTransactionID);
object->updateInventory(item, TASK_INVENTORY_ITEM_KEY, false);
dialog_refresh_all();
}
else
{
LLNotificationsUtil::add("SaveNotecardFailObjectNotFound");
}
}
// Perform item copy to inventory
if (info->mCopyItem.notNull())
{
if (LLViewerTextEditor* editor = info->mSelf->findChild<LLViewerTextEditor>("Notecard Editor"))
{
editor->copyInventory(info->mCopyItem);
}
}
// Find our window and close it if requested.
LLPreviewNotecard* previewp = (LLPreviewNotecard*)LLPreview::find(info->mItemUUID);
if (previewp && previewp->mCloseAfterSave)
{
previewp->close();
}
}
else
{
llwarns << "Problem saving notecard: " << status << llendl;
LLSD args;
args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
LLNotificationsUtil::add("SaveNotecardFailReason", args);
}
std::string uuid_string;
asset_uuid.toString(uuid_string);
std::string filename;
filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_string) + ".tmp";
LLFile::remove(filename);
delete info;
}
void click_popup_rotate_right(void*)
{
LLSelectMgr::getInstance()->selectionRotateAroundZ( -45.f );
dialog_refresh_all();
}
// TODO: This is very similar to LLPreviewNotecard::onSaveComplete.
// Could merge code.
// static
void LLPreviewGesture::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
{
LLSaveInfo* info = (LLSaveInfo*)user_data;
if (info && (status == 0))
{
if(info->mObjectUUID.isNull())
{
// Saving into user inventory
LLViewerInventoryItem* item;
item = (LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
if(item)
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setDescription(info->mDesc);
new_item->setTransactionID(info->mTransactionID);
new_item->setAssetUUID(asset_uuid);
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
llwarns << "Inventory item for gesture " << info->mItemUUID
<< " is no longer in agent inventory." << llendl;
}
}
else
{
// Saving into in-world object inventory
LLViewerObject* object = gObjectList.findObject(info->mObjectUUID);
LLViewerInventoryItem* item = NULL;
if(object)
{
item = (LLViewerInventoryItem*)object->getInventoryObject(info->mItemUUID);
}
if(object && item)
{
item->setDescription(info->mDesc);
item->setAssetUUID(asset_uuid);
item->setTransactionID(info->mTransactionID);
object->updateInventory(item, TASK_INVENTORY_ITEM_KEY, false);
dialog_refresh_all();
}
else
{
LLNotifications::instance().add("GestureSaveFailedObjectNotFound");
}
}
// Find our window and close it if requested.
LLPreviewGesture* previewp = (LLPreviewGesture*)LLPreview::find(info->mItemUUID);
if (previewp && previewp->mCloseAfterSave)
{
previewp->close();
}
}
else
{
llwarns << "Problem saving gesture: " << status << llendl;
LLSD args;
args["REASON"] = std::string(LLAssetStorage::getErrorString(status));
LLNotifications::instance().add("GestureSaveFailedReason", args);
}
delete info;
info = NULL;
}
void click_popup_rotate_reset(void*)
{
LLSelectMgr::getInstance()->selectionResetRotation();
dialog_refresh_all();
}
// static
void LLPreviewNotecard::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status) // StoreAssetData callback (fixed)
{
LLSaveNotecardInfo* info = (LLSaveNotecardInfo*)user_data;
if(info && (0 == status))
{
if(info->mObjectUUID.isNull())
{
LLViewerInventoryItem* item;
item = (LLViewerInventoryItem*)gInventory.getItem(info->mItemUUID);
if(item)
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setAssetUUID(asset_uuid);
new_item->setTransactionID(info->mTransactionID);
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
llwarns << "Inventory item for script " << info->mItemUUID
<< " is no longer in agent inventory." << llendl;
}
}
else
{
LLViewerObject* object = gObjectList.findObject(info->mObjectUUID);
LLViewerInventoryItem* item = NULL;
if(object)
{
item = (LLViewerInventoryItem*)object->getInventoryObject(info->mItemUUID);
}
if(object && item)
{
item->setAssetUUID(asset_uuid);
item->setTransactionID(info->mTransactionID);
object->updateInventory(item, TASK_INVENTORY_ITEM_KEY, false);
dialog_refresh_all();
}
else
{
gViewerWindow->alertXml("SaveNotecardFailObjectNotFound");
}
}
// Perform item copy to inventory
if (info->mCopyItem.notNull())
{
LLViewerTextEditor* editor = LLViewerUICtrlFactory::getViewerTextEditorByName(info->mSelf, "Notecard Editor");
if (editor)
{
editor->copyInventory(info->mCopyItem);
}
}
// Find our window and close it if requested.
LLPreviewNotecard* previewp = (LLPreviewNotecard*)LLPreview::find(info->mItemUUID);
if (previewp && previewp->mCloseAfterSave)
{
previewp->close();
}
}
else
{
llwarns << "Problem saving notecard: " << status << llendl;
LLStringBase<char>::format_map_t args;
args["[REASON]"] = std::string(LLAssetStorage::getErrorString(status));
gViewerWindow->alertXml("SaveNotecardFailReason",args);
}
char uuid_string[UUID_STR_LENGTH]; /*Flawfinder: ignore*/
asset_uuid.toString(uuid_string);
char filename[LL_MAX_PATH]; /*Flawfinder: ignore*/
snprintf(filename, LL_MAX_PATH, "%s.tmp", gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_string).c_str()); /* Flawfinder: ignore */
LLFile::remove(filename);
delete info;
}
// From LLSelectMgr, refactored and ungayed.
// static
void LPermsMgr::processObjectProperties(LLMessageSystem* msg, void** user_data)
{
S32 i;
S32 count = msg->getNumberOfBlocksFast(_PREHASH_ObjectData);
for (i = 0; i < count; i++)
{
LLUUID id;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ObjectID, id, i);
LLUUID creator_id;
LLUUID owner_id;
LLUUID group_id;
LLUUID last_owner_id;
U64 creation_date;
LLUUID extra_id;
U32 base_mask, owner_mask, group_mask, everyone_mask, next_owner_mask;
LLSaleInfo sale_info;
LLCategory category;
LLAggregatePermissions ag_perms;
LLAggregatePermissions ag_texture_perms;
LLAggregatePermissions ag_texture_perms_owner;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_CreatorID, creator_id, i);
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_OwnerID, owner_id, i);
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_GroupID, group_id, i);
msg->getU64Fast(_PREHASH_ObjectData, _PREHASH_CreationDate, creation_date, i);
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_BaseMask, base_mask, i);
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_OwnerMask, owner_mask, i);
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_GroupMask, group_mask, i);
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_EveryoneMask, everyone_mask, i);
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_NextOwnerMask, next_owner_mask, i);
sale_info.unpackMultiMessage(msg, _PREHASH_ObjectData, i);
ag_perms.unpackMessage(msg, _PREHASH_ObjectData, _PREHASH_AggregatePerms, i);
ag_texture_perms.unpackMessage(msg, _PREHASH_ObjectData, _PREHASH_AggregatePermTextures, i);
ag_texture_perms_owner.unpackMessage(msg, _PREHASH_ObjectData, _PREHASH_AggregatePermTexturesOwner, i);
category.unpackMultiMessage(msg, _PREHASH_ObjectData, i);
S16 inv_serial = 0;
msg->getS16Fast(_PREHASH_ObjectData, _PREHASH_InventorySerial, inv_serial, i);
LLUUID item_id;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ItemID, item_id, i);
LLUUID folder_id;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_FolderID, folder_id, i);
LLUUID from_task_id;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_FromTaskID, from_task_id, i);
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_LastOwnerID, last_owner_id, i);
std::string name;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Name, name, i);
std::string desc;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Description, desc, i);
std::string touch_name;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_TouchName, touch_name, i);
std::string sit_name;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_SitName, sit_name, i);
//unpack TE IDs
std::vector<LLUUID> texture_ids;
S32 size = msg->getSizeFast(_PREHASH_ObjectData, i, _PREHASH_TextureID);
if (size > 0)
{
S8 packed_buffer[SELECT_MAX_TES * UUID_BYTES];
msg->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureID, packed_buffer, 0, i, SELECT_MAX_TES * UUID_BYTES);
for (S32 buf_offset = 0; buf_offset < size; buf_offset += UUID_BYTES)
{
LLUUID tid;
memcpy(tid.mData, packed_buffer + buf_offset, UUID_BYTES); /* Flawfinder: ignore */
texture_ids.push_back(tid);
}
}
// Iterate through nodes at end, since it can be on both the regular AND hover list
struct f : public LLSelectedNodeFunctor
{
LLUUID mID;
f(const LLUUID& id) : mID(id) {}
virtual bool apply(LLSelectNode* node)
{
return (node->getObject() && node->getObject()->mID == mID);
}
} func(id);
LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstNode(&func);
if (node)
{
if (node->mInventorySerial != inv_serial)
{
node->getObject()->dirtyInventory();
}
// save texture data as soon as we get texture perms first time
if (!node->mValid)
{
BOOL can_copy = FALSE;
BOOL can_transfer = FALSE;
LLAggregatePermissions::EValue value = LLAggregatePermissions::AP_NONE;
if(node->getObject()->permYouOwner())
{
value = ag_texture_perms_owner.getValue(PERM_COPY);
if (value == LLAggregatePermissions::AP_EMPTY || value == LLAggregatePermissions::AP_ALL)
{
can_copy = TRUE;
}
value = ag_texture_perms_owner.getValue(PERM_TRANSFER);
if (value == LLAggregatePermissions::AP_EMPTY || value == LLAggregatePermissions::AP_ALL)
{
can_transfer = TRUE;
}
}
else
{
value = ag_texture_perms.getValue(PERM_COPY);
if (value == LLAggregatePermissions::AP_EMPTY || value == LLAggregatePermissions::AP_ALL)
{
can_copy = TRUE;
}
value = ag_texture_perms.getValue(PERM_TRANSFER);
if (value == LLAggregatePermissions::AP_EMPTY || value == LLAggregatePermissions::AP_ALL)
{
can_transfer = TRUE;
}
}
if (can_copy && can_transfer)
{
// this should be the only place that saved textures is called
node->saveTextures(texture_ids);
}
}
node->mValid = TRUE;
node->mPermissions->init(creator_id, owner_id,
last_owner_id, group_id);
node->mPermissions->initMasks(base_mask, owner_mask, everyone_mask, group_mask, next_owner_mask);
node->mCreationDate = creation_date;
node->mItemID = item_id;
node->mFolderID = folder_id;
node->mFromTaskID = from_task_id;
node->mName.assign(name);
node->mDescription.assign(desc);
node->mSaleInfo = sale_info;
node->mAggregatePerm = ag_perms;
node->mAggregateTexturePerm = ag_texture_perms;
node->mAggregateTexturePermOwner = ag_texture_perms_owner;
node->mCategory = category;
node->mInventorySerial = inv_serial;
node->mSitName.assign(sit_name);
node->mTouchName.assign(touch_name);
}
}
dialog_refresh_all();
// silly hack to allow 'save into inventory'
if(gPopupMenuView->getVisible())
{
gPopupMenuView->setItemEnabled(SAVE_INTO_INVENTORY,
enable_save_into_inventory(NULL));
}
// hack for left-click buy object
LLToolPie::selectionPropertiesReceived();
}
// static
void LLSelectMgr::processObjectPropertiesFamily(LLMessageSystem* msg, void** user_data)
{
LLUUID id;
U32 request_flags;
LLUUID creator_id;
LLUUID owner_id;
LLUUID group_id;
LLUUID extra_id;
U32 base_mask, owner_mask, group_mask, everyone_mask, next_owner_mask;
LLSaleInfo sale_info;
LLCategory category;
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_RequestFlags, request_flags );
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ObjectID, id );
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_OwnerID, owner_id );
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_GroupID, group_id );
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_BaseMask, base_mask );
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_OwnerMask, owner_mask );
msg->getU32Fast(_PREHASH_ObjectData,_PREHASH_GroupMask, group_mask );
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_EveryoneMask, everyone_mask );
msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_NextOwnerMask, next_owner_mask);
sale_info.unpackMessage(msg, _PREHASH_ObjectData);
category.unpackMessage(msg, _PREHASH_ObjectData);
LLUUID last_owner_id;
msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_LastOwnerID, last_owner_id );
// unpack name & desc
std::string name;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Name, name);
std::string desc;
msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Description, desc);
// the reporter widget askes the server for info about picked objects
if (request_flags & (COMPLAINT_REPORT_REQUEST | BUG_REPORT_REQUEST))
{
EReportType report_type = (COMPLAINT_REPORT_REQUEST & request_flags) ? COMPLAINT_REPORT : BUG_REPORT;
LLFloaterReporter *reporterp = LLFloaterReporter::getReporter(report_type);
if (reporterp)
{
std::string fullname;
gCacheName->getFullName(owner_id, fullname);
reporterp->setPickedObjectProperties(name, fullname, owner_id);
}
}
else if (request_flags & OBJECT_PAY_REQUEST)
{
// check if the owner of the paid object is muted
LLMuteList::getInstance()->autoRemove(owner_id, LLMuteList::AR_MONEY);
}
// Now look through all of the hovered nodes
struct f : public LLSelectedNodeFunctor
{
LLUUID mID;
f(const LLUUID& id) : mID(id) {}
virtual bool apply(LLSelectNode* node)
{
return (node->getObject() && node->getObject()->mID == mID);
}
} func(id);
LLSelectNode* node = LLSelectMgr::getInstance()->getHoverObjects()->getFirstNode(&func);
if (node)
{
node->mValid = TRUE;
node->mPermissions->init(LLUUID::null, owner_id,
last_owner_id, group_id);
node->mPermissions->initMasks(base_mask, owner_mask, everyone_mask, group_mask, next_owner_mask);
node->mSaleInfo = sale_info;
node->mCategory = category;
node->mName.assign(name);
node->mDescription.assign(desc);
}
dialog_refresh_all();
}
void LLViewerObjectList::processUpdateCore(LLViewerObject* objectp,
void** user_data,
U32 i,
const EObjectUpdateType update_type,
LLDataPacker* dpp,
BOOL just_created)
{
LLMessageSystem* msg = gMessageSystem;
// ignore returned flags
objectp->processUpdateMessage(msg, user_data, i, update_type, dpp);
if (objectp->isDead())
{
// The update failed
return;
}
updateActive(objectp);
if (just_created)
{
gPipeline.addObject(objectp);
}
else if( LLXmlImport::sImportInProgress
&& objectp->permYouOwner()
&& LLXmlImport::sExpectedUpdate == objectp->getID())
{
LLXmlImport::onUpdatePrim(objectp);
}
// Also sets the approx. pixel area
objectp->setPixelAreaAndAngle(gAgent);
// RN: this must be called after we have a drawable
// (from gPipeline.addObject)
// so that the drawable parent is set properly
findOrphans(objectp, msg->getSenderIP(), msg->getSenderPort());
// <edit>
if (just_created
&& update_type != OUT_TERSE_IMPROVED
&& LLXmlImport::sImportInProgress)
{
LLViewerObject* parent = (LLViewerObject*)objectp->getParent();
if(parent)
{
if(parent->getID() == gAgent.getID())
{
LLXmlImport::onNewAttachment(objectp);
}
}
}
//</edit>
// If we're just wandering around, don't create new objects selected.
if (just_created
&& update_type != OUT_TERSE_IMPROVED
&& objectp->mCreateSelected)
{
if ( LLToolMgr::getInstance()->getCurrentTool() != LLToolPie::getInstance() )
{
// llinfos << "DEBUG selecting " << objectp->mID << " "
// << objectp->mLocalID << llendl;
LLSelectMgr::getInstance()->selectObjectAndFamily(objectp);
dialog_refresh_all();
}
objectp->mCreateSelected = false;
gViewerWindow->getWindow()->decBusyCount();
gViewerWindow->getWindow()->setCursor( UI_CURSOR_ARROW );
// <edit>
if(LLXmlImport::sImportInProgress)
{
if( objectp->permYouOwner()
&& (objectp->getPCode() == LLXmlImport::sSupplyParams->getPCode())
&& (objectp->getScale() == LLXmlImport::sSupplyParams->getScale()))
{
LLXmlImport::onNewPrim(objectp);
}
}
// </edit>
}
}