Пример #1
0
        public override void Draw(IPlatformDrawer platform, float scale)
        {
            base.Draw(platform, scale);

            var headerPadding = StyleSchema.HeaderPadding;
//            var headerBounds = new Rect(
//                Bounds.x - headerPadding.left,
//                Bounds.y,
//                Bounds.width + headerPadding.left * 2 + 1,
//                Bounds.height + (NodeViewModel.IsCollapsed ? 0 : -20) + headerPadding.bottom);
            var headerBounds = new Rect(
                //Bounds.x-headerPadding.left-1,
                Bounds.x - headerPadding.left + 1,
                Bounds.y + 1,
                Bounds.width + headerPadding.left + headerPadding.right + headerPadding.left - 6,
                Bounds.height + 0 + (NodeViewModel.IsCollapsed ? 9 : -2));

            var image = HeaderImage;

            platform.DrawNodeHeader(
                headerBounds,
                NodeViewModel.IsCollapsed ? StyleSchema.CollapsedHeaderStyleObject : StyleSchema.ExpandedHeaderStyleObject,
                NodeViewModel.IsCollapsed,
                scale, image);


            // The bounds for the main text

//            var textBounds = new Rect(Bounds.x, Bounds.y + ((Bounds.height / 2f) - (TextSize.y / 2f)), Bounds.width,
//                Bounds.height);
            var padding     = headerPadding;
            var titleBounds = new Rect(
                Bounds.x + padding.left,
                Bounds.y + padding.top + (StyleSchema.ShowSubtitle ? 1 : 0),
                Bounds.width - padding.right - padding.left - (StyleSchema.ShowIcon ? 16 : 0), //Subtract icon size if shown
                Bounds.height - padding.top - padding.bottom);

            var titleSize = platform.CalculateTextSize(NodeViewModel.Label, StyleSchema.TitleStyleObject);

            var subtitleBound = new Rect(Bounds.x + padding.left + 0, Bounds.y + padding.top + titleSize.y + 0, Bounds.width - padding.right, Bounds.height - padding.top);



            if (NodeViewModel.IsEditing && NodeViewModel.IsEditable)
            {
                //UnityEngine.GUI.SetNextControlName("EditingField");
                //DiagramDrawer.IsEditingField = true;
                //UnityEditor.EditorGUI.BeginChangeCheck();

                //var newText = GUI.TextField(textBounds.Scale(scale), NodeViewModel.Name,
                //    ElementDesignerStyles.ViewModelHeaderEditingStyle);

                //if (UnityEditor.EditorGUI.EndChangeCheck())
                //{
                //    NodeViewModel.Rename(newText);
                //    Dirty = true;
                //}

                //textBounds.y += TextSize.y / 2f;
                platform.DrawTextbox(NodeViewModel.GraphItemObject.Identifier, titleBounds.Scale(scale), NodeViewModel.Name, CachedStyles.ViewModelHeaderStyle, (v, finished) =>
                {
                    NodeViewModel.Rename(v);
                    ParentDrawer.Refresh(platform);
                    if (finished)
                    {
                        NodeViewModel.EndEditing();
                    }
                });
            }
            else
            {
                //var titleStyle = new GUIStyle(TextStyle);
                //titleStyle.normal.textColor = BackgroundStyle.normal.textColor;
                //titleStyle.alignment = TextAnchor.MiddleCenter;
                //titleStyle.fontSize = Mathf.RoundToInt(12*scale);
                platform.DrawLabel(titleBounds.Scale(scale), NodeViewModel.Label ?? string.Empty, StyleSchema.TitleStyleObject, StyleSchema.ShowSubtitle ? DrawingAlignment.TopLeft : DrawingAlignment.MiddleLeft);

                if (StyleSchema.ShowSubtitle && !string.IsNullOrEmpty(NodeViewModel.SubTitle))
                {
                    platform.DrawLabel(subtitleBound.Scale(scale), NodeViewModel.SubTitle ?? string.Empty,
                                       StyleSchema.SubTitleStyleObject, StyleSchema.ShowSubtitle ? DrawingAlignment.TopLeft : DrawingAlignment.MiddleLeft);
                }

                if (StyleSchema.ShowIcon && !string.IsNullOrEmpty(NodeViewModel.IconName))
                {
                    var iconsize    = IconBounds ?? (IconBounds = new Vector2(16, 16));
                    var size        = 16;
                    var imageBounds = new Rect(Bounds.xMax - padding.right - size, Bounds.y + ((Bounds.height / 2f) - (size / 2f)), 16, 16);


                    //var imageBounds = new Rect().WithSize(16, 16).InnerAlignWithUpperRight(Bounds).AlignHorisonallyByCenter(headerBounds).Translate(-headerPadding.right,0);
                    var cCache = GUI.color;
                    GUI.color = new Color(cCache.r, cCache.g, cCache.b, 0.7f);
                    platform.DrawImage(imageBounds.Scale(scale), IconImage, true);
                    GUI.color = cCache;

                    if (!string.IsNullOrEmpty(IconTooltip))
                    {
                        platform.SetTooltipForRect(imageBounds.Scale(scale), IconTooltip);
                    }
                }

                //GUI.Label(textBounds.Scale(scale), NodeViewModel.Label ?? string.Empty, titleStyle);
                //if (NodeViewModel.IsCollapsed)
                //{
                //    textBounds.y += TextSize.y/2f;
                //    //titleStyle.fontSize = Mathf.RoundToInt(10*scale);
                //    //titleStyle.fontStyle = FontStyle.Italic;

                //    GUI.Label(textBounds.Scale(scale), NodeViewModel.SubTitle, titleStyle);
                //}
            }
        }
