private void SetScrollViewDirection(Data.GroupNode node, ScrollRect scrollRect, DirectionAxis direction)
{
switch (direction)
{
case DirectionAxis.Horizontal:
scrollRect.vertical = false;
scrollRect.horizontal = true;
break;
case DirectionAxis.Vertical:
scrollRect.vertical = true;
scrollRect.horizontal = false;
break;
case DirectionAxis.Horizontal | DirectionAxis.Vertical:
scrollRect.vertical = true;
scrollRect.horizontal = true;
break;
default:
if (node.children != null)
{
if (node.children.Find(x => MatchAddress((x as Data.GroupNode).displayName, vbarAddress)) != null)
{
scrollRect.vertical = true;
}
else if (node.children.Find(x => MatchAddress((x as Data.GroupNode).displayName, hbarAddress)) != null)
{
scrollRect.horizontal = true;
}
}
break;
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent); //GameObject.Instantiate(temp) as UnityEngine.UI.Slider;
UnityEngine.UI.Slider slider = node.InitComponent <UnityEngine.UI.Slider>();
SetSliderDirection(slider, layer);
for (int i = 0; i < layer.images.Count; i++)
{
var imgNode = layer.images[i];
if (MatchAddress(imgNode.Name, backgroundAddress))
{
DrawBackground(imgNode, node);
}
else if (MatchAddress(imgNode.Name, fillAddress))
{
DrawFill(imgNode, node);
}
else if (MatchAddress(imgNode.Name, handleAddress))
{
DrawHandle(imgNode, node, layer);
}
else
{
ctrl.DrawImage(imgNode, node);
}
}
return(node);
}
/// <summary>
/// 绘制图片
/// </summary>
/// <param name="layer"></param>
/// <param name="node"></param>
/// <param name="background"></param>
private void DrawImages(Data.GroupNode layer, UGUINode node, out Graphic background)
{
background = null;
for (int i = 0; i < layer.images.Count; i++)
{
Data.ImgNode image = layer.images[i];
if (MatchAddress(image.Name, backgroundAddress))
{
if (image.type == ImgType.Texture)
{
background = node.InitComponent <UnityEngine.UI.RawImage>();
}
else
{
background = node.InitComponent <UnityEngine.UI.Image>();
}
if (background)
{
PSDImporterUtility.SetPictureOrLoadColor(image, background);
SetRectTransform(image.rect, background.GetComponent <RectTransform>());
background.name = layer.displayName;
}
}
else
{
ctrl.DrawImage(image, node);
}
}
}
/// <summary>
/// 设置Scrollbar的方向
/// </summary>
/// <param name="scrollbar"></param>
/// <param name="layer"></param>
private void SetScrollBarDirection(Scrollbar scrollbar, Data.GroupNode layer)
{
switch (layer.direction)
{
case Direction.LeftToRight:
scrollbar.direction = Scrollbar.Direction.LeftToRight;
break;
case Direction.BottomToTop:
scrollbar.direction = Scrollbar.Direction.BottomToTop;
break;
case Direction.TopToBottom:
scrollbar.direction = Scrollbar.Direction.TopToBottom;
break;
case Direction.RightToLeft:
scrollbar.direction = Scrollbar.Direction.RightToLeft;
break;
default:
if (layer.rect.width > layer.rect.height)
{
scrollbar.direction = Scrollbar.Direction.LeftToRight;
}
else
{
scrollbar.direction = Scrollbar.Direction.BottomToTop;
}
break;
}
}
private void SetSliderDirection(Slider slider, Data.GroupNode layer)
{
var dir = layer.direction;
switch (dir)
{
case Direction.LeftToRight:
slider.direction = Slider.Direction.LeftToRight;
break;
case Direction.RightToLeft:
slider.direction = Slider.Direction.RightToLeft;
break;
case Direction.BottomToTop:
slider.direction = Slider.Direction.BottomToTop;
break;
case Direction.TopToBottom:
slider.direction = Slider.Direction.TopToBottom;
break;
default:
if (layer.rect.width > layer.rect.height)
{
slider.direction = Slider.Direction.LeftToRight;
}
else
{
slider.direction = Slider.Direction.BottomToTop;
}
break;
}
}
private UGUINode DrawViewNode(Data.GroupNode layer, ScrollRect scrollRect, UGUINode node)
{
var viewPort = new GameObject("ViewPort", typeof(Mask), typeof(Image)).GetComponent <RectTransform>();
Color color;
if (ColorUtility.TryParseHtmlString("#FFFFFF01", out color))
{
viewPort.GetComponent <UnityEngine.UI.Image>().color = color;
}
UGUINode viewNode = CreateNormalNode(viewPort.gameObject, layer.rect, node);
if (scrollRect.vertical)
{
viewNode.anchoType = AnchoType.Up | AnchoType.XCenter;
}
else if (scrollRect.horizontal)
{
viewNode.anchoType = AnchoType.YCenter | AnchoType.Left;
}
else
{
viewNode.anchoType = AnchoType.Up | AnchoType.Left;
}
return(viewNode);
}
private void DrawMask(Data.GroupNode layer, Toggle toggle, UGUINode bgNode)
{
var mask = layer.images.Find(x => MatchAddress(x.Name, maskAddress));
if (mask != null)
{
if (mask.sprite != null)
{
SetGraphic <Image>(toggle);
}
else if (mask.texture != null)
{
SetGraphic <RawImage>(toggle);
}
else if (mask.text != null)
{
var text = SetGraphic <Text>(toggle);
text.horizontalOverflow = HorizontalWrapMode.Overflow;
text.verticalOverflow = VerticalWrapMode.Overflow;
}
PSDImporterUtility.SetPictureOrLoadColor(mask, toggle.graphic);
var graphic = toggle.targetGraphic.transform.Find("Mask").gameObject;
CreateNormalNode(graphic, mask.rect, bgNode);
}
else
{
SetGraphic <Image>(toggle);
}
}
private void DrawImages(InputField inputfield, UGUINode node, Data.GroupNode layer)
{
if (layer.images != null)
{
for (int i = 0; i < layer.images.Count; i++)
{
Data.ImgNode image = layer.images[i];
if (image.type == ImgType.Label && MatchAddress(image.Name, titleAddress))
{
UnityEngine.UI.Text text = (UnityEngine.UI.Text)inputfield.textComponent;//inputfield.transform.Find("Text").GetComponent<UnityEngine.UI.Text>();
var childNode = CreateNormalNode(text.gameObject, image.rect, node);
childNode.anchoType = AnchoType.XStretch | AnchoType.YStretch;
PSDImporterUtility.SetPictureOrLoadColor(image, text);
}
else if (image.type == ImgType.Label && MatchAddress(image.Name, placeAddress))
{
UnityEngine.UI.Text text = (UnityEngine.UI.Text)inputfield.placeholder;//.transform.Find("Placeholder").GetComponent<UnityEngine.UI.Text>();
var childNode = CreateNormalNode(text.gameObject, image.rect, node);
childNode.anchoType = AnchoType.XStretch | AnchoType.YStretch;
PSDImporterUtility.SetPictureOrLoadColor(image, text);
}
else if (MatchAddress(image.Name, backgroundAddress))
{
PSDImporterUtility.SetPictureOrLoadColor(image, inputfield.image);
SetRectTransform(image.rect, inputfield.GetComponent <RectTransform>());
}
else
{
ctrl.DrawImage(image, node);
}
}
}
}
private void DrawChildLayers(Data.GroupNode layer, UGUINode viewNode, ScrollRect scrollRect)
{
if (layer.children != null)
{
for (int i = 0; i < layer.children.Count; i++)
{
Data.GroupNode child = layer.children[i] as Data.GroupNode;
UGUINode childNode = ctrl.DrawLayer(child, viewNode);
if (MatchAddress(child.displayName, contentAddress))
{
DrawConent(childNode, scrollRect);
}
else if (MatchAddress(child.displayName, vbarAddress))
{
scrollRect.verticalScrollbar = childNode.InitComponent <Scrollbar>();
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHide;
childNode.anchoType = AnchoType.Right | AnchoType.YCenter;
}
else if (MatchAddress(child.displayName, hbarAddress))
{
scrollRect.horizontalScrollbar = childNode.InitComponent <Scrollbar>();
scrollRect.horizontalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHide;
childNode.anchoType = AnchoType.Down | AnchoType.XCenter;
}
}
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
UnityEngine.UI.InputField inputfield = node.InitComponent <UnityEngine.UI.InputField>();
DrawImages(inputfield, node, layer);
return(node);
}
public override void AnalysisAreguments(Data.GroupNode layer, string[] areguments)
{
base.AnalysisAreguments(layer, areguments);
if (areguments != null && areguments.Length > 0)
{
layer.directionAxis = GetDirectionByKey(areguments);
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
Scrollbar scrollbar = node.InitComponent <Scrollbar>();
SetScrollBarDirection(scrollbar, layer);
DrawImages(layer.images, scrollbar, node);
return(node);
}
private void DrawMask(Data.GroupNode layer, Toggle toggle, UGUINode bgNode)
{
var mask = layer.images.Find(x => MatchAddress(x.Name, maskAddress));
if (mask != null)
{
PSDImporterUtility.SetPictureOrLoadColor(mask, toggle.graphic);
CreateNormalNode(toggle.graphic.gameObject, mask.rect, bgNode);
}
}
public void Import(Data.GroupNode rootNode)
{
InitBaseSize(uinode, canvasSize);
DrawLayer(rootNode, uinode); //直接绘制所有层级
BeginSetUIParents(uinode); //设置层级之前的父子关系
BeginSetAnchers(uinode); //设置层级的锚点
BeginReprocess(uinode); //后处理
if (rule.spreadUI)
{
BeginScaleWithCanvas(uinode, canvasSize);//尺寸缩放
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
ScrollRect scrollRect = node.InitComponent <UnityEngine.UI.ScrollRect>();
SetScrollViewDirection(layer, scrollRect, layer.directionAxis);
var viewNode = DrawViewNode(layer, scrollRect, node);
DrawImages(layer, node, scrollRect);
DrawChildLayers(layer, viewNode, scrollRect);
return(node);
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
UnityEngine.UI.Toggle toggle = node.InitComponent <UnityEngine.UI.Toggle>();
if (layer.images != null)
{
var bgNode = DrawBackground(layer, toggle, node);
DrawMask(layer, toggle, bgNode);
DrawOtherLayers(layer, node);
}
return(node);
}
/// <summary>
/// 试图为Panel类型的图片添加空背景
/// </summary>
/// <param name="background"></param>
/// <param name="layer"></param>
/// <param name="node"></param>
private void TryDrawPanel(Graphic background, Data.GroupNode layer, UGUINode node)
{
if (background == null)
{
background = node.InitComponent <UnityEngine.UI.Image>();
SetRectTransform(layer.rect, background.GetComponent <RectTransform>());
Color color;
if (ColorUtility.TryParseHtmlString("#FFFFFF01", out color))
{
background.color = color;
}
background.name = layer.displayName;
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
Dropdown dropdown = node.InitComponent <Dropdown>();
ScrollRect scrllRect = dropdown.template.GetComponent <ScrollRect>();
RectTransform content = scrllRect.content;
Toggle toggle = content.GetComponentInChildren <Toggle>();
UGUINode tempNode = CreateNormalNode(dropdown.template.gameObject, layer.rect, node);
tempNode.anchoType = AnchoType.Down | AnchoType.XStretch;
DrawImages(node, layer, dropdown, toggle, content);
DrawSubLayers(layer, tempNode, scrllRect);
return(node);
}
private void DrawImages(Data.GroupNode layer, UGUINode node, ScrollRect scrollRect)
{
for (int i = 0; i < layer.images.Count; i++)
{
Data.ImgNode image = layer.images[i];
if (MatchAddress(image.Name, backgroundAddress))
{
InitScrollViewBackground(node, image, scrollRect);
}
else
{
ctrl.DrawImage(image, node);
}
}
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
if (layer.children != null)
{
ctrl.DrawLayers(layer.children.ConvertAll(x => x as Data.GroupNode).ToArray(), node);//子节点
}
Graphic background;
DrawImages(layer, node, out background);
TryDrawPanel(background, layer, node);
return(node);
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
var node = base.CreateRootNode(layer.displayName, layer.rect, parent);
UnityEngine.UI.Button button = node.InitComponent <UnityEngine.UI.Button>();
if (layer.images != null)
{
for (int imageIndex = 0; imageIndex < layer.images.Count; imageIndex++)
{
Data.ImgNode image = layer.images[imageIndex];
if (MatchAddress(image.Name, normalAddress, pressedAddress, disableAddress, highlightedAddress))
{
if (MatchAddress(image.Name, normalAddress))
{
SetRectTransform(image.rect, button.transform as RectTransform);
}
InitButton(image, button);
if (image.type == ImgType.Color)
{
SetColorSwipe(image, button);
}
else
{
SetSpriteSwipe(image, button);
}
}
else
{
if (autoButtonTitle && image.type == ImgType.Label && !image.Name.StartsWith(titleAddress))
{
var array = layer.images.Where(x => x.type == ImgType.Label).ToList();
if (array.Count > 0 && array.IndexOf(image) == 0)
{
image.Name = titleAddress + image.Name;
}
}
ctrl.DrawImage(image, node);
}
}
}
return(node);
}
public override void AnalysisAreguments(Data.GroupNode layer, string[] areguments)
{
base.AnalysisAreguments(layer, areguments);
if (areguments != null && areguments.Length > 1)
{
layer.directionAxis = GetDirectionByKey(areguments);
}
if (areguments != null)
{
if (areguments.Length > 2)
{
var key = areguments[1];
int.TryParse(key, out layer.constraintCount);
}
}
}
private void DrawHandle(Data.ImgNode handle, UGUINode node, Data.GroupNode layer)
{
var slider = node.InitComponent <Slider>();
Data.ImgNode bg = layer.images.Find(x => MatchAddress(x.Name, backgroundAddress));
Data.ImgNode fill = layer.images.Find(x => MatchAddress(x.Name, fillAddress));
var tempRect = fill != null ? fill : bg;
var rect = new Rect(tempRect.rect.x, tempRect.rect.y, tempRect.rect.width - handle.rect.width, tempRect.rect.height);//x,y 为中心点的坐标！
var handAreaNode = CreateNormalNode(new GameObject("Handle Slide Area", typeof(RectTransform)), rect, node);
var handNode = ctrl.DrawImage(handle, handAreaNode);
slider.handleRect = handNode.InitComponent <RectTransform>();
///设置handle最后的锚点类型
switch (layer.direction)
{
case Direction.LeftToRight:
handNode.anchoType = AnchoType.Right | AnchoType.YStretch;
break;
case Direction.BottomToTop:
handNode.anchoType = AnchoType.Up | AnchoType.XStretch;
break;
case Direction.TopToBottom:
handNode.anchoType = AnchoType.Down | AnchoType.XStretch;
break;
case Direction.RightToLeft:
handNode.anchoType = AnchoType.Left | AnchoType.YStretch;
break;
default:
break;
}
handNode.inversionReprocess += (n) =>
{
//写slider进行关联后,尺寸信息丢失
slider.handleRect.anchoredPosition = Vector3.zero;
slider.handleRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, handle.rect.width);
slider.handleRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, handle.rect.height);
};
}
private UGUINode DrawBackground(Data.GroupNode layer, Toggle toggle, UGUINode node)
{
var bgImage = layer.images.Find(x => MatchAddress(x.Name, backgroundAddress));
UGUINode bgNode = null;
if (bgImage != null)
{
bgNode = CreateNormalNode(toggle.targetGraphic.gameObject, bgImage.rect, node);
PSDImporterUtility.SetPictureOrLoadColor(bgImage, toggle.targetGraphic);
SetRectTransform(bgImage.rect, toggle.GetComponent <RectTransform>());
}
else
{
bgNode = CreateNormalNode(toggle.targetGraphic.gameObject, layer.rect, node);
}
return(bgNode);
}
public override UGUINode DrawLayer(Data.GroupNode layer, UGUINode parent)
{
UGUINode node = CreateRootNode(layer.displayName, layer.rect, parent);
node.anchoType = AnchoType.Up | AnchoType.Left;
if (layer.children != null)
{
ctrl.DrawLayers(layer.children.ConvertAll(x => x as Data.GroupNode).ToArray(), node);
}
if (layer.images != null)
{
ctrl.DrawImages(layer.images.ToArray(), node);
}
InitGrid(node, layer);
return(node);
}
/// <summary>
/// 绘制所有image
/// </summary>
/// <param name="node"></param>
/// <param name="layer"></param>
/// <param name="dropdown"></param>
/// <param name="toggle"></param>
/// <param name="content"></param>
private void DrawImages(UGUINode node, Data.GroupNode layer, Dropdown dropdown, Toggle toggle, RectTransform content)
{
for (int i = 0; i < layer.images.Count; i++)
{
Data.ImgNode image = layer.images[i];
if (MatchIDAddress(image.Name, 1, backgroundsFormat))
{
PSDImporterUtility.SetPictureOrLoadColor(image, dropdown.image);
SetRectTransform(image.rect, dropdown.GetComponent <RectTransform>());
dropdown.name = layer.displayName;
}
else if (MatchIDAddress(image.Name, 2, backgroundsFormat))
{
PSDImporterUtility.SetPictureOrLoadColor(image, dropdown.template.GetComponent <Graphic>());
SetRectTransform(image.rect, dropdown.template);
}
else if (MatchIDAddress(image.Name, 3, backgroundsFormat))
{
UnityEngine.UI.Image itemimage = (UnityEngine.UI.Image)toggle.targetGraphic;
PSDImporterUtility.SetPictureOrLoadColor(image, itemimage);
content.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, image.rect.height);
}
else if (MatchIDAddress(image.Name, 1, titlesFormat))
{
PSDImporterUtility.SetPictureOrLoadColor(image, dropdown.captionText);
}
else if (MatchIDAddress(image.Name, 2, titlesFormat))
{
PSDImporterUtility.SetPictureOrLoadColor(image, dropdown.itemText);
}
else if (MatchAddress(image.Name, maskAddress))
{
UnityEngine.UI.Image mask = (UnityEngine.UI.Image)toggle.graphic;
mask.enabled = true;
PSDImporterUtility.SetPictureOrLoadColor(image, mask);
}
else
{
ctrl.DrawImage(image, node);
}
}
}
public override void HeadGUI(Rect dirRect, Data.GroupNode item)
{
base.HeadGUI(dirRect, item);
var dir = (DirectionAxis)EditorGUI.EnumPopup(dirRect, item.directionAxis);
if (dir == DirectionAxis.Horizontal || dir == DirectionAxis.Vertical)
{
item.directionAxis = dir;
}
if (item.directionAxis == 0)
{
item.directionAxis = DirectionAxis.Horizontal;
}
var constenctCountRect = dirRect;
constenctCountRect.width *= 0.5f;
constenctCountRect.x -= 50;
item.constraintCount = EditorGUI.IntField(constenctCountRect, item.constraintCount, EditorStyles.label);
}
private void DrawOtherLayers(Data.GroupNode layer, UGUINode node)
{
for (int imageIndex = 0; imageIndex < layer.images.Count; imageIndex++)
{
Data.ImgNode image = layer.images[imageIndex];
if (!MatchAddress(image.Name, backgroundAddress, maskAddress))
{
if (autoToggleTitle && image.type == ImgType.Label && !image.Name.StartsWith(titleAddress))
{
var array = layer.images.Where(x => x.type == ImgType.Label).ToList();
if (array.Count > 0 && array.IndexOf(image) == 0)
{
image.Name = titleAddress + image.Name;
}
}
ctrl.DrawImage(image, node);
}
}
}
/// <summary>
/// 初始化组
/// </summary>
/// <param name="layer"></param>
/// <param name="node"></param>
private void InitLayoutGroup(Data.GroupNode layer, UGUINode node)
{
HorizontalOrVerticalLayoutGroup group = null;
switch (layer.directionAxis)
{
case DirectionAxis.Horizontal:
group = node.InitComponent <UnityEngine.UI.HorizontalLayoutGroup>();
break;
case DirectionAxis.Vertical:
default:
group = node.InitComponent <UnityEngine.UI.VerticalLayoutGroup>();
break;
}
if (group)
{
(group as UnityEngine.UI.VerticalLayoutGroup).spacing = layer.spacing;
group.childAlignment = TextAnchor.UpperLeft;
}
}
/// <summary>
/// 滑动条绘制
/// </summary>
/// <param name="layer"></param>
/// <param name="tempNode"></param>
/// <param name="scrollRect"></param>
private void DrawSubLayers(Data.GroupNode layer, UGUINode tempNode, ScrollRect scrollRect)
{
if (layer.children != null)
{
for (int i = 0; i < layer.children.Count; i++)
{
Data.GroupNode child = layer.children[i] as Data.GroupNode;
if (MatchAddress(child.displayName, vbarAddress))
{
UGUINode barNode = ctrl.DrawLayer(child, tempNode);
scrollRect.verticalScrollbar = barNode.InitComponent <Scrollbar>();
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHide;
barNode.anchoType = AnchoType.Right | AnchoType.YCenter;
}
else
{
ctrl.DrawLayer(child, tempNode);
}
}
}
}
