private void ListView_Configurations_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (this.ListView_Configurations.SelectedItems.Count != 1)
            {
                this.ListView_Configurations.ContextMenuStrip = this.ContextMenuStrip_ConfigurationsMenu;

                if (this.currentEmoteConfiguration != null)
                {
                    this.currentEmoteConfiguration.DefaultEmotes = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_DefaultEmotes.Nodes).ToList();
                    this.currentEmoteConfiguration.CombatEmotes  = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_CombatEmotes.Nodes).ToList();
                    this.currentEmoteConfiguration.FeedingEmotes = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_FeedingEmotes.Nodes).ToList();
                }

                this.currentEmoteConfiguration = null;
                this.ClearTreeViews();
                this.DisableItemsOfToolStripExcept(
                    this.ToolStrip_Main,
                    this.ToolStripItemsThatNeedNoActiveConfiguration.ToArray()
                    );
            }
            else
            {
                this.ListView_Configurations.ContextMenuStrip = this.ContextMenuStrip_Configuration;
                this.currentEmoteConfiguration = (EmoteConfiguration)this.ListView_Configurations.SelectedItems[0].Tag;
                this.ClearTreeViews();
                this.DisableItemsOfToolStripExcept(
                    this.ToolStrip_Main,
                    this.ToolStripItemsThatNeedNoActiveEmote.ToArray()
                    );

                this.TreeView_DefaultEmotes.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(this.currentEmoteConfiguration.DefaultEmotes).ToArray());
                this.TreeView_CombatEmotes.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(this.currentEmoteConfiguration.CombatEmotes).ToArray());
                this.TreeView_FeedingEmotes.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(this.currentEmoteConfiguration.FeedingEmotes).ToArray());
            }
        }
        private void Save()
        {
            if (this.currentEmoteConfiguration != null)
            {
                this.currentEmoteConfiguration.DefaultEmotes = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_DefaultEmotes.Nodes).ToList();
                this.currentEmoteConfiguration.CombatEmotes  = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_CombatEmotes.Nodes).ToList();
                this.currentEmoteConfiguration.FeedingEmotes = TreeNodeConverter.TreeNodeCollectionToEmoteNodes(this.TreeView_FeedingEmotes.Nodes).ToList();
            }

            this.currentEmotes.EmoteConfigurations.Clear();

            foreach (ListViewItem item in this.ListView_Configurations.Items)
            {
                this.currentEmotes.EmoteConfigurations.Add((EmoteConfiguration)item.Tag);
            }

            // Speichern (xml)
            while (!this.currentEmotes.Save())
            {
                if (MessageBox.Show(Resources.Message_SavingFailed, Application.ProductName, MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Exclamation) != DialogResult.Retry)
                {
                    break;
                }
            }

            // Exportieren (lua)
            while (!this.currentEmotes.Export(this.currentEmotes.GetType() == typeof(DefaultEmotes)))
            {
                if (MessageBox.Show(Resources.Message_SavingFailed, Application.ProductName, MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Exclamation) != DialogResult.Retry)
                {
                    break;
                }
            }
        }
Example #3
0
        /// <summary>
        /// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
        /// used as generic method and casting is not required.
        /// <example>
        /// treenodeconverter.ConvertTo<int>(context, culture, value);
        /// </example>
        /// </summary>
        public static T ConvertTo <T>(this TreeNodeConverter treenodeconverter, System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
        {
            if (treenodeconverter == null)
            {
                throw new ArgumentNullException("treenodeconverter");
            }

            return((T)treenodeconverter.ConvertTo(context, culture, value, typeof(T)));
        }
Example #4
0
        /// <summary>
        /// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
        /// used as generic method and casting is not required.
        /// <example>
        /// typeconverter.ConvertTo<int>(value);
        /// </example>
        /// </summary>
        public static T ConvertTo <T>(this TreeNodeConverter typeconverter, Object value)
        {
            if (typeconverter == null)
            {
                throw new ArgumentNullException("typeconverter");
            }

            return((T)typeconverter.ConvertTo(value, typeof(T)));
        }
        private TreeNode AddTreeNode(EmoteNode emoteNode)
        {
            TreeNode node = new TreeNode(emoteNode.Text);

            node.Tag = emoteNode.Properties;
            node.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(emoteNode.ChildNodes).ToArray());

            this.currentTreeView.Nodes.Add(node);

            return(node);
        }
Example #6
0
        private static async Task <T> ReadFromStorage <T>(string key, IObjectStorage strage, JsonConverter converter = null)
        {
            if (converter == null)
            {
                converter = new TreeNodeConverter();
            }

            var treeLeftStream = strage.Get(key);

            using (var textStream = new StreamReader(treeLeftStream))
            {
                var data = await textStream.ReadToEndAsync();

                return(JsonConvert.DeserializeObject <T>(data, converter));
            }
        }
        private TreeNode AddTreeNode(EmoteNode emoteNode, TreeNode parentNode)
        {
            if (parentNode == null)
            {
                return(this.AddTreeNode(emoteNode));
            }

            TreeNode node = new TreeNode(emoteNode.Text);

            node.Tag = emoteNode.Properties;
            node.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(emoteNode.ChildNodes).ToArray());

            parentNode.Nodes.Add(node);

            return(node);
        }
        /// <summary>
        /// Gibt einen Emote-TreeNode im EmoteOutput-Control aus.
        /// </summary>
        /// <param name="treeNode">Der TreeNode, der ausgegeben werden soll.</param>
        private void ShowEmoteOutputByTreeNode(TreeNode treeNode)
        {
            EmoteNode emoteNode = TreeNodeConverter.TreeNodeToEmoteNode(treeNode);

            // Das hier ist nur eine Notlösung, um beim Markieren eines untergeordneten Emotes
            // trotzdem den kompletten Emote-Text zu sehen. Besser wäre es, wenn beim Flachklopfen
            // des EmoteNodes die übergeordneten Emotes berücksichtigt werden könnten (nur fraglich,
            // ob das dann dort sinnvoll wäre). Wichtig wäre dann auch, die Properties der
            // übergeordneten Emotes zu bekommen, weil die im Moment gar nicht übergeben werden
            // können. Deshalb werden die Bedingungen erst ab dem markierten Emote angezeigt.
            if (treeNode.Parent != null)
            {
                emoteNode.Text = treeNode.Parent.FullPath + " " + emoteNode.Text;
            }

            this.EmoteOutput.PetName = this.currentEmoteConfiguration.Name;
            this.EmoteOutput.Clear();
            this.EmoteOutput.AddEmoteNode(emoteNode);
        }
 private void AddTreeNodeRange(ref TreeView treeView, List <EmoteNode> emoteNodeSet)
 {
     treeView.Nodes.AddRange(TreeNodeConverter.EmoteNodesToTreeNodes(emoteNodeSet).ToArray());
 }