Exemple #1
0
        public List <INodeItem> PickUpInOutItem(INodeParent item)
        {
            this.pickedUpItem = item;
            List <INodeItem> olditems = new List <INodeItem>();

            if (connectedNodes.ContainsKey(item))
            {
                List <INodeItem> needClear = new List <INodeItem>();
                for (int i = 0; i < connectedNodes[item].Count; i++)
                {
                    INodeItem nodeItem = connectedNodes[item][i];
                    needClear.Add(nodeItem);

                    INodeItem target = nodeItem.ConnectedNode;
                    connectedNodes[target.Body].Remove(target);
                    Debug.Log(connectedNodes[item][i].Detach());

                    olditems.Add(nodeItem);
                    olditems.Add(target);
                }

                for (int i = 0; i < needClear.Count; i++)
                {
                    connectedNodes[item].Remove(needClear[i]);
                }
            }
            return(olditems);
        }
Exemple #2
0
        void BuildViewCtrl_Populated(INodeItem nodeItem, NodeItemView node, bool bPopulatedFieldsOnly)
        {
            if (null == nodeItem)
            {
                return;
            }

            ISchemaItem  item    = nodeItem.Schema;
            NodeItemView subNode = null;

            if ((item.IsGroup && nodeItem.AnySubItemHasRepetition) || item.IsMessage || (!item.RepetitionContainerNode && !item.StructureDefOnlyNode))
            {
                if (null == item)
                {
                    return;//dead end
                }

                subNode = new NodeItemView();

                FillViewInfo(nodeItem, subNode);
                BuildViewCtrl_Fields(nodeItem, subNode, bPopulatedFieldsOnly);

                node.Nodes.Add(subNode);
            }
            else
            {
                subNode = node;
            }

            foreach (INodeItem sub in nodeItem.Nodes)
            {
                BuildViewCtrl_Populated(sub, subNode, bPopulatedFieldsOnly);
            }
        }
Exemple #3
0
        void BuildViewCtrl_Schema(INodeItem nodeItem, NodeItemView node)
        {
            if (null == nodeItem)
            {
                return;
            }

            ISchemaItem  item    = nodeItem.Schema;
            NodeItemView subNode = null;

            if (!item.RepetitionContainerNode && (item.StructureDefOnlyNode || item.IsMessage))
            {
                if (null == item)
                {
                    return;//dead end
                }

                subNode = new NodeItemView();

                FillViewInfo(nodeItem, subNode);
                BuildViewCtrl_Fields(nodeItem, subNode, false);

                node.Nodes.Add(subNode);
            }
            else
            {
                subNode = node;
            }

            foreach (INodeItem sub in nodeItem.Nodes)
            {
                BuildViewCtrl_Schema(sub, subNode);
            }
        }
Exemple #4
0
        public static void Add(INodeItem item)
        {
            if (item is Sensor)
            {
                if (_sensors.Contains(item))
                    return;

                _sensors.Add(item as Sensor);
            }
        }
        public INodeItem Detach()
        {
            INodeItem outItem = ConnectedNode;

            if (ConnectedNode != null)
            {
                ConnectedNode.ConnectedNode = null;
                ConnectedNode = null;
            }
            return(outItem);
        }
Exemple #6
0
        public void AddValue(INodeItem nodeItem)
        {
            if (!(nodeItem is Sensor))
                return;

            Sensor sensor = (Sensor)nodeItem;

            try
            {

                string query = "SELECT Id FROM Sensors WHERE Name = @name";

                SqlCommand cmd = new SqlCommand(query, _connection);
                cmd.Parameters.AddWithValue("name", sensor.Name);

                var sensorId = cmd.ExecuteScalar();

                if (sensorId == null)
                {
                    string insertQuery = "INSERT INTO Sensors (Name, Description, Type) VALUES (@name, @description, @type)";

                    SqlCommand insertCmd = new SqlCommand(insertQuery, _connection);
                    insertCmd.Parameters.AddWithValue("name", sensor.Name);
                    insertCmd.Parameters.AddWithValue("description", sensor.Description);
                    insertCmd.Parameters.AddWithValue("type", sensor.Type);

                    insertCmd.ExecuteNonQuery();
                    sensorId = cmd.ExecuteScalar();
                }

                string readingQuery = "INSERT INTO Readings (SensorId, Time, Value) VALUES (@sensorId, @time, @value)";

                SqlCommand readingCmd = new SqlCommand(readingQuery, _connection);
                readingCmd.Parameters.AddWithValue("sensorId", sensorId);
                readingCmd.Parameters.AddWithValue("time", sensor.Time);
                readingCmd.Parameters.AddWithValue("value", sensor.Value);

                readingCmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                string msg = string.Format("Unable to insert reading into database for sensor {0}.", sensor.Name);
                ErrorLogger.LogException(LogLevel.Error, msg, ex);

                return;
            }
        }