Пример #2
0
        public void OnDrawGUI(Rect rect)
        {
            LineSetting setting = LineSetting.Setting;

            Rect itemRect = Rect.zero;

            itemRect.x      = Data.FireTime * setting.WidthForSecond - setting.ScrollPosX;
            itemRect.y      = rect.y;
            itemRect.height = setting.TracklineHeight;
            itemRect.width  = MIN_ACTION_WIDTH;

            DurationActionData durationActionData = null;

            if (Data is DurationActionData)
            {
                durationActionData = (DurationActionData)Data;

                itemRect.width = Mathf.Max(itemRect.width, durationActionData.DurationTime * setting.WidthForSecond);
            }
            else
            {
                itemRect.x -= itemRect.width * 0.5f;
            }
            GUI.Label(itemRect, BriefName, IsSelected ? "flow node 6" : "flow node 5");

            int       eventBtn   = Event.current.button;
            EventType eventType  = Event.current.type;
            bool      isContains = itemRect.Contains(Event.current.mousePosition);

            Rect leftRect  = new Rect(itemRect.x, itemRect.y, MIN_ACTION_WIDTH * 0.5f, itemRect.height);
            Rect rightRect = new Rect(itemRect.x + itemRect.width - MIN_ACTION_WIDTH * 0.5f, itemRect.y, MIN_ACTION_WIDTH * 0.5f, itemRect.height);

            bool isInLeftRect  = false;
            bool isInRightRect = false;

            if (durationActionData != null && !durationActionData.IsFixedDurationTime)
            {
                EGUI.DrawAreaLine(leftRect, Color.yellow);
                EGUI.DrawAreaLine(rightRect, Color.yellow);

                EditorGUIUtility.AddCursorRect(leftRect, MouseCursor.ResizeHorizontal);
                EditorGUIUtility.AddCursorRect(rightRect, MouseCursor.ResizeHorizontal);

                isInLeftRect  = leftRect.Contains(Event.current.mousePosition);
                isInRightRect = rightRect.Contains(Event.current.mousePosition);
            }

            if (eventBtn == 0)
            {
                if (eventType == EventType.MouseDown && isContains)
                {
                    if (durationActionData != null)
                    {
                        if (isInLeftRect)
                        {
                            dragType = ActionDragType.ItemLeft;
                        }
                        else if (isInRightRect)
                        {
                            dragType = ActionDragType.ItemRight;
                        }
                        else
                        {
                            dragType = ActionDragType.Item;
                        }
                    }
                    else
                    {
                        dragType = ActionDragType.Item;
                    }

                    IsSelected = true;
                    Event.current.Use();
                }
                else if (dragType != ActionDragType.None && eventType == EventType.MouseUp)
                {
                    dragType = ActionDragType.None;
                    Event.current.Use();
                }
                else if (dragType != ActionDragType.None && IsSelected && eventType == EventType.MouseDrag)
                {
                    Vector2 deltaPos  = Event.current.delta;
                    float   deltaTime = deltaPos.x / setting.WidthForSecond;
                    if (dragType == ActionDragType.ItemLeft)
                    {
                        if (Data.FireTime < durationActionData.DurationTime + Data.FireTime || deltaTime < 0)
                        {
                            Data.FireTime += deltaTime;
                            durationActionData.DurationTime -= deltaTime;
                        }
                    }
                    else if (dragType == ActionDragType.ItemRight)
                    {
                        durationActionData.DurationTime += deltaTime;
                    }
                    else if (dragType == ActionDragType.Item)
                    {
                        Data.FireTime += deltaTime;
                    }

                    float timeLength = ParentDrawer.ParentDrawer.Data.TimeLength;
                    if (Data.FireTime < 0)
                    {
                        Data.FireTime = 0;
                    }
                    else if (Data.FireTime > timeLength)
                    {
                        Data.FireTime = timeLength;
                    }

                    if (durationActionData != null)
                    {
                        durationActionData.DurationTime = Mathf.Max(0.0f, durationActionData.DurationTime);

                        float endTime = durationActionData.FireTime + durationActionData.DurationTime;
                        if (endTime > timeLength)
                        {
                            durationActionData.DurationTime = Mathf.Min(durationActionData.DurationTime, timeLength - durationActionData.FireTime);
                        }
                    }

                    Event.current.Use();
                }
            }
            else if (eventBtn == 1 && isContains && eventType == EventType.MouseUp)
            {
                IsSelected = true;

                GenericMenu menu = new GenericMenu();
                menu.AddItem(new GUIContent("Copy"), false, () =>
                {
                    string actionJson = JsonConvert.SerializeObject(Data, new JsonSerializerSettings()
                    {
                        TypeNameHandling = TypeNameHandling.All,
                    });
                    setting.CopiedActionData = actionJson;
                });
                menu.AddSeparator("");
                menu.AddItem(new GUIContent("Delete"), false, () =>
                {
                    ParentDrawer.OnActionDelete(this);
                });
                menu.ShowAsContext();

                Event.current.Use();
            }
        }