public string RezAll(BotInventoryEval man, InventoryBase b, SimPosition dest)
{
string ret = "";
var manager = man.Manager;
if (b is InventoryItem)
{
InventoryItem item = b as InventoryItem;
bool canCopy = (item.Permissions.OwnerMask & PermissionMask.Copy) == PermissionMask.Copy;
ret += item.Name + nl;
if (dest == null)
{
Simulator sim = Client.Network.CurrentSim;
Client.Inventory.RequestRestoreRezFromInventory(sim, item, item.UUID);
}
else
{
Simulator sim = SimRegion.GetRegion(dest.GlobalPosition).TheSimulator;
Client.Inventory.RequestRezFromInventory(sim, dest.SimRotation, dest.SimPosition, item, UUID.Zero);
}
}
else if (b is InventoryFolder)
{
InventoryFolder folder = b as InventoryFolder;
List<InventoryBase> folderContents = man.FolderContents(folder.UUID);
if (folderContents != null)
foreach (InventoryBase list in folderContents)
{
ret += RezAll(man, list, dest);
}
}
return ret;
}
/// <summary>
/// Determine whether the specified <seealso cref="OpenMetaverse.InventoryBase"/> object is equal to the current object
/// </summary>
/// <param name="o">InventoryBase object to compare against</param>
/// <returns>true if objects are the same</returns>
public virtual bool Equals(InventoryBase o)
{
return(o.UUID == UUID &&
o.ParentUUID == ParentUUID &&
o.Name == Name &&
o.OwnerID == OwnerID);
}
/// <summary>
/// Removes the InventoryObject and all related node data from Inventory.
/// </summary>
/// <param name="item">The InventoryObject to remove.</param>
public void RemoveNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode node;
if (Items.TryGetValue(item.UUID, out node))
{
if (node.Parent != null)
{
lock (node.Parent.Nodes.SyncRoot)
node.Parent.Nodes.Remove(item.UUID);
}
Items.Remove(item.UUID);
if (m_InventoryObjectRemoved != null)
{
OnInventoryObjectRemoved(new InventoryObjectRemovedEventArgs(item));
}
}
// In case there's a new parent:
InventoryNode newParent;
if (Items.TryGetValue(item.ParentUUID, out newParent))
{
lock (newParent.Nodes.SyncRoot)
newParent.Nodes.Remove(item.UUID);
}
}
}
protected void FireOnInventoryObjectAdded(InventoryBase obj)
{
if (OnInventoryObjectAdded != null)
{
try { OnInventoryObjectAdded(obj); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
}
protected void FireOnInventoryObjectUpdated(InventoryBase oldObject, InventoryBase newObject)
{
if (OnInventoryObjectUpdated != null)
{
try { OnInventoryObjectUpdated(oldObject, newObject); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
}
/// <summary>
/// De-serialization handler for the InventoryNode Class
/// </summary>
public InventoryNode(SerializationInfo info, StreamingContext ctxt)
{
parentID = (UUID)info.GetValue("Parent", typeof(UUID));
Type type = (Type)info.GetValue("Type", typeof(Type));
// Construct a new inventory object based on the Type stored in Type
System.Reflection.ConstructorInfo ctr = type.GetConstructor(new Type[] { typeof(SerializationInfo), typeof(StreamingContext) });
data = (InventoryBase)ctr.Invoke(new Object[] { info, ctxt });
}
/// <summary>
/// De-serialization constructor for the InventoryNode Class
/// </summary>
public InventoryNode(InventoryBase data, InventoryNode parent)
{
this.data = data;
this.parent = parent;
if (parent != null)
{
// Add this node to the collection of parent nodes
lock (parent.Nodes.SyncRoot) parent.Nodes.Add(data.UUID, this);
}
}
/// <summary>
/// De-serialization constructor for the InventoryNode Class
/// </summary>
public InventoryNode(InventoryBase data, InventoryNode parent)
{
this.data = data;
this.parent = parent;
if (parent != null)
{
// Add this node to the collection of parent nodes
lock (parent.Nodes.SyncRoot) parent.Nodes.Add(data.UUID, this);
}
}
internal Closet(PluginControl pc)
: base(pc)
{
Title = "inventory";
inv = control.instance.Client.Inventory.Store;
selected = inv.RootNode.Data;
control.listener.CreateGrammar(
INVNAME,
new string[] {
"read it",
"go there",
"close the closet",
"describe it" });
}
public int CompareNodes(InventoryBase x, InventoryBase y, TreeNode nodeX, TreeNode nodeY)
{
int returnVal = 0;
if (x is InventoryItem && y is InventoryItem)
{
InventoryItem itemX = (InventoryItem)x;
InventoryItem itemY = (InventoryItem)y;
returnVal = -itemX.CreationDate.CompareTo(itemY.CreationDate);
}
else if (x is InventoryFolder && y is InventoryFolder)
returnVal = nodeX.Text.CompareTo(nodeY.Text);
else if (x is InventoryFolder && y is InventoryItem)
returnVal = 1;
else if (x is InventoryItem && y is InventoryFolder)
returnVal = -1;
return returnVal;
}
public string GiveAll(BotInventoryEval man, InventoryBase b, SimObject dest, bool moveInsteadOfCopy)
{
string ret = "";
var manager = man.Manager;
if (b is InventoryItem)
{
InventoryItem item = b as InventoryItem;
bool canCopy = (item.Permissions.OwnerMask & PermissionMask.Copy) == PermissionMask.Copy;
ret += item.Name + nl;
if (dest.IsAvatar)
{
manager.GiveItem(item.UUID, item.Name, item.AssetType, dest.ID, true);
}
else
{
throw new NotImplementedException("giving items to objects");
}
}
else if (b is InventoryFolder)
{
InventoryFolder item = b as InventoryFolder;
if (dest.IsAvatar)
{
manager.GiveFolder(item.UUID, item.Name, AssetType.Folder, dest.ID, true);
return item.Name + nl;
}
InventoryFolder folder = b as InventoryFolder;
List<InventoryBase> folderContents = man.FolderContents(folder.UUID);
if (folderContents != null)
foreach (InventoryBase list in folderContents)
{
ret += GiveAll(man, list, dest, moveInsteadOfCopy);
}
}
return ret;
}
/// <summary>
///
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public override bool Equals(InventoryBase o)
{
InventoryFolder folder = o as InventoryFolder;
return folder != null && Equals(folder);
}
/// <summary>
/// Creates inventory link to another inventory item or folder
/// </summary>
/// <param name="folderID">Put newly created link in folder with this UUID</param>
/// <param name="bse">Inventory item or folder</param>
/// <param name="callback">Method to call upon creation of the link</param>
public void CreateLink(UUID folderID, InventoryBase bse, ItemCreatedCallback callback)
{
if (bse is InventoryFolder)
{
InventoryFolder folder = (InventoryFolder)bse;
CreateLink(folderID, folder, callback);
}
else if (bse is InventoryItem)
{
InventoryItem item = (InventoryItem)bse;
CreateLink(folderID, item.UUID, item.Name, item.Description, AssetType.Link, item.InventoryType, UUID.Random(), callback);
}
}
/// <summary>
/// Move an inventory item or folder to a new location and change its name
/// </summary>
/// <param name="item">The <seealso cref="T:InventoryBase"/> item or folder to move</param>
/// <param name="newParent">The <seealso cref="T:InventoryFolder"/> to move item or folder to</param>
/// <param name="newName">The name to change the item or folder to</param>
public void Move(InventoryBase item, InventoryFolder newParent, string newName)
{
if (item is InventoryFolder)
MoveFolder(item.UUID, newParent.UUID, newName);
else
MoveItem(item.UUID, newParent.UUID, newName);
}
TreeNode AddBase(TreeNode parent, InventoryBase obj)
{
if (obj is InventoryItem)
{
return AddItem(parent, (InventoryItem)obj);
}
else
{
return AddDir(parent, (InventoryFolder)obj);
}
}
public SearchResult(InventoryBase inv, int level)
{
this.Inv = inv;
this.Level = level;
}
public InventoryObjectAddedEventArgs(InventoryBase obj)
{
this.m_Obj = obj;
}
public bool Contains(InventoryBase obj)
{
return(Contains(obj.UUID));
}
public bool Contains(InventoryBase obj)
{
return Contains(obj.UUID);
}
/// <summary>
/// Removes the InventoryObject and all related node data from Inventory.
/// </summary>
/// <param name="item">The InventoryObject to remove.</param>
public void RemoveNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode node;
if (Items.TryGetValue(item.UUID, out node))
{
if (node.Parent != null)
lock (node.Parent.Nodes.SyncRoot)
node.Parent.Nodes.Remove(item.UUID);
Items.Remove(item.UUID);
FireOnInventoryObjectRemoved(item);
}
// In case there's a new parent:
InventoryNode newParent;
if (Items.TryGetValue(item.ParentUUID, out newParent))
{
lock (newParent.Nodes.SyncRoot)
newParent.Nodes.Remove(item.UUID);
}
}
}
/// <summary>
/// Updates the state of the InventoryNode and inventory data structure that
/// is responsible for the InventoryObject. If the item was previously not added to inventory,
/// it adds the item, and updates structure accordingly. If it was, it updates the
/// InventoryNode, changing the parent node if <code>item.parentUUID</code> does
/// not match <code>node.Parent.Data.UUID</code>.
///
/// You can not set the inventory root folder using this method
/// </summary>
/// <param name="item">The InventoryObject to store</param>
public void UpdateNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode itemParent = null;
if (item.ParentUUID != UUID.Zero && !Items.TryGetValue(item.ParentUUID, out itemParent))
{
// OK, we have no data on the parent, let's create a fake one.
InventoryFolder fakeParent = new InventoryFolder(item.ParentUUID);
fakeParent.DescendentCount = 1; // Dear god, please forgive me.
itemParent = new InventoryNode(fakeParent);
Items[item.ParentUUID] = itemParent;
// Unfortunately, this breaks the nice unified tree
// while we're waiting for the parent's data to come in.
// As soon as we get the parent, the tree repairs itself.
Logger.DebugLog("Attempting to update inventory child of " +
item.ParentUUID.ToString() + " when we have no local reference to that folder", Client);
if (Client.Settings.FETCH_MISSING_INVENTORY)
{
// Fetch the parent
List<UUID> fetchreq = new List<UUID>(1);
fetchreq.Add(item.ParentUUID);
//Manager.FetchInventory(fetchreq); // we cant fetch folder data! :-O
}
}
InventoryNode itemNode;
if (Items.TryGetValue(item.UUID, out itemNode)) // We're updating.
{
InventoryNode oldParent = itemNode.Parent;
// Handle parent change
if (oldParent == null || itemParent == null || itemParent.Data.UUID != oldParent.Data.UUID)
{
if (oldParent != null)
{
lock (oldParent.Nodes.SyncRoot)
oldParent.Nodes.Remove(item.UUID);
}
if (itemParent != null)
{
lock (itemParent.Nodes.SyncRoot)
itemParent.Nodes[item.UUID] = itemNode;
}
}
itemNode.Parent = itemParent;
FireOnInventoryObjectUpdated(itemNode.Data, item);
itemNode.Data = item;
}
else // We're adding.
{
itemNode = new InventoryNode(item, itemParent);
Items.Add(item.UUID, itemNode);
FireOnInventoryObjectAdded(item);
}
}
}
/// <summary>
/// Determine whether the specified <seealso cref="OpenMetaverse.InventoryBase"/> object is equal to the current object
/// </summary>
/// <param name="o">InventoryBase object to compare against</param>
/// <returns>true if objects are the same</returns>
public virtual bool Equals(InventoryBase o)
{
return o.Guid == Guid
&& o.ParentGuid == ParentGuid
&& o.Name == Name
&& o.OwnerID == OwnerID;
}
/// <inheritdoc />
/// <summary>
/// Determine whether the specified <seealso cref="T:OpenMetaverse.InventoryBase" /> object is equal to the current object
/// </summary>
/// <param name="o">The <seealso cref="T:OpenMetaverse.InventoryBase" /> object to compare against</param>
/// <returns>true if objects are the same</returns>
public override bool Equals(InventoryBase o)
{
return(o is InventoryItem item && Equals(item));
}
/// <summary>
/// Can this inventory type be worn
/// </summary>
/// <param name="item">Item to check</param>
/// <returns>True if the inventory item can be worn</returns>
public static bool CanBeWorn(InventoryBase item)
{
return item is InventoryWearable || item is InventoryAttachment || item is InventoryObject;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public InventoryNode(SerializationInfo info, StreamingContext ctxt)
{
parentID = (UUID)info.GetValue("Parent", typeof(UUID));
Type type = (Type)info.GetValue("Type", typeof(Type));
if (type == typeof(InventoryAnimation))
{
data = new InventoryAnimation(info, ctxt);
}
if (type == typeof(InventoryAttachment))
{
data = new InventoryAttachment(info, ctxt);
}
if (type == typeof(InventoryCallingCard))
{
data = new InventoryCallingCard(info, ctxt);
}
if (type == typeof(InventoryFolder))
{
data = new InventoryFolder(info, ctxt);
}
if (type == typeof(InventoryGesture))
{
data = new InventoryGesture(info, ctxt);
}
if (type == typeof(InventoryLandmark))
{
data = new InventoryLandmark(info, ctxt);
}
if (type == typeof(InventoryLSL))
{
data = new InventoryLSL(info, ctxt);
}
if (type == typeof(InventoryNotecard))
{
data = new InventoryNotecard(info, ctxt);
}
if (type == typeof(InventoryObject))
{
data = new InventoryObject(info, ctxt);
}
if (type == typeof(InventorySnapshot))
{
data = new InventorySnapshot(info, ctxt);
}
if (type == typeof(InventorySound))
{
data = new InventorySound(info, ctxt);
}
if (type == typeof(InventoryTexture))
{
data = new InventoryTexture(info, ctxt);
}
if (type == typeof(InventoryWearable))
{
data = new InventoryWearable(info, ctxt);
}
}
void OnItemChange(object sender, TreeViewEventArgs e)
{
selected = (InventoryBase)e.Node.Tag;
SayWhere();
}
protected void FireOnInventoryObjectUpdated(InventoryBase oldObject, InventoryBase newObject)
{
if (OnInventoryObjectUpdated != null)
{
try { OnInventoryObjectUpdated(oldObject, newObject); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
}
public InventoryObjectUpdatedEventArgs(InventoryBase oldObject, InventoryBase newObject)
{
this.m_OldObject = oldObject;
this.m_NewObject = newObject;
}
protected void FireOnInventoryObjectAdded(InventoryBase obj)
{
if (OnInventoryObjectAdded != null)
{
try { OnInventoryObjectAdded(obj); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
}
void Exec_OnInventoryObjectUpdated(InventoryBase oldObject, InventoryBase newObject)
{
if (newObject == null) return;
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => Exec_OnInventoryObjectUpdated(oldObject, newObject)));
return;
}
lock (attachments)
{
if (attachments.ContainsKey(newObject.UUID))
{
attachments[newObject.UUID].Item = (InventoryItem)newObject;
}
}
// Find our current node in the tree
TreeNode currentNode = findNodeForItem(newObject.UUID);
// Find which node should be our parrent
TreeNode parent = findNodeForItem(newObject.ParentUUID);
if (parent == null) return;
if (currentNode != null)
{
// Did we move to a different folder
if (currentNode.Parent != parent)
{
TreeNode movedNode = (TreeNode)currentNode.Clone();
movedNode.Tag = newObject;
parent.Nodes.Add(movedNode);
removeNode(currentNode);
cacheNode(movedNode);
}
else // Update
{
currentNode.Tag = newObject;
currentNode.Text = ItemLabel(newObject, false);
currentNode.Name = newObject.Name;
}
}
else // We are not in the tree already, add
{
AddBase(parent, newObject);
}
}
Gdk.Pixbuf getprettyicon(InventoryBase item)
{
if (item is InventoryFolder)
return getprettyfoldericon((InventoryFolder)item);
if(item is OpenMetaverse.InventoryLandmark)
return this.item_landmark;
if(item is OpenMetaverse.InventoryAnimation)
return this.item_animation;
if(item is OpenMetaverse.InventoryWearable)
{
OpenMetaverse.InventoryWearable wearable=(OpenMetaverse.InventoryWearable)item;
switch(wearable.WearableType)
{
case WearableType.Eyes:
return this.item_clothing_eyes;
case WearableType.Gloves:
return this.item_clothing_gloves;
case WearableType.Hair:
return this.item_clothing_hair;
case WearableType.Jacket:
return this.item_clothing_jacket;
case WearableType.Pants:
return this.item_clothing_pants;
case WearableType.Shape:
return this.item_clothing_shape;
case WearableType.Shirt:
return this.item_clothing_shirt;
case WearableType.Shoes:
return this.item_clothing_shoes;
case WearableType.Skin:
return this.item_clothing_skin;
case WearableType.Skirt:
return this.item_clothing_skirt;
case WearableType.Socks:
return this.item_clothing_socks;
case WearableType.Underpants:
return this.item_clothing_underpants;
case WearableType.Undershirt:
return this.item_clothing_undershirt;
default:
return this.item_clothing;
}
}
if (item is OpenMetaverse.InventoryGesture)
return this.item_gesture;
if (item is OpenMetaverse.InventoryNotecard)
return this.item_notecard;
if (item is OpenMetaverse.InventoryLSL)
return this.item_script;
if (item is OpenMetaverse.InventorySnapshot)
return this.item_snapshot;
if (item is OpenMetaverse.InventoryTexture)
return this.item_texture;
if (item is OpenMetaverse.InventorySound)
return this.item_sound;
if (item is OpenMetaverse.InventoryCallingCard)
return this.item_callingcard;
return item_object;
}
/// <summary>
/// Returns text of the label
/// </summary>
/// <param name="invBase">Inventory item</param>
/// <param name="returnRaw">Should we return raw text, or if false decorated text with (worn) info, and (no copy) etc. permission info</param>
/// <returns></returns>
public string ItemLabel(InventoryBase invBase, bool returnRaw)
{
if (returnRaw || (invBase is InventoryFolder))
return invBase.Name;
InventoryItem item = (InventoryItem)invBase;
string raw = item.Name;
if (item.IsLink())
{
raw += " (link)";
if (Inventory.Contains(item.AssetUUID) && Inventory[item.AssetUUID] is InventoryItem)
{
item = (InventoryItem)Inventory[item.AssetUUID];
}
}
if ((item.Permissions.OwnerMask & PermissionMask.Modify) == 0)
raw += " (no modify)";
if ((item.Permissions.OwnerMask & PermissionMask.Copy) == 0)
raw += " (no copy)";
if ((item.Permissions.OwnerMask & PermissionMask.Transfer) == 0)
raw += " (no transfer)";
if (IsWorn(item))
raw += " (worn)";
if (IsAttached(item))
{
raw += " (worn on " + AttachedTo(item).ToString() + ")";
}
return raw;
}
/// <summary>
/// Move an inventory item or folder to a new location
/// </summary>
/// <param name="item">The <seealso cref="T:InventoryBase"/> item or folder to move</param>
/// <param name="newParent">The <seealso cref="T:InventoryFolder"/> to move item or folder to</param>
public void Move(InventoryBase item, InventoryFolder newParent)
{
if (item is InventoryFolder)
MoveFolder(item.Guid, newParent.Guid);
else
MoveItem(item.Guid, newParent.Guid);
}
void Exec_OnInventoryObjectAdded(InventoryBase obj)
{
if (InvokeRequired)
{
Invoke(new MethodInvoker(delegate()
{
Exec_OnInventoryObjectAdded(obj);
}
));
return;
}
lock (attachments)
{
if (attachments.ContainsKey(obj.UUID))
{
attachments[obj.UUID].Item = (InventoryItem)obj;
}
}
TreeNode parent = findNodeForItem(obj.ParentUUID);
if (parent != null)
{
TreeNode newNode = AddBase(parent, obj);
if (obj.Name == newItemName)
{
if (newNode.Parent.IsExpanded)
{
newNode.BeginEdit();
}
else
{
newNode.Parent.Expand();
}
}
}
newItemName = string.Empty;
}
/// <summary>
/// De-serialization handler for the InventoryNode Class
/// </summary>
public InventoryNode(SerializationInfo info, StreamingContext ctxt)
{
parentID = (UUID)info.GetValue("Parent", typeof(UUID));
Type type = (Type)info.GetValue("Type", typeof(Type));
// Construct a new inventory object based on the Type stored in Type
System.Reflection.ConstructorInfo ctr = type.GetConstructor(new Type[] {typeof(SerializationInfo),typeof(StreamingContext)});
data = (InventoryBase) ctr.Invoke(new Object[] { info, ctxt });
}
/// <summary>
/// Determine whether the specified <seealso cref="OpenMetaverse.InventoryBase"/> object is equal to the current object
/// </summary>
/// <param name="o">InventoryBase object to compare against</param>
/// <returns>true if objects are the same</returns>
public virtual bool Equals(InventoryBase o)
{
return o.UUID == UUID
&& o.ParentUUID == ParentUUID
&& o.Name == Name
&& o.OwnerID == OwnerID;
}
public InventoryClipboard(ClipboardOperation operation, InventoryBase item)
{
Operation = operation;
Item = item;
}
/// <summary>
/// Determine whether the specified <seealso cref="OpenMetaverse.InventoryBase"/> object is equal to the current object
/// </summary>
/// <param name="o">The <seealso cref="OpenMetaverse.InventoryBase"/> object to compare against</param>
/// <returns>true if objects are the same</returns>
public override bool Equals(InventoryBase o)
{
InventoryItem item = o as InventoryItem;
return item != null && Equals(item);
}
/// <summary>
/// Updates the state of the InventoryNode and inventory data structure that
/// is responsible for the InventoryObject. If the item was previously not added to inventory,
/// it adds the item, and updates structure accordingly. If it was, it updates the
/// InventoryNode, changing the parent node if <code>item.parentUUID</code> does
/// not match <code>node.Parent.Data.UUID</code>.
///
/// You can not set the inventory root folder using this method
/// </summary>
/// <param name="item">The InventoryObject to store</param>
public void UpdateNodeFor(InventoryBase item)
{
lock (Items)
{
InventoryNode itemParent = null;
if (item.ParentUUID != UUID.Zero && !Items.TryGetValue(item.ParentUUID, out itemParent))
{
// OK, we have no data on the parent, let's create a fake one.
InventoryFolder fakeParent = new InventoryFolder(item.ParentUUID);
fakeParent.DescendentCount = 1; // Dear god, please forgive me.
itemParent = new InventoryNode(fakeParent);
Items[item.ParentUUID] = itemParent;
// Unfortunately, this breaks the nice unified tree
// while we're waiting for the parent's data to come in.
// As soon as we get the parent, the tree repairs itself.
//Logger.DebugLog("Attempting to update inventory child of " +
// item.ParentUUID.ToString() + " when we have no local reference to that folder", Client);
if (Client.Settings.FETCH_MISSING_INVENTORY)
{
// Fetch the parent
List <UUID> fetchreq = new List <UUID>(1);
fetchreq.Add(item.ParentUUID);
}
}
InventoryNode itemNode;
if (Items.TryGetValue(item.UUID, out itemNode)) // We're updating.
{
InventoryNode oldParent = itemNode.Parent;
// Handle parent change
if (oldParent == null || itemParent == null || itemParent.Data.UUID != oldParent.Data.UUID)
{
if (oldParent != null)
{
lock (oldParent.Nodes.SyncRoot)
oldParent.Nodes.Remove(item.UUID);
}
if (itemParent != null)
{
lock (itemParent.Nodes.SyncRoot)
itemParent.Nodes[item.UUID] = itemNode;
}
}
itemNode.Parent = itemParent;
if (m_InventoryObjectUpdated != null)
{
OnInventoryObjectUpdated(new InventoryObjectUpdatedEventArgs(itemNode.Data, item));
}
itemNode.Data = item;
}
else // We're adding.
{
itemNode = new InventoryNode(item, itemParent);
Items.Add(item.UUID, itemNode);
if (m_InventoryObjectAdded != null)
{
OnInventoryObjectAdded(new InventoryObjectAddedEventArgs(item));
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
public InventoryNode(InventoryBase data)
{
this.data = data;
}
private void Inventory_OnInventoryItemCopied(InventoryBase item)
{
if (InvokeRequired)
{
if (!instance.MonoRuntime || IsHandleCreated)
BeginInvoke(new MethodInvoker(() => Inventory_OnInventoryItemCopied(item)));
return;
}
if (null == item) return;
instance.TabConsole.DisplayNotificationInChat(
string.Format("{0} saved to inventory", item.Name),
ChatBufferTextStyle.Invisible);
tlblStatus.Text = "Saved";
if (item is InventoryNotecard)
{
Notecard nc = new Notecard(instance, (InventoryNotecard)item);
nc.pnlKeepDiscard.Visible = true;
nc.ShowDetached();
}
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
public InventoryNode(InventoryBase data)
{
this.data = data;
}
string DescriptiveName(InventoryBase item)
{
string name = NiceName(item.Name);
if (item is InventoryFolder)
return name + " folder";
if (item is InventoryNotecard)
return name + ", a notecard";
if (item is InventoryWearable)
return name + ", a " + WearableType(item as InventoryWearable);
if (item is InventoryLandmark)
return name + ", a landmark";
// TODO other types
return name;
}