Exemple #7
0
        void BuildViewCtrl_All(INodeItem nodeItem, NodeItemView node)
        {
            if (null == nodeItem)
            {
                return;
            }

            ISchemaItem  item    = nodeItem.Schema;
            NodeItemView subNode = null;

            bool IsSchemaItem             = (!item.RepetitionContainerNode && (item.StructureDefOnlyNode || item.IsMessage));
            bool IsContentItem            = ((item.IsGroup && nodeItem.AnySubItemHasRepetition) || item.IsMessage || (!item.RepetitionContainerNode && !item.StructureDefOnlyNode));
            bool ParentContainsContentRep = false;

            if (nodeItem.ParentItem != null)
            {
                if (nodeItem.ParentItem.Schema.RepetitionContainerNode)
                {
                    ParentContainsContentRep = nodeItem.ParentItem.Nodes.Count > 1;
                }
            }

            if ((IsSchemaItem && !ParentContainsContentRep) || IsContentItem)
            {
                if (null == item)
                {
                    return;//dead end
                }

                subNode = new NodeItemView();

                FillViewInfo(nodeItem, subNode);
                BuildViewCtrl_Fields(nodeItem, subNode, false);

                node.Nodes.Add(subNode);
            }
            else
            {
                subNode = node;
            }

            foreach (INodeItem sub in nodeItem.Nodes)
            {
                BuildViewCtrl_All(sub, subNode);
            }
        }
Exemple #8
0
 public bool FindConnectableObject()
 {
     if (pickedUpItem != null)
     {
         INodeItem tempNode;
         foreach (var item in pickedUpItem.ChildNodes)
         {
             if (FindInstallableNode(item, out tempNode))
             {
                 activeNode = item;
                 targetNode = tempNode;
                 return(true);
             }
         }
     }
     activeNode = null;
     targetNode = null;
     return(false);
 }
Exemple #9
0
        void FillViewInfo(INodeItem nodeItem, NodeItemView tvc)
        {
            if (null == nodeItem)
            {
                return;
            }

            ISchemaItem schema = nodeItem.Schema;

            tvc.Name  = schema.ItemName;
            tvc.Text  = schema.ItemName;
            tvc.Tag   = null;
            tvc.Model = this;

            if (schema.IsGroup || schema.IsMessage)
            {
                tvc.Expand = true;
            }
        }
Exemple #10
0
 private bool FindInstallableNode(INodeItem item, out INodeItem node)
 {
     Collider[] colliders = Physics.OverlapSphere(item.Pos, sphereRange, LayerMask.GetMask(LayerConst.nodeLayer));
     if (colliders != null && colliders.Length > 0)
     {
         foreach (var collider in colliders)
         {
             NodeItemBehaiver tempNode = collider.GetComponent <NodeItemBehaiver>();
             //主被动动连接点,非自身点,相同名,没有建立连接
             if (tempNode.Body != item.Body && tempNode.Info.nodeName == item.Info.nodeName && tempNode.ConnectedNode == null)
             {
                 if (tempNode.connectAble.Find((x) => x.itemName == item.Body.Name && x.nodeId == item.Info.nodeID) != null)
                 {
                     node = tempNode;
                     return(true);
                 }
             }
         }
     }
     node = null;
     return(false);
 }
Exemple #11
0
        public void PutDownInOutItem(bool connected)
        {
            if (connected)
            {
                if (!connectedNodes.ContainsKey(pickedUpItem))
                {
                    connectedNodes[pickedUpItem] = new List <INodeItem>();
                }

                connectedNodes[pickedUpItem].Add(activeNode);

                if (!connectedNodes.ContainsKey(TargetNode.Body))
                {
                    connectedNodes[TargetNode.Body] = new List <INodeItem>();
                }

                connectedNodes[TargetNode.Body].Add(targetNode);
            }

            pickedUpItem = null;
            targetNode   = null;
            activeNode   = null;
        }
 public bool Attach(INodeItem item)
 {
     item.ConnectedNode = this;
     ConnectedNode      = item;
     return(true);
 }
