public Image GenerateProxyImage(Dictionary <string, string> values)
{
TemplateDefinition cardDef = TemplateSelector.GetTemplate(values);
Image ret = ProxyGenerator.GenerateProxy(BlockManager, RootPath, cardDef, values);
return(ret);
}
protected virtual DataTemplate GetTemplateFor(object item)
{
var template = ItemTemplate;
if (TemplateSelector != null)
{
template = TemplateSelector.SelectTemplate(item, null);
}
return(template);
}
public override void OnInspectorGUI()
{
if (GUILayout.Button("New Object"))
{
TemplateSelector.Initialize();
TemplateSelector.Scene = ((SceneDetails)serializedObject.targetObject).gameObject;
}
base.OnInspectorGUI();
}
private void UpdateContent()
{
if (BindingContext == null || TemplateSelector == null)
{
return;
}
var template = TemplateSelector.SelectTemplate(SelectorItem ?? BindingContext, this);
Content = template.CreateContent() as View;
}
internal void Load(string path)
{
if (Document != null)
{
Document.RemoveAll();
Document = null;
TemplateSelector.ClearTemplates();
}
Document = new XmlDocument();
Document.Load(path);
LoadTemplates();
}
private void OkClick([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
var selectedTemplate = SelectedTemplate;
if (selectedTemplate != null)
{
TemplateSelector.AddToRecent(selectedTemplate);
}
this.Close(true);
}
public void LoadContent()
{
if (TemplateSelector == null)
{
TemplateSelector = (AsyncLoadStateTemplateSelector)Resources["DefaultAsyncLoadStateTemplateSelector"];
}
var tempContent = (FrameworkElement)TemplateSelector.SelectTemplate(this, this).LoadContent();
// 仅在有错误的情况下，设置DataContext以便于错误页的信息展示
if (ErrorMessage != null && ErrorMessage.Length > 0)
{
tempContent.SetValue(FrameworkElement.DataContextProperty, this);
}
Content = tempContent;
}
public override Object OnCreateGroupViewHolder(ViewGroup parent, int viewType)
{
var itemBindingContext = new MvxAndroidBindingContext(parent.Context, BindingContext.LayoutInflaterHolder);
var viewHolder =
new MvxExpandableRecyclerViewHolder(
InflateViewForHolder(TemplateSelector.GetItemLayoutId(viewType), parent, viewType, itemBindingContext),
itemBindingContext)
{
Click = GroupItemClickCommand,
LongClick = GroupItemLongClickCommand
};
return(viewHolder);
}
internal void LoadTemplates()
{
XmlNodeList blockList = Document.GetElementsByTagName("blocks");
BlockManager = new BlockManager(RootPath);
BlockManager.LoadBlocks(blockList[0]);
XmlNodeList templateList = Document.GetElementsByTagName("template");
foreach (XmlNode template in templateList)
{
TemplateDefinition templateDef = TemplateDefinition.LoadCardDefinition(template);
templateDef.rootPath = RootPath;
TemplateSelector.AddTemplate(templateDef);
}
}
public void NoFunctions()
{
// invalid error strategy
ExceptionAssert.Throws <ArgumentOutOfRangeException>(
() => TemplateSelector.Create <int>(errorStrategy: (SelectorErrorStrategy)int.MaxValue),
"errorStrategy");
// with ConverterErrorStrategy.ReturnDefaultValue (default)
Assert.AreEqual <DataTemplate?>(null, TemplateSelector.Create <int>().SelectTemplate(1, null));
// with ConverterErrorStrategy.ReturnNewEmptyDataTemplate
DataTemplate result = TemplateSelector.Create <int>(errorStrategy: SelectorErrorStrategy.ReturnNewEmptyDataTemplate).SelectTemplate(1, null);
Assert.IsNotNull(result);
Assert.IsFalse(result.HasContent);
}
/// <summary>
/// Show dropdown for selecting a collection to bind to.
/// </summary>
private void ShowPropertySelector(TemplateSelector targetScript, PropertyInfo[] bindableViews)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("View to bind to");
var dropdownPosition = GUILayoutUtility.GetLastRect();
dropdownPosition.x += dropdownPosition.width;
if (GUILayout.Button(new GUIContent(targetScript.viewModelPropertyName), EditorStyles.popup))
{
ShowPropertySelectorDropdown(targetScript, bindableViews, dropdownPosition);
}
EditorGUILayout.EndHorizontal();
}
public void WithSelectFunction()
{
// with an input value of an unexpected type (use default error strategy)
Assert.IsNull(TemplateSelector.Create <int>(e => new DataTemplate()).SelectTemplate(true, null));
Assert.IsNull(TemplateSelector.Create <int>(e => new DataTemplate()).SelectTemplate(null, null));
// with a valid input value
DataTemplate template = new DataTemplate();
Assert.AreEqual(template, TemplateSelector.Create <int>(
e =>
{
Assert.AreEqual(1, e.Item);
return(template);
}).SelectTemplate(1, null));
}
public override int GetItemViewType(int position)
{
int viewType = base.GetItemViewType(position);
var template = TemplateSelector.GetTemplate(adapter, position);
lock (lockObj)
{
viewType = templates.IndexOf(template);
if (viewType < 0)
{
templates.Add(template);
viewType = templates.Count - 1;
}
}
return(viewType);
}
public void CompareTemplateSelectorArgs()
{
StructAssert.IsCorrect <TemplateSelectorArgs <int> >();
var arg = default(TemplateSelectorArgs <int>);
DataTemplate template = new DataTemplate();
Assert.AreEqual(
template,
TemplateSelector.Create <int>(
e =>
{
arg = e;
return(template);
}).SelectTemplate(1, null));
StructAssert.AreEqual(arg, (x, y) => x == y, (x, y) => x != y);
StructAssert.AreNotEqual(arg, default, (x, y) => x == y, (x, y) => x != y);
/// <summary>
/// Draws the dropdown for selecting a method from bindableViewModelProperties
/// </summary>
private void ShowPropertySelectorDropdown(TemplateSelector targetScript, PropertyInfo[] bindableViews, Rect position)
{
var selectedIndex = Array.IndexOf(
bindableViews.Select(m => m.ReflectedType + m.Name).ToArray(),
targetScript.viewModelName + targetScript.viewModelPropertyName
);
var options = bindableViews.Select(m =>
new InspectorUtils.MenuItem(
new GUIContent(m.ReflectedType + "/" + m.Name),
true
)
).ToArray();
InspectorUtils.ShowCustomSelectionMenu(
index => SetViewModelProperty(targetScript, bindableViews[index]),
options,
selectedIndex,
position);
}
internal void Load(string path)
{
if (Document != null)
{
Document.RemoveAll();
Document = null;
TemplateSelector.ClearTemplates();
}
Document = new XmlDocument();
Document.Load(path);
XmlNodeList blockList = Document.GetElementsByTagName("blocks");
BlockManager = new BlockManager(RootPath);
foreach (XmlNode block in blockList[0])
{
if (block.Name != "block")
{
continue;
}
BlockDefinition blockDef = ProxyDeserializer.DeserializeBlock(BlockManager, block);
BlockManager.AddBlock(blockDef);
}
XmlNodeList templateList = Document.GetElementsByTagName("template");
foreach (XmlNode template in templateList)
{
if (template.Name != "template")
{
continue;
}
TemplateDefinition templateDef = ProxyDeserializer.DeserializeTemplate(template);
templateDef.rootPath = RootPath;
TemplateSelector.AddTemplate(templateDef);
}
}
public override void OnBindViewHolder(RecyclerView.ViewHolder holder, int position)
{
var info = TemplateSelector.GetInfo(adapter, position);
if (info == null)
{
return;
}
// The template selector doesn't infer selected properly
// so we need to ask the listview which tracks selections about the state
info.IsSelected = info.Kind == PositionKind.Item &&
(Element?.IsItemSelected(info.SectionIndex, info.ItemIndex) ?? false);
var item = info.BindingContext ?? BindingContext;
if (item != null && holder is RvItemHolder itemHolder && itemHolder.ViewCell != null)
{
itemHolder.PositionInfo = info;
itemHolder.ViewCell.BindingContext = item;
itemHolder.ViewCell.Update(info);
itemHolder.ViewCell.View.InvalidateMeasureNonVirtual(Xamarin.Forms.Internals.InvalidationTrigger.MeasureChanged);
}
}
public override int GetChildItemViewType(int p0, int p1) => TemplateSelector.GetItemViewType(GetItemAt(p0, p1));
/// <summary>
/// Set up the viewModelName and viewModelPropertyname in the TemplateSelector we're editing.
/// </summary>
private void SetViewModelProperty(TemplateSelector target, PropertyInfo property)
{
target.viewModelName = property.ReflectedType.Name;
target.viewModelPropertyName = property.Name;
}
private PropertyInfo[] GetBindableViews(TemplateSelector target)
{
return(target.GetAvailableViewModelTypes()
.SelectMany(type => type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
.ToArray());
}
public override int GetGroupItemViewType(int p0) => TemplateSelector.GetItemViewType(GetItemAt(p0));
public static void ParseFile(DataContext context, File file, int projectId)
{
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(file.Content);
var nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("xsl", "http://www.w3.org/1999/XSL/Transform");
var importNodes = xmlDoc.SelectNodes("//xsl:import", nsmgr);
for (var i = 0; i < importNodes.Count; i++)
{
XmlNode importNode = importNodes[i];
var importPath = importNode.Attributes["href"].Value;
context.FilesRelations.Add(new FilesRelation
{
Source = context.Files.Local.First(f => f.Path.ToLower() == importPath.ToLower() &&
f.Project.Id == projectId),
Target = file,
Order = i,
Mode = FilesRelationMode.Import
});
}
var includeNodes = xmlDoc.SelectNodes("//xsl:include", nsmgr);
for (var i = 0; i < includeNodes.Count; i++)
{
XmlNode includeNode = includeNodes[i];
var includePath = includeNode.Attributes["href"].Value;
context.FilesRelations.Add(new FilesRelation
{
Source = context.Files.Local.First(f => f.Path.ToLower() == includePath.ToLower() &&
f.Project.Id == projectId),
Target = file,
Order = i,
Mode = FilesRelationMode.Include
});
}
var templates = xmlDoc.SelectNodes("//xsl:template", nsmgr);
foreach (XmlNode templateNode in templates)
{
var match = templateNode.Attributes["match"] != null ? templateNode.Attributes["match"].Value : "";
var name = templateNode.Attributes["name"] != null ? templateNode.Attributes["name"].Value : "";
var mode = templateNode.Attributes["mode"] != null ? templateNode.Attributes["mode"].Value : "";
TemplateSelector selector = match.Length > 0 ? TemplateSelector.Match : TemplateSelector.Name;
var template = new Template
{
Content = templateNode.InnerXml,
File = file,
Mode = mode,
Selector = selector,
SelectorValue = selector == TemplateSelector.Match ? match : name
};
context.Templates.Add(template);
ParseTemplateData(context, templateNode, template, nsmgr);
}
}
