internal void SetIsVariable(EngineNS.UISystem.UIElement element, bool setValue)
        {
            var category = Macross_Client.GetCategory(MacrossPanel.UIElementVariableCategoryName);

            var elementType = element.GetType();
            var variables   = category.Items.ToArray();

            for (int i = 0; i < variables.Length; i++)
            {
                var pro = variables[i].PropertyShowItem as UIElementVariableCategoryItemPropertys;
                if (pro == null)
                {
                    continue;
                }

                if (pro.ElementId == element.Id)
                {
                    if (!setValue)
                    {
                        category.Items.Remove(variables[i]);
                    }
                    return;
                }
            }

            if (setValue)
            {
                // 没找到则创建一个
                var item = new Macross.CategoryItem(null, category);
                item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;
                BindingOperations.SetBinding(item, Macross.CategoryItem.NameProperty, new Binding("Name")
                {
                    Source = element.Initializer, Mode = BindingMode.TwoWay
                });
                item.CanDrag     = true;
                item.InitTypeStr = "UI_UIElement_Variable";
                var data = new UIElementVariableCategoryItemInitData();
                data.Reset();
                data.UIElement   = element;
                data.ElementType = elementType;
                data.UIElementId = element.Id;
                data.Deleteable  = false;
                item.Initialize(Macross_Client, data);

                category.Items.Add(item);
            }
        }
        internal async Task SetPropertyCustomBindOperation(EngineNS.UISystem.UIElement uiElement, string bindPropertyName, Type bindPropertyType)
        {
            Macross.Category category = Macross_Client.GetCategory(MacrossPanel.UIBindFuncCategoryName);
            var item = new Macross.CategoryItem(null, category);

            item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;
            item.CanDrag          = false;
            item.InitTypeStr      = "UI_UIElement_PropertyCustomBind";
            var data = new UIElementPropertyCustomBindCategoryitemInitData();

            data.Reset();
            data.UIElement    = uiElement;
            data.UIElementId  = uiElement.Id;
            data.PropertyName = bindPropertyName;
            data.PropertyType = bindPropertyType;
            data.FunctionName = $"UIBindFunc_{bindPropertyName}_{uiElement.Id.ToString().Replace("-","_")}_{item.Id.ToString().Replace("-", "_")}";// bindFunctionName;
            item.Initialize(Macross_Client, data);
            category.Items.Add(item);
            uiElement.PropertyBindFunctions[bindPropertyName] = data.FunctionName;

            var varItemPro     = item.PropertyShowItem as UIElementPropertyCustomBindCategoryItemPropertys;
            var nodesContainer = await Macross_Client.CreateNodesContainer(item);

            var nodeType = typeof(CodeDomNode.MethodCustom);
            var csParam  = new CodeDomNode.MethodCustom.MethodCustomConstructParam()
            {
                CSType             = Macross_Client.CSType,
                HostNodesContainer = nodesContainer.NodesControl,
                ConstructParam     = "",
                MethodInfo         = varItemPro.MethodInfo,
                IsShowProperty     = false,
            };
            var node = nodesContainer.NodesControl.AddOrigionNode(nodeType, csParam, 0, 0);

            node.IsDeleteable            = false;
            node.NodeNameAddShowNodeName = false;
            nodesContainer.Save();

            await Macross_Client.ShowNodesContainer(item);
        }
