public AvatarAttachment(AvatarAttachment attach)
 {
     AttachPoint = attach.AttachPoint;
     ItemID = attach.ItemID;
     AssetID = attach.AssetID;
 }
        public AvatarAppearance WearFolder(AvatarAppearance avappearance, UUID user, UUID folderOwnerID)
        {
            InventoryFolderBase Folder2Wear = m_InventoryService.GetFolderByOwnerAndName(folderOwnerID,
                                                                                         m_forceUserToWearFolderName);
            if (Folder2Wear != null)
            {
                List<InventoryItemBase> itemsInFolder = m_InventoryService.GetFolderItems(UUID.Zero, Folder2Wear.ID);

                InventoryFolderBase appearanceFolder = m_InventoryService.GetFolderForType(user, InventoryType.Wearable,
                                                                                           AssetType.Clothing);

                InventoryFolderBase folderForAppearance = new InventoryFolderBase(UUID.Random(), "GridWear", user, -1,
                                                                                  appearanceFolder.ID, 1);
                List<InventoryFolderBase> userFolders = m_InventoryService.GetFolderFolders(user, appearanceFolder.ID);
                bool alreadyThere = false;
                List<UUID> items2RemoveFromAppearence = new List<UUID>();
                List<UUID> toDelete = new List<UUID>();
                foreach (InventoryFolderBase folder in userFolders)
                {
                    if (folder.Name == folderForAppearance.Name)
                    {
                        List<InventoryItemBase> itemsInCurrentFolder = m_InventoryService.GetFolderItems(UUID.Zero,
                                                                                                         folder.ID);
                        foreach (InventoryItemBase itemBase in itemsInCurrentFolder)
                        {
                            items2RemoveFromAppearence.Add(itemBase.AssetID);
                            items2RemoveFromAppearence.Add(itemBase.ID);
                            toDelete.Add(itemBase.ID);
                        }
                        folderForAppearance = folder;
                        alreadyThere = true;
                        m_InventoryService.DeleteItems(user, toDelete);
                        break;
                    }
                }

                if (!alreadyThere)
                    m_InventoryService.AddFolder(folderForAppearance);
                else
                {
                    // we have to remove all the old items if they are currently wearing them
                    for (int i = 0; i < avappearance.Wearables.Length; i++)
                    {
                        AvatarWearable wearable = avappearance.Wearables[i];
                        for (int ii = 0; ii < wearable.Count; ii++)
                        {
                            if (items2RemoveFromAppearence.Contains(wearable[ii].ItemID))
                            {
                                avappearance.Wearables[i] = AvatarWearable.DefaultWearables[i];
                                break;
                            }
                        }
                    }

                    List<AvatarAttachment> attachments = avappearance.GetAttachments();
                    foreach (AvatarAttachment attachment in attachments)
                    {
                        if ((items2RemoveFromAppearence.Contains(attachment.AssetID)) ||
                            (items2RemoveFromAppearence.Contains(attachment.ItemID)))
                        {
                            avappearance.DetachAttachment(attachment.ItemID);
                        }
                    }
                }

                // ok, now we have a empty folder, lets add the items
                foreach (InventoryItemBase itemBase in itemsInFolder)
                {
                    InventoryItemBase newcopy = m_InventoryService.InnerGiveInventoryItem(user, folderOwnerID, itemBase,
                                                                                          folderForAppearance.ID,
                                                                                          true, true);

                    if (newcopy.InvType == (int) InventoryType.Object)
                    {
                        byte[] attobj = m_AssetService.GetData(newcopy.AssetID.ToString());

                        if (attobj != null)
                        {
                            string xmlData = Utils.BytesToString(attobj);
                            XmlDocument doc = new XmlDocument();
                            try
                            {
                                doc.LoadXml(xmlData);
                            }
                            catch
                            {
                                continue;
                            }

                            if (doc.FirstChild.OuterXml.StartsWith("<groups>") ||
                                (doc.FirstChild.NextSibling != null &&
                                 doc.FirstChild.NextSibling.OuterXml.StartsWith("<groups>")))
                                continue;

                            string xml = "";
                            if ((doc.FirstChild.NodeType == XmlNodeType.XmlDeclaration) &&
                                (doc.FirstChild.NextSibling != null))
                                xml = doc.FirstChild.NextSibling.OuterXml;
                            else
                                xml = doc.FirstChild.OuterXml;
                            doc.LoadXml(xml);

                            if (doc.DocumentElement == null) continue;

                            XmlNodeList xmlNodeList = doc.DocumentElement.SelectNodes("//State");
                            int attchspot;
                            if ((xmlNodeList != null) && (int.TryParse(xmlNodeList[0].InnerText, out attchspot)))
                            {
                                AvatarAttachment a = new AvatarAttachment(attchspot, newcopy.ID, newcopy.AssetID);
                                Dictionary<int, List<AvatarAttachment>> ac = avappearance.Attachments;

                                if (!ac.ContainsKey(attchspot))
                                    ac[attchspot] = new List<AvatarAttachment>();

                                ac[attchspot].Add(a);
                                avappearance.Attachments = ac;
                            }
                        }
                    }
                    m_InventoryService.AddItem(newcopy);
                }
            }
            return avappearance;
        }
 public void SetAttachments(ISceneEntity[] attachments)
 {
     ClearAttachments();
     foreach (ISceneEntity e in attachments)
     {
         if (e.RootChild.FromUserInventoryItemID == UUID.Zero)
             continue;
         AvatarAttachment a = new AvatarAttachment(e.GetAttachmentPoint(), e.RootChild.FromUserInventoryItemID,
                                                   e.RootChild.FromUserInventoryAssetID);
         lock (_attachmentslock)
         {
             if (!m_attachments.ContainsKey(e.GetAttachmentPoint()))
                 m_attachments.Add(e.GetAttachmentPoint(), new List<AvatarAttachment>());
             m_attachments[e.GetAttachmentPoint()].Add(a);
         }
     }
 }
 /// <summary>
 ///     Replace the attachment
 /// </summary>
 /// <param name="attach"></param>
 /// <returns>Whether attachments changed</returns>
 internal bool ReplaceAttachment(AvatarAttachment attach)
 {
     lock (_attachmentslock)
     {
         bool result = true;
         if (m_attachments.ContainsKey(attach.AttachPoint))
         {
             if (m_attachments[attach.AttachPoint].Contains(attach))
                 result = false;
         }
         m_attachments[attach.AttachPoint] = new List<AvatarAttachment> {attach};
         return result;
     }
 }
        internal void AppendAttachment(AvatarAttachment attach)
        {
            lock (_attachmentslock)
            {
                if (!m_attachments.ContainsKey(attach.AttachPoint))
                    m_attachments[attach.AttachPoint] = new List<AvatarAttachment>();

                // 21/07/2014 Added to prevent Attachments to be added more then once
                foreach (AvatarAttachment prev in m_attachments[attach.AttachPoint])
                {
                    if (prev.ItemID == attach.ItemID)
                        return;
                }

                m_attachments[attach.AttachPoint].Add(attach);
            }
        }
 internal void AppendAttachment(AvatarAttachment attach)
 {
     lock (m_attachments)
     {
         if (!m_attachments.ContainsKey(attach.AttachPoint))
             m_attachments[attach.AttachPoint] = new List<AvatarAttachment>();
         m_attachments[attach.AttachPoint].Add(attach);
     }
 }
 public AvatarAttachment(AvatarAttachment attach)
 {
     AttachPoint = attach.AttachPoint;
     ItemID      = attach.ItemID;
     AssetID     = attach.AssetID;
 }