/*
         *
         */
        private void C_ADD_NODE_BUTTON_Click(object sender, RoutedEventArgs e)
        {
            var    c_pos     = C_MAIN_NODE_VIEW.TS_GetViewCenterPoint();
            String node_name = "NODE" + Model.TrickerStarDataModel.RandToken();

            C_MAIN_NODE_VIEW.TS_AddNode(node_name);
            C_MAIN_NODE_VIEW.TS_SetNodePosition(node_name, c_pos);
            String code = C_MAIN_CODE_TEXT.Text;
            int    i    = code.IndexOf("\r");

            while (i >= 0)

            {
                String param = code.Substring(0, i);
                code = code.Substring(i + 1);
                i    = code.IndexOf("\r");
                if (param.Contains("----"))
                {
                    break;
                }
                if (param.StartsWith("@"))
                {
                    C_MAIN_NODE_VIEW.TS_SetNodeTitle(node_name, param.Substring(1));
                }
                if (param.Contains("INPUT ") && (!param.Contains(">>")))

                {
                    String slot_name     = param.Split(" ", StringSplitOptions.RemoveEmptyEntries)[1];
                    String slot_type_str = param.Split(" ", StringSplitOptions.RemoveEmptyEntries)[3];
                    var    slot_type     = Model.TrickerStarDataModel.GetSlotTypeFromName(slot_type_str);

                    if (slot_type == Model.TrickerStarSlotType.PLACEHOLDER)
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node_name, Model.TrickerStarSlotType.PLACEHOLDER, "PLACE_HOLDER", Model.TrickerStarSlotSide.INPUT);
                    }
                    else
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node_name, slot_type, slot_name, Model.TrickerStarSlotSide.INPUT);
                    }
                }

                if (param.Contains("OUTPUT") && (!param.Contains("<<")))

                {
                    String slot_name     = param.Split(" ", StringSplitOptions.RemoveEmptyEntries)[1];
                    String slot_type_str = param.Split(" ", StringSplitOptions.RemoveEmptyEntries)[3];
                    var    slot_type     = Model.TrickerStarDataModel.GetSlotTypeFromName(slot_type_str);
                    if (slot_type == Model.TrickerStarSlotType.PLACEHOLDER)
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node_name, Model.TrickerStarSlotType.PLACEHOLDER, "PLACE_HOLDER", Model.TrickerStarSlotSide.OUTPUT);
                    }
                    else
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node_name, slot_type, slot_name, Model.TrickerStarSlotSide.OUTPUT);
                    }
                }
            }
            m_NodeCode[node_name] = new String(code.ToCharArray());
        }
Beispiel #2
0
        private async void C_LOAD_BUTTON_Click(object sender, RoutedEventArgs e)
        {
            var picker = new Windows.Storage.Pickers.FileOpenPicker();

            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;

            // Dropdown of file types the user can save the file as

            picker.FileTypeFilter.Add(".json");

            // Default file name if the user does not type one in or select a file to replace

            var t_storagefile = await picker.PickSingleFileAsync();

            if (t_storagefile == null)
            {
                return;
            }

            String json_str;

            using (StorageStreamTransaction transaction = await t_storagefile.OpenTransactedWriteAsync())

            {
                using (Windows.Storage.Streams.DataReader dataReader = new Windows.Storage.Streams.DataReader(transaction.Stream))

                {
                    uint numBytesLoaded = await dataReader.LoadAsync((uint)transaction.Stream.Size);

                    json_str = dataReader.ReadString(numBytesLoaded);

                    await transaction.Stream.FlushAsync();

                    await transaction.CommitAsync();
                }
            }

            var serialize = (Model.TrickerStarNodeViewSerialize)Model.JsonHelper.FromJson(json_str, typeof(Model.TrickerStarNodeViewSerialize));

            foreach (var node in serialize.Nodes)
            {
                C_MAIN_NODE_VIEW.TS_AddNode(node.NodeName);
                C_MAIN_NODE_VIEW.TS_SetNodePosition(node.NodeName, node.Pos);
                C_MAIN_NODE_VIEW.TS_SetNodeTitle(node.NodeName, node.NodeTitle);
                foreach (var inslot in node.InputSlot)
                {
                    if (inslot.SlotType == Model.TrickerStarSlotType.PLACEHOLDER)
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node.NodeName, inslot.SlotType, inslot.SlotName, inslot.SlotSide);
                    }
                    else
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node.NodeName, inslot.SlotType, inslot.SlotName, inslot.SlotSide);
                    }
                    if (inslot.SlotType == Model.TrickerStarSlotType.INSTANCE_VALUE)
                    {
                        C_MAIN_NODE_VIEW.TS_SetSlotValue(node.NodeName, inslot.SlotIndex, inslot.SlotSide, inslot.SlotValue);
                    }
                }
                foreach (var outslot in node.OutputSlot)
                {
                    if (outslot.SlotType == Model.TrickerStarSlotType.PLACEHOLDER)
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node.NodeName, outslot.SlotType, outslot.SlotName, outslot.SlotSide);
                    }
                    else
                    {
                        C_MAIN_NODE_VIEW.TS_AddSlot(node.NodeName, outslot.SlotType, outslot.SlotName, outslot.SlotSide);
                    }
                    if (outslot.SlotType == Model.TrickerStarSlotType.INSTANCE_VALUE)
                    {
                        C_MAIN_NODE_VIEW.TS_SetSlotValue(node.NodeName, outslot.SlotIndex, outslot.SlotSide, outslot.SlotValue);
                    }
                }
            }
            foreach (var line in serialize.Lines)
            {
                C_MAIN_NODE_VIEW.TS_AddLine(line.LineName, line.From.NodeName, line.From.SlotIndex, line.To.NodeName, line.To.SlotIndex);
            }

            foreach (var code in serialize.Codes)
            {
                m_NodeCode[code.NodeName] = code.Code;
            }
            foreach (var group in serialize.Groups)
            {
                m_GroupList.Add(group);
            }
            foreach (var group in serialize.NodeGroups)
            {
                m_NodeGroup[group.NodeName] = new Model.TrickerStarGroupModel()
                {
                    GroupName  = group.GroupName,
                    GroupTitle = group.GroupTitle,
                };
            }
        }