void SetupService(VisualElement scrollContainer, VisualTreeAsset serviceTemplate, SingleService singleService)
{
scrollContainer.Add(serviceTemplate.CloneTree().contentContainer);
var serviceIconAsset = EditorGUIUtility.Load(singleService.pathTowardIcon) as Texture2D;
var serviceRoot = scrollContainer[scrollContainer.childCount - 1];
serviceRoot.name = singleService.name;
var serviceTitle = serviceRoot.Q <TextElement>(className: k_ServiceTitleClassName);
serviceTitle.text = singleService.title;
serviceRoot.Q <TextElement>(className: k_ServiceDescriptionClassName).text = singleService.description;
serviceRoot.Q(className: k_ServiceIconClassName).style.backgroundImage = serviceIconAsset;
Action openServiceSettingsLambda = () =>
{
ServicesUtils.OpenServicesProjectSettings(singleService);
};
m_ClickableByServiceName.Add(singleService.name, new Clickable(openServiceSettingsLambda));
SetupServiceStatusLabel(serviceRoot, singleService);
SetupPackageInstall(serviceRoot, singleService);
}
public static string GetTemplateNameFromPath(this VisualTreeAsset vta, string path)
{
var fieldInfo = UsingsListFieldInfo;
if (fieldInfo != null)
{
var usings = fieldInfo.GetValue(vta) as List <VisualTreeAsset.UsingEntry>;
if (usings != null && usings.Count > 0)
{
var lookingFor = new VisualTreeAsset.UsingEntry(null, path);
int index = usings.BinarySearch(lookingFor, s_UsingEntryPathComparer);
if (index >= 0 && usings[index].path == path)
{
return(usings[index].alias);
}
}
}
else
{
Debug.LogError("UI Builder: VisualTreeAsset.m_Usings field has not been found! Update the reflection code!");
}
return(Path.GetFileNameWithoutExtension(path));
}
/// <summary>
/// 初始化页面
/// </summary>
public void InitViewer()
{
// 加载布局文件
_visualAsset = EditorHelper.LoadWindowUXML <ReporterAssetListViewer>();
if (_visualAsset == null)
{
return;
}
_root = _visualAsset.CloneTree();
_root.style.flexGrow = 1f;
// 顶部按钮栏
_topBar1 = _root.Q <ToolbarButton>("TopBar1");
_topBar2 = _root.Q <ToolbarButton>("TopBar2");
_topBar1.clicked += TopBar1_clicked;
_topBar2.clicked += TopBar2_clicked;
// 底部按钮栏
_bottomBar1 = _root.Q <ToolbarButton>("BottomBar1");
// 资源列表
_assetListView = _root.Q <ListView>("TopListView");
_assetListView.makeItem = MakeAssetListViewItem;
_assetListView.bindItem = BindAssetListViewItem;
#if UNITY_2020_1_OR_NEWER
_assetListView.onSelectionChange += AssetListView_onSelectionChange;
#else
_assetListView.onSelectionChanged += AssetListView_onSelectionChange;
#endif
// 依赖列表
_dependListView = _root.Q <ListView>("BottomListView");
_dependListView.makeItem = MakeDependListViewItem;
_dependListView.bindItem = BindDependListViewItem;
}
internal static List <VisualElementAsset> FindElementsByName(this VisualTreeAsset vta, string name)
{
var foundList = new List <VisualElementAsset>();
foreach (var vea in vta.visualElementAssets)
{
string currentName;
vea.TryGetAttributeValue("name", out currentName);
if (currentName == name)
{
foundList.Add(vea);
}
}
foreach (var vea in vta.templateAssets)
{
string currentName;
vea.TryGetAttributeValue("name", out currentName);
if (currentName == name)
{
foundList.Add(vea);
}
}
return(foundList);
}
private void OnEnable()
{
Instance = this;
if (m_ObjectList == null)
{
m_ObjectList = new List <Object>();
}
if (m_AssetList == null)
{
m_AssetList = new List <Asset>();
}
this.titleContent = new GUIContent("Affected Files");
this.minSize = new Vector2(415, 350);
string scriptPath = Utility.GetScriptPath("AffectedFilesWindow");
VisualTreeAsset uiAsset =
AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(scriptPath + "AffectedFilesWindow.uxml");
var uss = AssetDatabase.LoadAssetAtPath <StyleSheet>(scriptPath + "ShaderGraphPropertyRenamerWindow.uss");
VisualElement ui = uiAsset.CloneTree();
ui.style.flexGrow = 1f;
Type providerType = typeof(Provider);
m_HasLockingSupport = providerType.GetProperty("hasLockingSupport") != null;
if (m_HasLockingSupport)
{
m_HasLockingSupport = (bool)typeof(Provider).GetProperty("hasLockingSupport").GetValue(null);
}
root = rootVisualElement;
root.style.flexGrow = 1;
root.Add(ui);
root.styleSheets.Add(uss);
InitUI();
CheckVersionControlStatus();
}
public GroupNode()
{
this.m_ContentItem = new GroupNodeDropArea();
this.m_ContentItem.ClearClassList();
this.m_ContentItem.AddToClassList("content");
VisualTreeAsset visualTreeAsset = EditorGUIUtility.Load("UXML/GraphView/GroupNode.uxml") as VisualTreeAsset;
this.m_MainContainer = visualTreeAsset.CloneTree(null);
this.m_MainContainer.AddToClassList("mainContainer");
this.m_HeaderItem = this.m_MainContainer.Q("header", null);
this.m_HeaderItem.AddToClassList("header");
this.m_TitleItem = this.m_MainContainer.Q("titleLabel", null);
this.m_TitleItem.AddToClassList("label");
this.m_TitleEditor = (this.m_MainContainer.Q("titleField", null) as TextField);
this.m_TitleEditor.AddToClassList("textfield");
this.m_TitleEditor.visible = false;
this.m_TitleEditor.RegisterCallback <FocusOutEvent>(delegate(FocusOutEvent e)
{
this.OnEditTitleFinished();
}, Capture.NoCapture);
this.m_TitleEditor.RegisterCallback <KeyDownEvent>(new EventCallback <KeyDownEvent>(this.OnKeyPressed), Capture.NoCapture);
VisualElement visualElement = this.m_MainContainer.Q("contentPlaceholder", null);
visualElement.Add(this.m_ContentItem);
base.Add(this.m_MainContainer);
base.ClearClassList();
base.AddToClassList("groupNode");
base.clippingOptions = VisualElement.ClippingOptions.ClipAndCacheContents;
base.capabilities |= (Capabilities.Selectable | Capabilities.Movable | Capabilities.Deletable);
this.m_HeaderItem.RegisterCallback <PostLayoutEvent>(new EventCallback <PostLayoutEvent>(this.OnHeaderSizeChanged), Capture.NoCapture);
base.RegisterCallback <PostLayoutEvent>(delegate(PostLayoutEvent e)
{
this.MoveElements();
}, Capture.NoCapture);
base.RegisterCallback <MouseDownEvent>(new EventCallback <MouseDownEvent>(this.OnMouseUpEvent), Capture.NoCapture);
}
public BuilderInspectorInheritedStyles(BuilderInspector inspector, BuilderInspectorMatchingSelectors matchingSelectors)
{
m_Inspector = inspector;
m_Selection = inspector.selection;
m_PaneWindow = inspector.paneWindow;
m_MatchingSelectors = matchingSelectors;
m_InheritedStylesSection = m_Inspector.Q <PersistedFoldout>("inspector-inherited-styles-foldout");
m_ClassListContainer = m_Inspector.Q("class-list-container");
m_MatchingSelectorsFoldout = m_Inspector.Q <PersistedFoldout>("matching-selectors-container");
m_AddClassField = m_Inspector.Q <TextField>("add-class-field");
m_AddClassField.isDelayed = true;
m_AddClassField.RegisterCallback <KeyUpEvent>(OnAddClassFieldChange);
m_AddClassButton = m_Inspector.Q <Button>("add-class-button");
m_CreateClassButton = m_Inspector.Q <Button>("create-class-button");
m_ClassPillTemplate = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(
BuilderConstants.UIBuilderPackagePath + "/BuilderClassPill.uxml");
m_AddClassButton.clickable.clicked += AddStyleClass;
m_CreateClassButton.clickable.clicked += ExtractLocalStylesToNewClass;
}
private static bool ResolveType(XElement elt, VisualTreeAsset visualTreeAsset, out VisualElementAsset vea)
{
string fullName;
if (visualTreeAsset.AliasExists(elt.Name.LocalName))
{
vea = new TemplateAsset(elt.Name.LocalName);
}
else
{
fullName = String.IsNullOrEmpty(elt.Name.NamespaceName)
? elt.Name.LocalName
: elt.Name.NamespaceName + "." + elt.Name.LocalName;
// HACK: wait for Theo's PR OR go with that
if (fullName == typeof(VisualElement).FullName)
{
fullName = typeof(VisualContainer).FullName;
}
vea = new VisualElementAsset(fullName);
}
return(true);
}
static void GenerateUXMLFromRootElements(
VisualTreeAsset vta,
Dictionary<int, List<VisualElementAsset>> idToChildren,
StringBuilder stringBuilder,
string vtaPath,
bool writingToFile)
{
List<VisualElementAsset> rootAssets;
// Tree root has parentId == 0
idToChildren.TryGetValue(0, out rootAssets);
if (rootAssets == null || rootAssets.Count == 0)
return;
#if UNITY_2020_1_OR_NEWER
//vta.AssignClassListFromAssetToElement(rootAssets[0], target);
//vta.AssignStyleSheetFromAssetToElement(rootAssets[0], target);
// Get the first-level elements. These will be instantiated and added to target.
idToChildren.TryGetValue(rootAssets[0].id, out rootAssets);
if (rootAssets == null || rootAssets.Count == 0)
return;
#endif
rootAssets.Sort(VisualTreeAssetUtilities.CompareForOrder);
foreach (VisualElementAsset rootElement in rootAssets)
{
Assert.IsNotNull(rootElement);
// Don't try to include the special selection tracking element.
if (writingToFile && rootElement.fullTypeName == BuilderConstants.SelectedVisualTreeAssetSpecialElementTypeName)
continue;
GenerateUXMLRecursive(vta, vtaPath, rootElement, idToChildren, stringBuilder, 1, false, writingToFile);
}
}
//----------------------------------------------------------------------------------------------------------------------
public void Setup(VisualElement root)
{
m_root = root;
m_root.Clear();
VisualTreeAsset container = UIElementsEditorUtility.LoadVisualTreeAsset(
Path.Combine(MeshSyncEditorConstants.PROJECT_SETTINGS_UIELEMENTS_PATH, "DCCToolsSettings_Container")
);
VisualTreeAsset dccToolInfoTemplate = UIElementsEditorUtility.LoadVisualTreeAsset(
Path.Combine(MeshSyncEditorConstants.PROJECT_SETTINGS_UIELEMENTS_PATH, "DCCToolInfoTemplate")
);
TemplateContainer containerInstance = container.CloneTree();
ScrollView scrollView = containerInstance.Query <ScrollView>().First();
//[TODO-sin: 2020-4-24] Auto detect installed DCC tools + check MeshSync status
MeshSyncEditorSettings settings = MeshSyncEditorSettings.GetOrCreateSettings();
foreach (var dccToolInfo in settings.GetDCCToolInfos())
{
AddDCCToolSettingsContainer(dccToolInfo.Value, scrollView, dccToolInfoTemplate);
}
//Buttons
Button autoDetectButton = containerInstance.Query <Button>("AutoDetectButton").First();
autoDetectButton.clickable.clicked += OnAutoDetectButtonClicked;
Button addDCCToolButton = containerInstance.Query <Button>("AddDCCToolButton").First();
addDCCToolButton.clickable.clicked += OnAddDCCToolButtonClicked;
//Add the container of this tab to root
root.Add(containerInstance);
}
public static bool IsSelected(this VisualTreeAsset vta)
{
var foundElement = vta.FindElementByType(BuilderConstants.SelectedVisualTreeAssetSpecialElementTypeName);
return(foundElement != null);
}
public static StyleRule GetOrCreateInlineStyleRule(this VisualTreeAsset vta, VisualElementAsset vea)
{
bool wasCreated;
return(vta.GetOrCreateInlineStyleRule(vea, out wasCreated));
}
public override bool LoadDocument(VisualTreeAsset asset, bool unloadAllSubdocuments = true)
{
return(m_Toolbar.LoadDocument(asset, unloadAllSubdocuments));
}
public CommandItem(CommandEditorDomain domain, CommandListView parentList,
PersistentSerializedProperty property,
Action <CommandItem, CommandListView, int> onMove) : base()
{
Domain = domain;
ParentList = parentList;
CommandProperty = property;
this.binding = new CommandItemBinding(() =>
{
if (this != Domain.SelectedItem)
{
return;
}
UpdateCommandDetail();
});
VisualTreeAsset uiAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(visualTreeAssetPath);
VisualElement root = uiAsset.CloneTree();
this.Add(root);
this.AddManipulator(new CommandMovableManipulator(this));
this.AddManipulator(new CommandMoveTargetManipulator(
ParentList,
part =>
{
switch (part)
{
case MovementPart.Top:
return(GetIndex());
case MovementPart.Bottom:
return(GetIndex() + 1);
default:
throw new ArgumentOutOfRangeException(nameof(part), part, null);
}
},
() =>
{
this.style.borderBottomWidth = new StyleFloat(0f);
this.style.borderTopWidth = new StyleFloat(3f);
this.style.borderTopColor = new StyleColor(new Color(0.2f, 0.3411765f, 0.8509805f));
},
() =>
{
this.style.borderTopWidth = new StyleFloat(0f);
this.style.borderBottomWidth = new StyleFloat(3f);
this.style.borderBottomColor = new StyleColor(new Color(0.2f, 0.3411765f, 0.8509805f));
},
() =>
{
this.style.borderTopWidth = new StyleFloat(0f);
this.style.borderBottomWidth = new StyleFloat(0f);
}));
this.RegisterCallback <MouseDownEvent>(evt =>
{
evt.StopPropagation();
Select();
});
var enabledToggle = this.Q <Toggle>("CommandEnabled");
enabledToggle.RegisterCallback <ChangeEvent <bool> >(evt =>
{
var prop = CommandProperty.GetProperty();
var propEnabled = prop.FindPropertyRelative("enabled");
propEnabled.boolValue = evt.newValue;
propEnabled.serializedObject.ApplyModifiedProperties();
});
//string typeName = GetTypeName();
var customContentContainer = this.Q <VisualElement>("CommandCustomDetailContent");
customContentContainer.Clear();
Editor = CreateEditor(GetCommandType(), this, customContentContainer);
UpdateCommandDetail();
}
public virtual void Activate(BuilderPaneWindow paneWindow, BuilderSelection selection, VisualTreeAsset visualTreeAsset, VisualElement target)
{
base.Activate(target);
if (target == null)
{
return;
}
m_PaneWindow = paneWindow;
m_Selection = selection;
m_VisualTreeAsset = visualTreeAsset;
}
void LoadXml(XElement elt, VisualElementAsset parent, VisualTreeAsset vta, int orderInDocument)
{
VisualElementAsset vea = ResolveType(elt, vta);
if (vea == null)
{
return;
}
int parentHash;
if (parent == null)
{
vea.parentId = 0;
parentHash = vta.GetHashCode();
}
else
{
vea.parentId = parent.id;
parentHash = parent.id;
}
// id includes the parent id, meaning it's dependent on the whole direct hierarchy
vea.id = (vta.GetNextChildSerialNumber() + 585386304) * -1521134295 + parentHash;
vea.orderInDocument = orderInDocument;
bool startedRule = ParseAttributes(elt, vea, vta, parent);
// each vea will creates 0 or 1 style rule, with one or more properties
// they don't have selectors and are directly referenced by index
// it's then applied during tree cloning
vea.ruleIndex = startedRule ? m_Builder.EndRule() : -1;
var templateAsset = vea as TemplateAsset;
if (templateAsset != null)
{
vta.templateAssets.Add(templateAsset);
}
else
{
vta.visualElementAssets.Add(vea);
}
if (elt.HasElements)
{
foreach (XElement child in elt.Elements())
{
if (child.Name.LocalName == k_StyleReferenceNode)
{
LoadStyleReferenceNode(vea, child);
}
else if (templateAsset != null && child.Name.LocalName == k_AttributeOverridesNode)
{
LoadAttributeOverridesNode(templateAsset, child);
}
else
{
++orderInDocument;
LoadXml(child, vea, vta, orderInDocument);
}
}
}
}
public void Render(VisualTreeAsset vta, Rect r, GUIStyle background)
{
if (Event.current.type != EventType.Repaint || r.width < 100 && r.height < 100)
{
return;
}
bool dirty = false;
if (vta != m_LastTree || !m_LastTree)
{
m_LastTree = vta;
m_Tree = (vta as UnityEngine.UIElements.VisualTreeAsset).Instantiate();
m_Tree.StretchToParentSize();
dirty = true;
}
if (m_Panel == null)
{
m_Panel = UIElementsUtility.FindOrCreateEditorPanel(m_LastTree);
var visualTree = m_Panel.visualTree;
visualTree.pseudoStates |= PseudoStates.Root;
UIElementsEditorUtility.AddDefaultEditorStyleSheets(visualTree);
dirty = true;
}
if (dirty)
{
m_Panel.visualTree.Clear();
m_Panel.visualTree.Add(m_Tree);
}
EditorGUI.DrawRect(r, EditorGUIUtility.kViewBackgroundColor);
m_Panel.visualTree.SetSize(r.size); // We will draw relative to a viewport covering the preview area, so draw at 0,0
m_Panel.visualTree.IncrementVersion(VersionChangeType.Repaint);
var oldState = SavedGUIState.Create();
int clips = GUIClip.Internal_GetCount();
while (clips > 0)
{
GUIClip.Pop();
clips--;
}
float pixelsPerPoint = EditorGUIUtility.pixelsPerPoint;
var desc = new RenderTextureDescriptor((int)(r.width * pixelsPerPoint), (int)(r.height * pixelsPerPoint), RenderTextureFormat.ARGB32, 16);
var rt = RenderTexture.GetTemporary(desc);
var oldRt = RenderTexture.active;
RenderTexture.active = rt;
GL.LoadPixelMatrix(0, rt.width, rt.height, 0);
m_Panel.Repaint(Event.current);
RenderTexture.active = oldRt;
oldState.ApplyAndForget();
GUI.DrawTexture(r, rt);
RenderTexture.ReleaseTemporary(rt);
}
public static void Swallow(this VisualTreeAsset vta, VisualElementAsset parent, VisualTreeAsset other)
{
var otherIdToChildren = VisualTreeAssetUtilities.GenerateIdToChildren(other);
if (parent == null)
{
parent = vta.GetRootUXMLElement();
}
var nextOrderInDocument = (vta.visualElementAssets.Count + vta.templateAssets.Count) * BuilderConstants.VisualTreeAssetOrderIncrement;
foreach (var vea in other.visualElementAssets)
{
if (other.IsRootUXMLElement(vea))
{
continue;
}
ReinitElementWithNewParentAsset(
vta, parent, other, otherIdToChildren, vea, ref nextOrderInDocument);
vta.visualElementAssets.Add(vea);
}
foreach (var vea in other.templateAssets)
{
ReinitElementWithNewParentAsset(
vta, parent, other, otherIdToChildren, vea, ref nextOrderInDocument);
if (!vta.TemplateExists(vea.templateAlias))
{
var path = other.GetPathFromTemplateName(vea.templateAlias);
vta.RegisterTemplate(vea.templateAlias, path);
}
vta.templateAssets.Add(vea);
}
VisualTreeAssetUtilities.ReOrderDocument(vta);
}
internal static void LinkedCloneTree(this VisualTreeAsset vta, VisualElement target)
{
VisualTreeAssetLinkedCloneTree.CloneTree(vta, target);
}
public override void LoadDocument(VisualTreeAsset asset, bool unloadAllSubdocuments = true)
{
m_Toolbar.LoadDocument(asset, unloadAllSubdocuments);
}
void LoadTemplateNode(VisualTreeAsset vta, XElement elt, XElement child)
{
bool hasPath = false;
bool hasSrc = false;
string name = null;
string path = null;
string src = null;
foreach (var xAttribute in child.Attributes())
{
switch (xAttribute.Name.LocalName)
{
case k_GenericPathAttr:
hasPath = true;
path = xAttribute.Value;
break;
case k_GenericSrcAttr:
hasSrc = true;
src = xAttribute.Value;
break;
case k_TemplateNameAttr:
name = xAttribute.Value;
if (String.IsNullOrEmpty(name))
{
logger.LogError(ImportErrorType.Semantic,
ImportErrorCode.TemplateHasEmptyName,
child,
Error.Level.Fatal,
child
);
}
break;
default:
logger.LogError(ImportErrorType.Semantic,
ImportErrorCode.UnknownAttribute,
xAttribute.Name.LocalName,
Error.Level.Fatal,
child
);
break;
}
}
if (hasPath == hasSrc)
{
logger.LogError(ImportErrorType.Semantic,
hasPath ? ImportErrorCode.TemplateSrcAndPathBothSpecified : ImportErrorCode.TemplateMissingPathOrSrcAttribute,
null,
Error.Level.Fatal,
elt
);
return;
}
if (String.IsNullOrEmpty(name))
{
name = Path.GetFileNameWithoutExtension(path);
}
if (vta.TemplateExists(name))
{
logger.LogError(ImportErrorType.Semantic,
ImportErrorCode.DuplicateTemplateName,
name,
Error.Level.Fatal,
elt
);
return;
}
if (hasPath)
{
vta.RegisterTemplate(name, path);
}
else if (hasSrc)
{
string errorMessage, projectRelativePath;
URIValidationResult result = URIHelpers.ValidAssetURL(assetPath, src, out errorMessage, out projectRelativePath);
if (result != URIValidationResult.OK)
{
logger.LogError(ImportErrorType.Semantic, ConvertErrorCode(result), errorMessage, Error.Level.Fatal, elt);
}
else
{
Object asset = DeclareDependencyAndLoad(projectRelativePath);
if (asset is VisualTreeAsset)
{
vta.RegisterTemplate(name, asset as VisualTreeAsset);
}
else
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.ReferenceInvalidAssetType, projectRelativePath, Error.Level.Fatal, elt);
}
}
}
}
public UIScreen With(VisualTreeAsset builder)
{
overrideBuilder = builder;
return(this);
}
bool ParseAttributes(XElement elt, VisualElementAsset res, VisualTreeAsset vta, VisualElementAsset parent)
{
bool startedRule = false;
foreach (XAttribute xattr in elt.Attributes())
{
string attrName = xattr.Name.LocalName;
// start with special cases
switch (attrName)
{
case "class":
res.AddProperty(xattr.Name.LocalName, xattr.Value);
res.classes = xattr.Value.Split(' ');
continue;
case "content-container":
case "contentContainer":
res.AddProperty(xattr.Name.LocalName, xattr.Value);
if (attrName == "contentContainer")
{
}
if (vta.contentContainerId != 0)
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.DuplicateContentContainer, null, Error.Level.Fatal, elt);
continue;
}
vta.contentContainerId = res.id;
continue;
case k_SlotDefinitionAttr:
logger.LogError(ImportErrorType.Syntax, ImportErrorCode.SlotsAreExperimental, null, Error.Level.Warning, elt);
if (String.IsNullOrEmpty(xattr.Value))
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.SlotDefinitionHasEmptyName, null, Error.Level.Fatal, elt);
}
else if (!vta.AddSlotDefinition(xattr.Value, res.id))
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.DuplicateSlotDefinition, xattr.Value, Error.Level.Fatal, elt);
}
continue;
case k_SlotUsageAttr:
logger.LogError(ImportErrorType.Syntax, ImportErrorCode.SlotsAreExperimental, null, Error.Level.Warning, elt);
var templateAsset = parent as TemplateAsset;
if (templateAsset == null)
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.SlotUsageInNonTemplate, parent, Error.Level.Fatal, elt);
continue;
}
if (string.IsNullOrEmpty(xattr.Value))
{
logger.LogError(ImportErrorType.Semantic, ImportErrorCode.SlotUsageHasEmptyName, null, Error.Level.Fatal, elt);
continue;
}
templateAsset.AddSlotUsage(xattr.Value, res.id);
continue;
case "style":
res.AddProperty(xattr.Name.LocalName, xattr.Value);
ExCSS.StyleSheet parsed = new Parser().Parse("* { " + xattr.Value + " }");
if (parsed.Errors.Count != 0)
{
logger.LogError(
ImportErrorType.Semantic,
ImportErrorCode.InvalidCssInStyleAttribute,
parsed.Errors.Aggregate("", (s, error) => s + error.ToString() + "\n"),
Error.Level.Warning,
xattr);
continue;
}
if (parsed.StyleRules.Count != 1)
{
logger.LogError(
ImportErrorType.Semantic,
ImportErrorCode.InvalidCssInStyleAttribute,
"Expected one style rule, found " + parsed.StyleRules.Count,
Error.Level.Warning,
xattr);
continue;
}
m_Builder.BeginRule(-1);
startedRule = true;
foreach (Property prop in parsed.StyleRules[0].Declarations)
{
m_Builder.BeginProperty(prop.Name);
VisitValue(prop.Term);
m_Builder.EndProperty();
}
// Don't call m_Builder.EndRule() here, it's done in LoadXml to get the rule index at the same time !
continue;
}
res.AddProperty(xattr.Name.LocalName, xattr.Value);
}
return(startedRule);
}
void VisualTreeAssetChanged(ChangeEvent <Object> evt)
{
m_VisualTreeAsset = evt.newValue as VisualTreeAsset;
CloneTree();
}
public static string GetVisualTreeAssetAssetName(VisualTreeAsset visualTreeAsset, bool hasUnsavedChanges) => GetAssetName(visualTreeAsset, BuilderConstants.UxmlExtension, hasUnsavedChanges);
public static bool IsRootElement(this VisualTreeAsset vta, VisualElementAsset vea)
{
return(vea.parentId == vta.GetRootUXMLElementId());
}
public virtual void LoadDocument(VisualTreeAsset asset, bool unloadAllSubdocuments = true)
{
// Nothing to do by default.
}
public static void ConvertAllAssetReferencesToPaths(this VisualTreeAsset vta)
{
#if UNITY_2019_3_OR_NEWER
var sheets = new HashSet <StyleSheet>();
foreach (var asset in vta.visualElementAssets)
{
sheets.Clear();
foreach (var styleSheet in asset.stylesheets)
{
sheets.Add(styleSheet);
}
foreach (var sheetPath in asset.stylesheetPaths)
{
var sheetAsset = AssetDatabase.LoadAssetAtPath <StyleSheet>(sheetPath);
if (sheetAsset == null)
{
sheetAsset = Resources.Load <StyleSheet>(sheetPath);
if (sheetAsset == null)
{
continue;
}
}
sheets.Add(sheetAsset);
}
asset.stylesheetPaths.Clear();
foreach (var sheet in sheets)
{
var path = AssetDatabase.GetAssetPath(sheet);
if (string.IsNullOrEmpty(path))
{
continue;
}
asset.stylesheetPaths.Add(path);
}
}
var fieldInfo = UsingsListFieldInfo;
if (fieldInfo != null)
{
var usings = fieldInfo.GetValue(vta) as List <VisualTreeAsset.UsingEntry>;
if (usings != null && usings.Count > 0)
{
for (int i = 0; i < usings.Count; ++i)
{
if (usings[i].asset == null)
{
continue;
}
var u = usings[i];
u.path = AssetDatabase.GetAssetPath(u.asset);
usings[i] = u;
}
}
}
else
{
Debug.LogError("UI Builder: VisualTreeAsset.m_Usings field has not been found! Update the reflection code!");
}
#endif
}
public void Deactivate()
{
m_Selection = null;
m_VisualTreeAsset = null;
m_Target = null;
}
internal static VisualElementAsset AddElement(
this VisualTreeAsset vta, VisualElementAsset parent, VisualElementAsset vea)
{
return(VisualTreeAssetUtilities.AddElementToDocument(vta, vea, parent));
}
