public frmGive(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
//netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
textBox1.GotFocus += textBox1_GotFocus;
textBox1.MouseUp += textBox1_MouseUp;
textBox1.Leave += textBox1_Leave;
client.Directory.DirPeopleReply += new EventHandler<DirPeopleReplyEventArgs>(Directory_OnDirPeopleReply);
client.Groups.GroupMembersReply += new EventHandler<GroupMembersReplyEventArgs>(GroupMembersHandler);
client.Avatars.UUIDNameReply += new EventHandler<UUIDNameReplyEventArgs>(AvatarNamesHandler);
groupmode = false;
client.Groups.RequestCurrentGroups();
label2.Text = "Give item: " + item.Name;
lvwColumnSorter = new NumericStringComparer();
lvwFindFriends.ListViewItemSorter = lvwColumnSorter;
lvwSelected.ListViewItemSorter = lvwColumnSorter;
}
public InventoryGestureConsol(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
client = this.instance.Client;
this.item = item;
}
public InventoryObjectConsole(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
//netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
}
public InventoryAnimationConsole(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
//netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
this.Disposed += new EventHandler(InventoryAnimation_Disposed);
}
//private InventoryConsole iconsole;
//private TreeNode inode;
public InventoryItemConsole(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
//netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
this.Disposed += new EventHandler(InventoryItemConsole_Disposed);
//iconsole = new InventoryConsole(instance);
AddClientEvents();
FillItemProperties();
}
public InventoryImageConsole(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
//netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
if (instance.ImageCache.ContainsImage(item.AssetUUID))
SetFinalImage(instance.ImageCache.GetImage(item.AssetUUID));
else
{
this.Disposed += new EventHandler(InventoryImageConsole_Disposed);
//client.Assets.OnImageRecieveProgress += new AssetManager.ImageReceiveProgressCallback(Assets_OnImageReceived);
}
}
public frmNotecardEditor(METAboltInstance instance, InventoryItem item)
{
InitializeComponent();
this.instance = instance;
netcom = this.instance.Netcom;
client = this.instance.Client;
this.item = item;
Disposed += new EventHandler(Notecard_Disposed);
AddNetcomEvents();
objectid = UUID.Zero;
istaskobj = false;
this.Text = item.Name + " (notecard) - METAbolt";
assetUUID = item.AssetUUID;
rtbNotecard.TextChanged += new EventHandler(rtbNotecard_TextChanged);
client.Assets.RequestInventoryAsset(assetUUID, item.UUID, UUID.Zero, item.OwnerID, item.AssetType, true, Assets_OnAssetReceived);
}
public ItemReceivedEventArgs(InventoryItem item)
{
this.m_Item = item;
}
/// <summary>
/// Parse the results of a RequestTaskInventory() response
/// </summary>
/// <param name="taskData">A string which contains the data from the task reply</param>
/// <returns>A List containing the items contained within the tasks inventory</returns>
public static List<InventoryBase> ParseTaskInventory(string taskData)
{
List<InventoryBase> items = new List<InventoryBase>();
int lineNum = 0;
string[] lines = taskData.Replace("\r\n", "\n").Split('\n');
while (lineNum < lines.Length)
{
string key, value;
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "inv_object")
{
#region inv_object
// In practice this appears to only be used for folders
UUID itemID = UUID.Zero;
UUID parentID = UUID.Zero;
string name = String.Empty;
AssetType assetType = AssetType.Unknown;
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "obj_id")
{
UUID.TryParse(value, out itemID);
}
else if (key == "parent_id")
{
UUID.TryParse(value, out parentID);
}
else if (key == "type")
{
assetType = Utils.StringToAssetType(value);
}
else if (key == "name")
{
name = value.Substring(0, value.IndexOf('|'));
}
}
}
if (assetType == AssetType.Folder)
{
InventoryFolder folder = new InventoryFolder(itemID);
folder.Name = name;
folder.ParentUUID = parentID;
items.Add(folder);
}
else
{
InventoryItem item = new InventoryItem(itemID);
item.Name = name;
item.ParentUUID = parentID;
item.AssetType = assetType;
items.Add(item);
}
#endregion inv_object
}
else if (key == "inv_item")
{
#region inv_item
// Any inventory item that links to an assetID, has permissions, etc
UUID itemID = UUID.Zero;
UUID assetID = UUID.Zero;
UUID parentID = UUID.Zero;
UUID creatorID = UUID.Zero;
UUID ownerID = UUID.Zero;
UUID lastOwnerID = UUID.Zero;
UUID groupID = UUID.Zero;
bool groupOwned = false;
string name = String.Empty;
string desc = String.Empty;
AssetType assetType = AssetType.Unknown;
InventoryType inventoryType = InventoryType.Unknown;
DateTime creationDate = Utils.Epoch;
uint flags = 0;
Permissions perms = Permissions.NoPermissions;
SaleType saleType = SaleType.Not;
int salePrice = 0;
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "item_id")
{
UUID.TryParse(value, out itemID);
}
else if (key == "parent_id")
{
UUID.TryParse(value, out parentID);
}
else if (key == "permissions")
{
#region permissions
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "creator_mask")
{
// Deprecated
uint val;
if (Utils.TryParseHex(value, out val))
perms.BaseMask = (PermissionMask)val;
}
else if (key == "base_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
perms.BaseMask = (PermissionMask)val;
}
else if (key == "owner_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
perms.OwnerMask = (PermissionMask)val;
}
else if (key == "group_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
perms.GroupMask = (PermissionMask)val;
}
else if (key == "everyone_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
perms.EveryoneMask = (PermissionMask)val;
}
else if (key == "next_owner_mask")
{
uint val;
if (Utils.TryParseHex(value, out val))
perms.NextOwnerMask = (PermissionMask)val;
}
else if (key == "creator_id")
{
UUID.TryParse(value, out creatorID);
}
else if (key == "owner_id")
{
UUID.TryParse(value, out ownerID);
}
else if (key == "last_owner_id")
{
UUID.TryParse(value, out lastOwnerID);
}
else if (key == "group_id")
{
UUID.TryParse(value, out groupID);
}
else if (key == "group_owned")
{
uint val;
if (UInt32.TryParse(value, out val))
groupOwned = (val != 0);
}
}
}
#endregion permissions
}
else if (key == "sale_info")
{
#region sale_info
while (lineNum < lines.Length)
{
if (ParseLine(lines[lineNum++], out key, out value))
{
if (key == "{")
{
continue;
}
else if (key == "}")
{
break;
}
else if (key == "sale_type")
{
saleType = Utils.StringToSaleType(value);
}
else if (key == "sale_price")
{
Int32.TryParse(value, out salePrice);
}
}
}
#endregion sale_info
}
else if (key == "shadow_id")
{
UUID shadowID;
if (UUID.TryParse(value, out shadowID))
assetID = DecryptShadowID(shadowID);
}
else if (key == "asset_id")
{
UUID.TryParse(value, out assetID);
}
else if (key == "type")
{
assetType = Utils.StringToAssetType(value);
}
else if (key == "inv_type")
{
inventoryType = Utils.StringToInventoryType(value);
}
else if (key == "flags")
{
UInt32.TryParse(value, out flags);
}
else if (key == "name")
{
name = value.Substring(0, value.IndexOf('|'));
}
else if (key == "desc")
{
desc = value.Substring(0, value.IndexOf('|'));
}
else if (key == "creation_date")
{
uint timestamp;
if (UInt32.TryParse(value, out timestamp))
creationDate = Utils.UnixTimeToDateTime(timestamp);
else
Logger.Log("Failed to parse creation_date " + value, Helpers.LogLevel.Warning);
}
}
}
InventoryItem item = CreateInventoryItem(inventoryType, itemID);
item.AssetUUID = assetID;
item.AssetType = assetType;
item.CreationDate = creationDate;
item.CreatorID = creatorID;
item.Description = desc;
item.Flags = flags;
item.GroupID = groupID;
item.GroupOwned = groupOwned;
item.Name = name;
item.OwnerID = ownerID;
item.LastOwnerID = lastOwnerID;
item.ParentUUID = parentID;
item.Permissions = perms;
item.SalePrice = salePrice;
item.SaleType = saleType;
items.Add(item);
#endregion inv_item
}
else
{
Logger.Log("Unrecognized token " + key + " in: " + Environment.NewLine + taskData,
Helpers.LogLevel.Error);
}
}
}
return items;
}
/// <summary>
/// Copy an InventoryScript item from the Agents Inventory into a primitives task inventory
/// </summary>
/// <param name="objectLocalID">An unsigned integer representing a primitive being simulated</param>
/// <param name="item">An <seealso cref="InventoryItem"/> which represents a script object from the agents inventory</param>
/// <param name="enableScript">true to set the scripts running state to enabled</param>
/// <returns>A Unique Transaction ID</returns>
/// <example>
/// The following example shows the basic steps necessary to copy a script from the agents inventory into a tasks inventory
/// and assumes the script exists in the agents inventory.
/// <code>
/// uint primID = 95899503; // Fake prim ID
/// UUID scriptID = UUID.Parse("92a7fe8a-e949-dd39-a8d8-1681d8673232"); // Fake Script UUID in Inventory
///
/// Client.Inventory.FolderContents(Client.Inventory.FindFolderForType(AssetType.LSLText), Client.Self.AgentID,
/// false, true, InventorySortOrder.ByName, 10000);
///
/// Client.Inventory.RezScript(primID, (InventoryItem)Client.Inventory.Store[scriptID]);
/// </code>
/// </example>
// DocTODO: what does the return UUID correlate to if anything?
public UUID CopyScriptToTask(uint objectLocalID, InventoryItem item, bool enableScript)
{
UUID transactionID = UUID.Random();
RezScriptPacket ScriptPacket = new RezScriptPacket();
ScriptPacket.AgentData.AgentID = Client.Self.AgentID;
ScriptPacket.AgentData.SessionID = Client.Self.SessionID;
ScriptPacket.UpdateBlock.ObjectLocalID = objectLocalID;
ScriptPacket.UpdateBlock.Enabled = enableScript;
ScriptPacket.InventoryBlock.ItemID = item.UUID;
ScriptPacket.InventoryBlock.FolderID = item.ParentUUID;
ScriptPacket.InventoryBlock.CreatorID = item.CreatorID;
ScriptPacket.InventoryBlock.OwnerID = item.OwnerID;
ScriptPacket.InventoryBlock.GroupID = item.GroupID;
ScriptPacket.InventoryBlock.BaseMask = (uint)item.Permissions.BaseMask;
ScriptPacket.InventoryBlock.OwnerMask = (uint)item.Permissions.OwnerMask;
ScriptPacket.InventoryBlock.GroupMask = (uint)item.Permissions.GroupMask;
ScriptPacket.InventoryBlock.EveryoneMask = (uint)item.Permissions.EveryoneMask;
ScriptPacket.InventoryBlock.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
ScriptPacket.InventoryBlock.GroupOwned = item.GroupOwned;
ScriptPacket.InventoryBlock.TransactionID = transactionID;
ScriptPacket.InventoryBlock.Type = (sbyte)item.AssetType;
ScriptPacket.InventoryBlock.InvType = (sbyte)item.InventoryType;
ScriptPacket.InventoryBlock.Flags = (uint)item.Flags;
ScriptPacket.InventoryBlock.SaleType = (byte)item.SaleType;
ScriptPacket.InventoryBlock.SalePrice = item.SalePrice;
ScriptPacket.InventoryBlock.Name = Utils.StringToBytes(item.Name);
ScriptPacket.InventoryBlock.Description = Utils.StringToBytes(item.Description);
ScriptPacket.InventoryBlock.CreationDate = (int)Utils.DateTimeToUnixTime(item.CreationDate);
ScriptPacket.InventoryBlock.CRC = ItemCRC(item);
Client.Network.SendPacket(ScriptPacket);
return transactionID;
}
/// <summary>
/// Rez an item from inventory to its previous simulator location
/// </summary>
/// <param name="simulator"></param>
/// <param name="item"></param>
/// <param name="queryID"></param>
/// <returns></returns>
public UUID RequestRestoreRezFromInventory(Simulator simulator, InventoryItem item, UUID queryID)
{
RezRestoreToWorldPacket add = new RezRestoreToWorldPacket();
add.AgentData.AgentID = Client.Self.AgentID;
add.AgentData.SessionID = Client.Self.SessionID;
add.InventoryData.ItemID = item.UUID;
add.InventoryData.FolderID = item.ParentUUID;
add.InventoryData.CreatorID = item.CreatorID;
add.InventoryData.OwnerID = item.OwnerID;
add.InventoryData.GroupID = item.GroupID;
add.InventoryData.BaseMask = (uint)item.Permissions.BaseMask;
add.InventoryData.OwnerMask = (uint)item.Permissions.OwnerMask;
add.InventoryData.GroupMask = (uint)item.Permissions.GroupMask;
add.InventoryData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
add.InventoryData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
add.InventoryData.GroupOwned = item.GroupOwned;
add.InventoryData.TransactionID = queryID;
add.InventoryData.Type = (sbyte)item.InventoryType;
add.InventoryData.InvType = (sbyte)item.InventoryType;
add.InventoryData.Flags = (uint)item.Flags;
add.InventoryData.SaleType = (byte)item.SaleType;
add.InventoryData.SalePrice = item.SalePrice;
add.InventoryData.Name = Utils.StringToBytes(item.Name);
add.InventoryData.Description = Utils.StringToBytes(item.Description);
add.InventoryData.CreationDate = (int)Utils.DateTimeToUnixTime(item.CreationDate);
Client.Network.SendPacket(add, simulator);
return queryID;
}
/// <summary>
/// Rez an object from inventory
/// </summary>
/// <param name="simulator">Simulator to place object in</param>
/// <param name="rotation">Rotation of the object when rezzed</param>
/// <param name="position">Vector of where to place object</param>
/// <param name="item">InventoryItem object containing item details</param>
/// <param name="groupOwner">UUID of group to own the object</param>
public UUID RequestRezFromInventory(Simulator simulator, Quaternion rotation, Vector3 position,
InventoryItem item, UUID groupOwner)
{
return RequestRezFromInventory(simulator, rotation, position, item, groupOwner, UUID.Random(), true);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
public void RequestUpdateItem(InventoryItem item)
{
List<InventoryItem> items = new List<InventoryItem>(1);
items.Add(item);
RequestUpdateItems(items, UUID.Random());
}
/// <summary>
/// Checks if an inventory item is currently being worn
/// </summary>
/// <param name="item">The inventory item to check against the agent
/// wearables</param>
/// <returns>The WearableType slot that the item is being worn in,
/// or WearbleType.Invalid if it is not currently being worn</returns>
public WearableType IsItemWorn(InventoryItem item)
{
lock (Wearables)
{
foreach (KeyValuePair<WearableType, WearableData> entry in Wearables)
{
if (entry.Value.ItemID == item.UUID)
return entry.Key;
}
}
return WearableType.Invalid;
}
/// <summary>
/// Detach an item from our agent using an <seealso cref="OpenMetaverse.InventoryItem"/> object
/// </summary>
/// <param name="item">An <seealso cref="OpenMetaverse.InventoryItem"/> object</param>
public void Detach(InventoryItem item)
{
Detach(item.UUID);
}
TreeNode AddItem(TreeNode parent, InventoryItem item)
{
TreeNode itemNode = new TreeNode();
itemNode.Name = item.UUID.ToString();
itemNode.Text = ItemLabel(item, false);
itemNode.Tag = item;
int img = -1;
InventoryItem linkedItem = null;
if (item.IsLink() && Inventory.Contains(item.AssetUUID) && Inventory[item.AssetUUID] is InventoryItem)
{
linkedItem = (InventoryItem)Inventory[item.AssetUUID];
}
else
{
linkedItem = item;
}
if (linkedItem is InventoryWearable)
{
InventoryWearable w = linkedItem as InventoryWearable;
img = GetItemImageIndex(w.WearableType.ToString().ToLower());
}
else
{
img = GetItemImageIndex(linkedItem.AssetType.ToString().ToLower());
}
itemNode.ImageIndex = img;
itemNode.SelectedImageIndex = img;
parent.Nodes.Add(itemNode);
lock (UUID2NodeCache)
{
UUID2NodeCache[item.UUID] = itemNode;
}
return itemNode;
}
/// <summary>
/// Creates inventory link to another inventory item
/// </summary>
/// <param name="folderID">Put newly created link in folder with this UUID</param>
/// <param name="item">Original inventory item</param>
/// <param name="callback">Method to call upon creation of the link</param>
public void CreateLink(UUID folderID, InventoryItem item, ItemCreatedCallback callback)
{
CreateLink(folderID, item.UUID, item.Name, item.Description, AssetType.Link, item.InventoryType, UUID.Random(), callback);
}
/// <summary>
/// Remove a wearable from the current outfit and set appearance
/// </summary>
/// <param name="wearableItem">Wearable to be removed from the outfit</param>
public void RemoveFromOutfit(InventoryItem wearableItem)
{
List<InventoryItem> wearableItems = new List<InventoryItem>();
wearableItems.Add(wearableItem);
RemoveFromOutfit(wearableItems);
}
/// <summary>
/// Rez an object from inventory
/// </summary>
/// <param name="simulator">Simulator to place object in</param>
/// <param name="rotation">Rotation of the object when rezzed</param>
/// <param name="position">Vector of where to place object</param>
/// <param name="item">InventoryItem object containing item details</param>
public UUID RequestRezFromInventory(Simulator simulator, Quaternion rotation, Vector3 position,
InventoryItem item)
{
return RequestRezFromInventory(simulator, rotation, position, item, Client.Self.ActiveGroup,
UUID.Random(), true);
}
public static bool IsFullPerm(InventoryItem item)
{
if (
((item.Permissions.OwnerMask & PermissionMask.Modify) != 0) &&
((item.Permissions.OwnerMask & PermissionMask.Copy) != 0) &&
((item.Permissions.OwnerMask & PermissionMask.Transfer) != 0)
)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// Rez an object from inventory
/// </summary>
/// <param name="simulator">Simulator to place object in</param>
/// <param name="rotation">Rotation of the object when rezzed</param>
/// <param name="position">Vector of where to place object</param>
/// <param name="item">InventoryItem object containing item details</param>
/// <param name="groupOwner">UUID of group to own the object</param>
/// <param name="queryID">User defined queryID to correlate replies</param>
/// <param name="rezSelected">If set to true, the CreateSelected flag
/// will be set on the rezzed object</param>
public UUID RequestRezFromInventory(Simulator simulator, Quaternion rotation, Vector3 position,
InventoryItem item, UUID groupOwner, UUID queryID, bool rezSelected)
{
RezObjectPacket add = new RezObjectPacket();
add.AgentData.AgentID = Client.Self.AgentID;
add.AgentData.SessionID = Client.Self.SessionID;
add.AgentData.GroupID = groupOwner;
add.RezData.FromTaskID = UUID.Zero;
add.RezData.BypassRaycast = 1;
add.RezData.RayStart = position;
add.RezData.RayEnd = position;
add.RezData.RayTargetID = UUID.Zero;
add.RezData.RayEndIsIntersection = false;
add.RezData.RezSelected = rezSelected;
add.RezData.RemoveItem = false;
add.RezData.ItemFlags = (uint)item.Flags;
add.RezData.GroupMask = (uint)item.Permissions.GroupMask;
add.RezData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
add.RezData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
add.InventoryData.ItemID = item.UUID;
add.InventoryData.FolderID = item.ParentUUID;
add.InventoryData.CreatorID = item.CreatorID;
add.InventoryData.OwnerID = item.OwnerID;
add.InventoryData.GroupID = item.GroupID;
add.InventoryData.BaseMask = (uint)item.Permissions.BaseMask;
add.InventoryData.OwnerMask = (uint)item.Permissions.OwnerMask;
add.InventoryData.GroupMask = (uint)item.Permissions.GroupMask;
add.InventoryData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
add.InventoryData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
add.InventoryData.GroupOwned = item.GroupOwned;
add.InventoryData.TransactionID = queryID;
add.InventoryData.Type = (sbyte)item.InventoryType;
add.InventoryData.InvType = (sbyte)item.InventoryType;
add.InventoryData.Flags = (uint)item.Flags;
add.InventoryData.SaleType = (byte)item.SaleType;
add.InventoryData.SalePrice = item.SalePrice;
add.InventoryData.Name = Utils.StringToBytes(item.Name);
add.InventoryData.Description = Utils.StringToBytes(item.Description);
add.InventoryData.CreationDate = (int)Utils.DateTimeToUnixTime(item.CreationDate);
Client.Network.SendPacket(add, simulator);
return queryID;
}
void ScriptCreated(bool success, InventoryItem item)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => ScriptCreated(success, item)));
return;
}
if (!success)
{
instance.TabConsole.DisplayNotificationInChat("Creation of script failed");
return;
}
instance.TabConsole.DisplayNotificationInChat("New script created, enter script name and press enter", ChatBufferTextStyle.Invisible);
var node = findNodeForItem(item.ParentUUID);
if (node != null) node.Expand();
node = findNodeForItem(item.UUID);
if (node != null)
{
invTree.SelectedNode = node;
node.BeginEdit();
}
}
/// <summary>
/// Copy or move an <see cref="InventoryItem"/> from agent inventory to a task (primitive) inventory
/// </summary>
/// <param name="objectLocalID">The target object</param>
/// <param name="item">The item to copy or move from inventory</param>
/// <returns></returns>
/// <remarks>For items with copy permissions a copy of the item is placed in the tasks inventory,
/// for no-copy items the object is moved to the tasks inventory</remarks>
// DocTODO: what does the return UUID correlate to if anything?
public UUID UpdateTaskInventory(uint objectLocalID, InventoryItem item)
{
UUID transactionID = UUID.Random();
UpdateTaskInventoryPacket update = new UpdateTaskInventoryPacket();
update.AgentData.AgentID = Client.Self.AgentID;
update.AgentData.SessionID = Client.Self.SessionID;
update.UpdateData.Key = 0;
update.UpdateData.LocalID = objectLocalID;
update.InventoryData.ItemID = item.UUID;
update.InventoryData.FolderID = item.ParentUUID;
update.InventoryData.CreatorID = item.CreatorID;
update.InventoryData.OwnerID = item.OwnerID;
update.InventoryData.GroupID = item.GroupID;
update.InventoryData.BaseMask = (uint)item.Permissions.BaseMask;
update.InventoryData.OwnerMask = (uint)item.Permissions.OwnerMask;
update.InventoryData.GroupMask = (uint)item.Permissions.GroupMask;
update.InventoryData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
update.InventoryData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
update.InventoryData.GroupOwned = item.GroupOwned;
update.InventoryData.TransactionID = transactionID;
update.InventoryData.Type = (sbyte)item.AssetType;
update.InventoryData.InvType = (sbyte)item.InventoryType;
update.InventoryData.Flags = (uint)item.Flags;
update.InventoryData.SaleType = (byte)item.SaleType;
update.InventoryData.SalePrice = item.SalePrice;
update.InventoryData.Name = Utils.StringToBytes(item.Name);
update.InventoryData.Description = Utils.StringToBytes(item.Description);
update.InventoryData.CreationDate = (int)Utils.DateTimeToUnixTime(item.CreationDate);
update.InventoryData.CRC = ItemCRC(item);
Client.Network.SendPacket(update);
return transactionID;
}
public AttachmentPoint AttachedTo(InventoryItem item)
{
lock (attachments)
{
if (attachments.ContainsKey(item.UUID))
{
return attachments[item.UUID].Point;
}
}
return AttachmentPoint.Default;
}
/// <summary>
/// Create a CRC from an InventoryItem
/// </summary>
/// <param name="iitem">The source InventoryItem</param>
/// <returns>A uint representing the source InventoryItem as a CRC</returns>
public static uint ItemCRC(InventoryItem iitem)
{
uint CRC = 0;
// IDs
CRC += iitem.AssetUUID.CRC(); // AssetID
CRC += iitem.ParentUUID.CRC(); // FolderID
CRC += iitem.UUID.CRC(); // ItemID
// Permission stuff
CRC += iitem.CreatorID.CRC(); // CreatorID
CRC += iitem.OwnerID.CRC(); // OwnerID
CRC += iitem.GroupID.CRC(); // GroupID
// CRC += another 4 words which always seem to be zero -- unclear if this is a UUID or what
CRC += (uint)iitem.Permissions.OwnerMask; //owner_mask; // Either owner_mask or next_owner_mask may need to be
CRC += (uint)iitem.Permissions.NextOwnerMask; //next_owner_mask; // switched with base_mask -- 2 values go here and in my
CRC += (uint)iitem.Permissions.EveryoneMask; //everyone_mask; // study item, the three were identical.
CRC += (uint)iitem.Permissions.GroupMask; //group_mask;
// The rest of the CRC fields
CRC += (uint)iitem.Flags; // Flags
CRC += (uint)iitem.InventoryType; // InvType
CRC += (uint)iitem.AssetType; // Type
CRC += (uint)Utils.DateTimeToUnixTime(iitem.CreationDate); // CreationDate
CRC += (uint)iitem.SalePrice; // SalePrice
CRC += (uint)((uint)iitem.SaleType * 0x07073096); // SaleType
return CRC;
}
void UpdateItemInfo(InventoryItem item)
{
foreach (Control c in pnlDetail.Controls)
{
c.Dispose();
}
pnlDetail.Controls.Clear();
pnlItemProperties.Tag = item;
if (item == null)
{
pnlItemProperties.Visible = false;
return;
}
pnlItemProperties.Visible = true;
btnProfile.Enabled = true;
txtItemName.Text = item.Name;
txtItemDescription.Text = item.Description;
txtCreator.AgentID = item.CreatorID;
txtCreator.Tag = item.CreatorID;
txtCreated.Text = item.CreationDate.ToString();
if (item.AssetUUID != UUID.Zero)
{
txtAssetID.Text = item.AssetUUID.ToString();
}
else
{
txtAssetID.Text = String.Empty;
}
Permissions p = item.Permissions;
cbOwnerModify.Checked = (p.OwnerMask & PermissionMask.Modify) != 0;
cbOwnerCopy.Checked = (p.OwnerMask & PermissionMask.Copy) != 0;
cbOwnerTransfer.Checked = (p.OwnerMask & PermissionMask.Transfer) != 0;
cbNextOwnModify.CheckedChanged -= cbNextOwnerUpdate_CheckedChanged;
cbNextOwnCopy.CheckedChanged -= cbNextOwnerUpdate_CheckedChanged;
cbNextOwnTransfer.CheckedChanged -= cbNextOwnerUpdate_CheckedChanged;
cbNextOwnModify.Checked = (p.NextOwnerMask & PermissionMask.Modify) != 0;
cbNextOwnCopy.Checked = (p.NextOwnerMask & PermissionMask.Copy) != 0;
cbNextOwnTransfer.Checked = (p.NextOwnerMask & PermissionMask.Transfer) != 0;
cbNextOwnModify.CheckedChanged += cbNextOwnerUpdate_CheckedChanged;
cbNextOwnCopy.CheckedChanged += cbNextOwnerUpdate_CheckedChanged;
cbNextOwnTransfer.CheckedChanged += cbNextOwnerUpdate_CheckedChanged;
switch (item.AssetType)
{
case AssetType.Texture:
SLImageHandler image = new SLImageHandler(instance, item.AssetUUID, item.Name, IsFullPerm(item));
image.Dock = DockStyle.Fill;
pnlDetail.Controls.Add(image);
break;
case AssetType.Notecard:
Notecard note = new Notecard(instance, (InventoryNotecard)item);
note.Dock = DockStyle.Fill;
note.TabIndex = 3;
note.TabStop = true;
pnlDetail.Controls.Add(note);
note.rtbContent.Focus();
break;
case AssetType.Landmark:
Landmark landmark = new Landmark(instance, (InventoryLandmark)item);
landmark.Dock = DockStyle.Fill;
pnlDetail.Controls.Add(landmark);
break;
case AssetType.LSLText:
ScriptEditor script = new ScriptEditor(instance, (InventoryLSL)item);
script.Dock = DockStyle.Fill;
script.TabIndex = 3;
script.TabStop = true;
pnlDetail.Controls.Add(script);
break;
case AssetType.Gesture:
Guesture gesture = new Guesture(instance, (InventoryGesture)item);
gesture.Dock = DockStyle.Fill;
pnlDetail.Controls.Add(gesture);
break;
}
tabsInventory.SelectedTab = tabDetail;
}
/// <summary>
/// Determine whether the specified <seealso cref="OpenMetaverse.InventoryItem"/> object is equal to the current object
/// </summary>
/// <param name="o">The <seealso cref="OpenMetaverse.InventoryItem"/> object to compare against</param>
/// <returns>true if objects are the same</returns>
public bool Equals(InventoryItem o)
{
return base.Equals(o as InventoryBase)
&& o.AssetType == AssetType
&& o.AssetUUID == AssetUUID
&& o.CreationDate == CreationDate
&& o.Description == Description
&& o.Flags == Flags
&& o.GroupID == GroupID
&& o.GroupOwned == GroupOwned
&& o.InventoryType == InventoryType
&& o.Permissions.Equals(Permissions)
&& o.SalePrice == SalePrice
&& o.SaleType == SaleType
&& o.LastOwnerID == LastOwnerID;
}
public bool IsAttached(InventoryItem item)
{
List<Primitive> myAtt = client.Network.CurrentSim.ObjectsPrimitives.FindAll((Primitive p) => p.ParentID == client.Self.LocalID);
foreach (Primitive prim in myAtt)
{
if (prim.NameValues == null) continue;
UUID invID = UUID.Zero;
for (int i = 0; i < prim.NameValues.Length; i++)
{
if (prim.NameValues[i].Name == "AttachItemID")
{
invID = (UUID)prim.NameValues[i].Value.ToString();
break;
}
}
if (invID == item.UUID)
{
lock (attachments)
{
AttachmentInfo inf = new AttachmentInfo();
inf.InventoryID = item.UUID;
inf.Item = item;
inf.MarkedAttached = true;
inf.Prim = prim;
inf.PrimID = prim.ID;
attachments[invID] = inf;
}
return true;
}
}
return false;
}
public void RequestInventoryAsset(InventoryItem item, bool priority, AssetReceivedCallback callback)
{
RequestInventoryAsset(item.AssetUUID, item.UUID, UUID.Zero, item.OwnerID, item.AssetType, priority, callback);
}
public bool IsWorn(InventoryItem item)
{
bool worn = client.Appearance.IsItemWorn(item) != WearableType.Invalid;
lock (WornItems)
{
if (worn && !WornItems.Contains(item.UUID))
WornItems.Add(item.UUID);
}
return worn;
}
