Beispiel #1
0
        public MDIChild(IPolicyStore store, string filename)
        {
            InitializeComponent();

            this.rootNode.Text = Path.GetFileName(filename);
            this.rootNode.Object = store;

            this.Text = this.rootNode.Text;

            CustomGXNode policies = new CustomGXNode("Policies", store);
            policies.Style = DevComponents.Tree.NodeStyles.Blue;
            this.rootNode.Nodes.Add(policies);

            this.gxPolicyTree.AfterNodeSelect += new DevComponents.Tree.TreeGXNodeEventHandler(gxPolicyTree_AfterNodeSelect);

            foreach (IPolicy policy in store.Reader.Policies)
            {
                AddPolicyToTree(policies, policy);
            }

            this.rootNode.ExpandAll();
        }
Beispiel #2
0
        private void AddExpressions(IPolicyObject policyobject, CustomGXNode rulenode)
        {
            if (policyobject is ICondition)
            {
                ICondition condition = policyobject as ICondition;
                CustomGXNode cnode = rulenode;

                CustomGXNode conditionnode = new CustomGXNode(condition["ShortName"], condition);
                //TreeGxNodeControl control = new TreeGxNodeControl(condition["ShortName"], new ConditionControl(condition), Color.FromArgb(255,231,156));
                //conditionnode.HostedControl = control;

                conditionnode.Style = DevComponents.Tree.NodeStyles.Yellow;
                rulenode.Nodes.Add(conditionnode);
            }
            else
            if (policyobject is IConditionGroup)
            {
                IConditionGroup group = policyobject as IConditionGroup;
                foreach (IPolicyObject condition in group.Conditions)
                {
                    AddExpressions(condition, rulenode);
                }
            }
        }
Beispiel #3
0
        private void AddPolicyToTree(DevComponents.Tree.Node policies, IPolicy policy)
        {
            /*DevComponents.Tree.Node policyrootnode = new DevComponents.Tree.Node();
            policyrootnode.Text = policy.Name;
            policies.Nodes.Add(policyrootnode);*/

            List<CustomGXNode> conditions = new List<CustomGXNode>();
            List<CustomGXNode> channels = new List<CustomGXNode>();
            List<IPolicyChannel> policychannels = new List<IPolicyChannel>();

            foreach (IPolicyRule rule in policy.Rules)
            {
                CustomGXNode rulenode = new CustomGXNode(rule.Name, rule);
                rulenode.Style = DevComponents.Tree.NodeStyles.Blue;
                policies.Nodes.Add(rulenode);

                CustomGXNode conditionsnode = new CustomGXNode("Conditions", rule.Conditions);
                conditionsnode.Style = DevComponents.Tree.NodeStyles.Yellow;
                rulenode.Nodes.Add(conditionsnode);

                CustomGXNode channelsnode = new CustomGXNode("Channels", rule.Channels);
                channelsnode.Style = DevComponents.Tree.NodeStyles.PurpleMist;
                rulenode.Nodes.Add(channelsnode);

                foreach (IPolicyChannel channel in rule.Channels)
                {
                    AddChannel(channel, channels, policychannels);
                }
                
                foreach (IPolicyObject policyobject in rule.Conditions)
                {
                    AddExpressions(policyobject, conditionsnode);
                }

                foreach (CustomGXNode node in channels)
                {
                    channelsnode.Nodes.Add(node);
                }
            }
        }
Beispiel #4
0
        private void AddChannel(IPolicyChannel channel, List<CustomGXNode> channels, List<IPolicyChannel> policychannels)
        {
            foreach (IPolicyChannel duplicate in policychannels)
            {
                if (channel.Name == duplicate.Name)
                    return;
            }

            policychannels.Add(channel);

            CustomGXNode node = new CustomGXNode(channel.Name, channel);
            node.Style = DevComponents.Tree.NodeStyles.PurpleMist;
            //MatrixTableControl routingTableControl = new MatrixTableControl(channel);
            //routingTableControl.Refresh();
            //TreeGxNodeControl control = new TreeGxNodeControl(channel.Name, routingTableControl, Color.FromArgb(198, 186, 206));
            //node.HostedControl = control;

            channels.Add(node);

            /*foreach (IRoutingTable table in channel.Routing)
            {
                DevComponents.Tree.Node senders = new DevComponents.Tree.Node();
                senders.Text = "Senders";
                node.Nodes.Add(senders);

                DevComponents.Tree.Node receivers = new DevComponents.Tree.Node();
                receivers.Text = "Receivers";
                node.Nodes.Add(receivers);

                AddAddresses(senders, table.Senders);
                AddAddresses(receivers, table.Recipients);
            }*/
        }
Beispiel #5
0
        private void AddAddresses(CustomGXNode usernode, IAddressGroup group)
        {
            foreach (IPolicyObject policyobject in group)
            {
                CustomGXNode groupnode = new CustomGXNode(policyobject.Name, policyobject);
                usernode.Nodes.Add(groupnode);

                //All the addresses
                /*if (policyobject is IAddressCollection)
                {
                    IAddressCollection collection = policyobject as IAddressCollection;
                    foreach (IAddress address in collection)
                    {
                        DevComponents.Tree.Node users = new DevComponents.Tree.Node();
                        users.Text = address.Value;
                        groupnode.Nodes.Add(users);
                    }
                }*/
            }
        }