Exemple #13
0
        void BuildViewCtrl_Fields(INodeItem nodeItem, NodeItemView node, bool bPopulatedFieldsOnly)
        {
            for (int seq = 0; seq < nodeItem.Fields.Count; seq++)
            {
                if (!bPopulatedFieldsOnly)
                {
                    if (nodeItem.Fields[seq].Repetitions.Count == 0)
                    {
                        NodeItemView subNode = new NodeItemView();
                        subNode.Name        = nodeItem.Schema.ItemName + "-" + (seq + 1);
                        subNode.Text        = nodeItem.Schema.ItemName + "-" + (seq + 1);
                        subNode.Text       += " (" + nodeItem.Fields[seq].FieldFactory.NameFromType + ")";
                        subNode.Value       = "";
                        subNode.Tag         = nodeItem.Fields[seq];
                        subNode.Model       = this;
                        subNode.DataType    = nodeItem.Fields[seq].FieldFactory.NameFromType;
                        subNode.NodeType    = "field";
                        subNode.IsPopulated = false;

                        node.Nodes.Add(subNode);
                    }
                }

                for (int rep = 0; rep < nodeItem.Fields[seq].Repetitions.Count; rep++)
                {
                    bool subcomphasvalue = false;

                    NodeItemView subNode = new NodeItemView();
                    subNode.Name = nodeItem.Schema.ItemName + "-" + (seq + 1);
                    subNode.Text = nodeItem.Schema.ItemName + "-" + (seq + 1);

                    IField f = nodeItem.Fields[seq].Repetitions[rep];

                    if (!f.IsEmpty)
                    {
                        if (!f.HasSubComponents)
                        {
                            subNode.NodeType = "field";
                        }

                        subNode.IsPopulated = true;

                        if (rep > 0)
                        {
                            subNode.Text += "(rep " + rep + ")" + ": " + f.Value;
                        }
                        else
                        {
                            subNode.Text += ": " + f.Value;
                        }
                        subNode.Rep   = rep;
                        subNode.Value = f.Value;
                        subNode.Tag   = f;
                        subNode.Model = this;
                    }

                    if (f.HasSubComponents)
                    {
                        //add parent's wholesome value
                        {
                            string DeepValue = f.DeepValue;
                            if (!string.IsNullOrEmpty(DeepValue))
                            {
                                subNode.IsPopulated = true;
                                if (rep > 0)
                                {
                                    subNode.Text += "(rep " + rep + ")" + ": " + DeepValue;
                                }
                                else
                                {
                                    subNode.Text += ": " + DeepValue;
                                }
                                subNode.Rep   = rep;
                                subNode.Value = DeepValue;
                                subNode.Tag   = f;
                                subNode.Model = this;
                            }
                        }

                        for (int subcomp = 0; subcomp < f.Components.Length; subcomp++)
                        {
                            NodeItemView subcompNode = new NodeItemView();
                            subcompNode.Name  = nodeItem.Schema.ItemName + "-" + (seq + 1) + "-" + (subcomp + 1).ToString();
                            subcompNode.Text  = nodeItem.Schema.ItemName + "-" + (seq + 1) + "-" + (subcomp + 1).ToString();
                            subcompNode.Tag   = f.Components[subcomp];
                            subcompNode.Model = this;

                            if (!f.Components[subcomp].IsEmpty)
                            {
                                subcompNode.NodeType    = "field";
                                subcompNode.IsPopulated = true;

                                if (rep > 0)
                                {
                                    subcompNode.Text += "(rep " + rep + ")" + ": " + f.Components[subcomp].Value;
                                }
                                else
                                {
                                    subcompNode.Text += ": " + f.Components[subcomp].Value;
                                }
                                subcompNode.Rep   = rep;
                                subcompNode.Value = f.Components[subcomp].Value;
                                subcompNode.Tag   = f;
                                subcompNode.Model = this;
                                subcomphasvalue   = true;
                            }
                            subNode.Nodes.Add(subcompNode);

                            //
                            if (f.Components[subcomp].HasSubComponents)
                            {
                                for (int subcomp1 = 0; subcomp1 < f.Components[subcomp].Components.Length; subcomp1++)
                                {
                                    NodeItemView subcompNode1 = new NodeItemView();
                                    subcompNode1.Name  = nodeItem.Schema.ItemName + "-" + (seq + 1) + "-" + subcomp + "-" + subcomp1;
                                    subcompNode1.Text  = nodeItem.Schema.ItemName + "-" + (seq + 1) + "-" + subcomp + "-" + subcomp1;
                                    subcompNode1.Tag   = f.Components[subcomp].Components[subcomp1];
                                    subcompNode1.Model = this;

                                    if (!f.Components[subcomp].Components[subcomp1].IsEmpty)
                                    {
                                        subcompNode.NodeType    = "field";
                                        subcompNode.IsPopulated = true;

                                        if (rep > 0)
                                        {
                                            subcompNode.Text += "(rep " + rep + ")" + ": " + f.Components[subcomp].Components[subcomp1].Value;
                                        }
                                        else
                                        {
                                            subcompNode.Text += ": " + f.Components[subcomp].Components[subcomp1].Value;
                                        }
                                        subcompNode.Rep   = rep;
                                        subcompNode.Value = f.Components[subcomp].Components[subcomp1].Value;
                                        subcompNode.Tag   = f;
                                        subcompNode.Model = this;
                                        subcomphasvalue   = true;
                                    }
                                    subcompNode.Nodes.Add(subcompNode1);
                                }
                            }
                        }
                    }

                    subNode.Text    += " (" + nodeItem.Fields[seq].FieldFactory.NameFromType + ")";
                    subNode.DataType = nodeItem.Fields[seq].FieldFactory.NameFromType;
                    if (!f.IsEmpty || !bPopulatedFieldsOnly || subcomphasvalue)
                    {
                        node.Nodes.Add(subNode);
                    }
                }
            }
        }