Esempio n. 3
0
        private void MenuItem_CustomEvent_Click(object sender, RoutedEventArgs e)
        {
            Macross.Category category;
            if (!mCategoryDic.TryGetValue(UICustomEventCategoryName, out category))
            {
                return;
            }

            int    i          = 0;
            string newName    = "NewEvent_";
            bool   repetition = false;

            do
            {
                repetition = false;
                foreach (var cItem in category.Items)
                {
                    if (newName + i == cItem.Name)
                    {
                        repetition = true;
                        i++;
                        break;
                    }
                }
            } while (repetition);
            var item = new Macross.CategoryItem(null, category);

            item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;// Macross.CategoryItem.enCategoryItemType.CustomFunction;
            item.Name             = newName + i;
            item.CanDrag          = true;
            item.InitTypeStr      = "UI_UIElement_CustomEvent";
            var data = new UIEditor.UIMacross.UIElementCustomEventCategoryItemInitData();

            data.Reset();
            data.EventName   = "UICustomEvent_" + EngineNS.Editor.Assist.GetValuedGUIDString(item.Id);
            data.DisplayName = newName + i;
            item.Initialize(HostControl, data);
            category.Items.Add(item);
        }
        internal async Task SetVariableBindOperation(EngineNS.UISystem.VariableBindInfo bindInfo)
        {
            var category   = Macross_Client.GetCategory(MacrossPanel.UIBindFuncCategoryName);
            var bindFromUI = HostControl.mCurrentUIHost.FindChildElement(bindInfo.BindFromUIElementId);
            var bindToUI   = HostControl.mCurrentUIHost.FindChildElement(bindInfo.BindToUIElementId);

            // from->to
            if (bindInfo.BindMode == EngineNS.UISystem.enBindMode.OnWayToSource ||
                bindInfo.BindMode == EngineNS.UISystem.enBindMode.TwoWay)
            {
                var item = new Macross.CategoryItem(null, category);
                item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;
                item.CanDrag          = false;
                item.InitTypeStr      = "UI_UIElement_VariableBind";
                var data = new UIElementVariableBindCategoryItemInitData();
                data.Reset();

                data.UIElement            = bindFromUI;
                data.UIElementId          = bindInfo.BindFromUIElementId;
                data.PropertyName         = bindInfo.BindFromPropertyName;
                data.PropertyType         = bindInfo.BindFromPropertyType;
                data.TargetUIElement      = bindToUI;
                data.TargetUIElementId    = bindInfo.BindToUIElementId;
                data.TargetPropertyName   = bindInfo.VariableName;
                data.TargetPropertyType   = bindInfo.BindToVariableType;
                data.FunctionName         = $"UIVariableBindFunc_Set_{bindInfo.BindFromUIElementId.ToString().Replace("-", "_")}_{item.Id.ToString().Replace("-", "_")}";
                bindInfo.FunctionName_Set = data.FunctionName;
                item.Initialize(Macross_Client, data);
                category.Items.Add(item);

                var varItemPro     = item.PropertyShowItem as UIElementVariableBindCategoryItemPropertys;
                var nodesContainer = await Macross_Client.CreateNodesContainer(item);

                var nodeType = typeof(CodeDomNode.MethodCustom);
                var csParam  = new CodeDomNode.MethodCustom.MethodCustomConstructParam()
                {
                    CSType             = Macross_Client.CSType,
                    HostNodesContainer = nodesContainer.NodesControl,
                    ConstructParam     = "",
                    MethodInfo         = varItemPro.MethodInfo,
                    IsShowProperty     = false,
                };
                var node = nodesContainer.NodesControl.AddOrigionNode(nodeType, csParam, 0, 0);
                node.IsDeleteable            = false;
                node.NodeNameAddShowNodeName = false;

                var retNodeType = typeof(CodeDomNode.ReturnCustom);
                var retCSParam  = new CodeDomNode.ReturnCustom.ReturnCustomConstructParam()
                {
                    CSType             = Macross_Client.CSType,
                    HostNodesContainer = nodesContainer.NodesControl,
                    ConstructParam     = "",
                    MethodInfo         = varItemPro.MethodInfo,
                    ShowPropertyType   = CodeDomNode.ReturnCustom.ReturnCustomConstructParam.enShowPropertyType.ReturnValue,
                };
                var retNode = nodesContainer.NodesControl.AddOrigionNode(retNodeType, retCSParam, 500, 0) as CodeDomNode.ReturnCustom;
                retNode.IsDeleteable = false;

                // 相同或可强转类型自动连接
                var nodePins    = node.GetLinkPinInfos();
                var retNodePins = retNode.GetLinkPinInfos();
                foreach (var pin in nodePins)
                {
                    if (pin.Visibility != Visibility.Visible)
                    {
                        continue;
                    }
                    foreach (var retPin in retNodePins)
                    {
                        if (retPin.Visibility != Visibility.Visible)
                        {
                            continue;
                        }
                        if (CodeGenerateSystem.Base.LinkInfo.CanLinkWith(pin, retPin))
                        {
                            var linkInfo = new CodeGenerateSystem.Base.LinkInfo(nodesContainer.NodesControl.GetDrawCanvas(), pin, retPin);
                        }
                    }
                }

                nodesContainer.Save();

                await Macross_Client.ShowNodesContainer(item);
            }

            // to->from
            if (bindInfo.BindMode == EngineNS.UISystem.enBindMode.OnWay ||
                bindInfo.BindMode == EngineNS.UISystem.enBindMode.TwoWay)
            {
                var item = new Macross.CategoryItem(null, category);
                item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;
                item.CanDrag          = false;
                item.InitTypeStr      = "UI_UIElement_VariableBind";
                var data = new UIElementVariableBindCategoryItemInitData();
                data.Reset();
                data.UIElement            = bindToUI;
                data.UIElementId          = bindInfo.BindToUIElementId;
                data.PropertyName         = bindInfo.VariableName;
                data.PropertyType         = bindInfo.BindToVariableType;
                data.TargetUIElement      = bindFromUI;
                data.TargetUIElementId    = bindInfo.BindFromUIElementId;
                data.TargetPropertyName   = bindInfo.BindFromPropertyName;
                data.TargetPropertyType   = bindInfo.BindFromPropertyType;
                data.FunctionName         = $"UIVariableBindFunc_Get_{bindInfo.BindToUIElementId.ToString().Replace("-", "_")}_{item.Id.ToString().Replace("-", "_")}";
                bindInfo.FunctionName_Get = data.FunctionName;
                item.Initialize(Macross_Client, data);
                category.Items.Add(item);

                var varItemPro     = item.PropertyShowItem as UIElementVariableBindCategoryItemPropertys;
                var nodesContainer = await Macross_Client.CreateNodesContainer(item);

                var nodeType = typeof(CodeDomNode.MethodCustom);
                var csParam  = new CodeDomNode.MethodCustom.MethodCustomConstructParam()
                {
                    CSType             = Macross_Client.CSType,
                    HostNodesContainer = nodesContainer.NodesControl,
                    ConstructParam     = "",
                    MethodInfo         = varItemPro.MethodInfo,
                    IsShowProperty     = false,
                };
                var node = nodesContainer.NodesControl.AddOrigionNode(nodeType, csParam, 0, 0);
                node.IsDeleteable            = false;
                node.NodeNameAddShowNodeName = false;

                var retNodeType = typeof(CodeDomNode.ReturnCustom);
                var retCSParam  = new CodeDomNode.ReturnCustom.ReturnCustomConstructParam()
                {
                    CSType             = Macross_Client.CSType,
                    HostNodesContainer = nodesContainer.NodesControl,
                    ConstructParam     = "",
                    MethodInfo         = varItemPro.MethodInfo,
                    ShowPropertyType   = CodeDomNode.ReturnCustom.ReturnCustomConstructParam.enShowPropertyType.ReturnValue,
                };
                var retNode = nodesContainer.NodesControl.AddOrigionNode(retNodeType, retCSParam, 500, 0) as CodeDomNode.ReturnCustom;
                retNode.IsDeleteable = false;

                // 相同或可强转类型自动连接
                bool childLinked     = false;
                var  nodeChildren    = node.GetChildNodes();
                var  retNodeChildren = retNode.GetChildNodes();
                foreach (var nodeChild in nodeChildren)
                {
                    foreach (var retNodeChild in retNodeChildren)
                    {
                        foreach (var pin in nodeChild.GetLinkPinInfos())
                        {
                            if (pin.Visibility != Visibility.Visible)
                            {
                                continue;
                            }
                            foreach (var retPin in retNodeChild.GetLinkPinInfos())
                            {
                                if (retPin.Visibility != Visibility.Visible)
                                {
                                    continue;
                                }
                                if (CodeGenerateSystem.Base.LinkInfo.CanLinkWith(pin, retPin))
                                {
                                    var linkInfo = new CodeGenerateSystem.Base.LinkInfo(nodesContainer.NodesControl.GetDrawCanvas(), pin, retPin);
                                    childLinked = true;
                                }
                            }
                        }
                    }
                }
                if (childLinked)
                {
                    var nodePins    = node.GetLinkPinInfos();
                    var retNodePins = retNode.GetLinkPinInfos();
                    foreach (var pin in nodePins)
                    {
                        if (pin.Visibility != Visibility.Visible)
                        {
                            continue;
                        }
                        foreach (var retPin in retNodePins)
                        {
                            if (retPin.Visibility != Visibility.Visible)
                            {
                                continue;
                            }
                            if (CodeGenerateSystem.Base.LinkInfo.CanLinkWith(pin, retPin))
                            {
                                var linkInfo = new CodeGenerateSystem.Base.LinkInfo(nodesContainer.NodesControl.GetDrawCanvas(), pin, retPin);
                            }
                        }
                    }
                }

                nodesContainer.Save();

                await Macross_Client.ShowNodesContainer(item);
            }

            List <EngineNS.UISystem.VariableBindInfo> infos;

            if (!bindFromUI.VariableBindInfosDic.TryGetValue(bindInfo.BindFromPropertyName, out infos))
            {
                infos = new List <EngineNS.UISystem.VariableBindInfo>();
                bindFromUI.VariableBindInfosDic[bindInfo.BindFromPropertyName] = infos;
            }
            infos.Add(bindInfo);

            HostControl.ChangeToLogic();
        }
        internal async Task SetEventFunction(EngineNS.UISystem.UIElement element, string functionName, Type eventType)
        {
            Macross.Category category = Macross_Client.GetCategory(MacrossPanel.UIEventFuncCategoryName);
            var item = new Macross.CategoryItem(null, category);

            item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.Unknow;
            item.CanDrag          = true;
            item.InitTypeStr      = "UI_UIElement_Event";
            var data = new UIElementEventCategoryItemInitData();

            data.Reset();
            data.UIElement    = element;
            data.UIElementId  = element.Id;
            data.FunctionName = functionName;
            data.EventType    = eventType;
            item.Initialize(Macross_Client, data);
            category.Items.Add(item);
            string dicValue;
            var    key = new UIResourceInfo.UIEventDicKey(element.Id, functionName);

            if (!HostControl.CurrentResInfo.UIEventsDic.TryGetValue(key, out dicValue))
            {
                HostControl.CurrentResInfo.UIEventsDic[key] = item.Name;
            }

            // 创建NodesContainer
            var varItemPro     = item.PropertyShowItem as UIElementEventCategoryItemPorpertys;
            var nodesContainer = await Macross_Client.CreateNodesContainer(item);

            var nodeType = typeof(CodeDomNode.MethodCustom);
            var csParam  = new CodeDomNode.MethodCustom.MethodCustomConstructParam()
            {
                CSType             = Macross_Client.CSType,
                HostNodesContainer = nodesContainer.NodesControl,
                ConstructParam     = "",
                MethodInfo         = varItemPro.MethodInfo,
                IsShowProperty     = false,
            };
            var node = nodesContainer.NodesControl.AddOrigionNode(nodeType, csParam, 0, 0);

            node.IsDeleteable            = false;
            node.NodeNameAddShowNodeName = false;

            // 有输出参数时才默认添加return
            if (varItemPro.MethodInfo.OutParams.Count > 0)
            {
                var retNodeType = typeof(CodeDomNode.ReturnCustom);
                var retParam    = new CodeDomNode.ReturnCustom.ReturnCustomConstructParam()
                {
                    CSType             = Macross_Client.CSType,
                    HostNodesContainer = nodesContainer.NodesControl,
                    ConstructParam     = "",
                    MethodInfo         = varItemPro.MethodInfo,
                    ShowPropertyType   = CodeDomNode.ReturnCustom.ReturnCustomConstructParam.enShowPropertyType.ReturnValue,
                };
                var retNode = nodesContainer.NodesControl.AddOrigionNode(retNodeType, retParam, 300, 0) as CodeDomNode.ReturnCustom;
                retNode.IsDeleteable = false;
            }
            nodesContainer.Save();

            await Macross_Client.ShowNodesContainer(item);
        }