public XamlSetTypeConverterEventArgs (XamlMember member, TypeConverter typeConverter, object value, ITypeDescriptorContext serviceProvider, CultureInfo cultureInfo)
: base (member, value)
{
CultureInfo = cultureInfo;
ServiceProvider = serviceProvider;
TypeConverter = typeConverter;
}
public void WriteStartMember(XamlMember property)
{
bag.Current.Property = property;
if (bag.Current.Instance == null)
{
objectAssembler.PrepareNewInstanceBecauseWeWantToConfigureIt(bag);
}
}
private IEnumerable<XamlNode> ParseCollectionInsideThisProperty(XamlMember member)
{
yield return Inject.StartOfMember(member);
yield return Inject.GetObject();
yield return Inject.Items();
foreach (var xamlNode in ParseElements()) yield return xamlNode;
yield return Inject.EndOfMember();
yield return Inject.EndOfObject();
yield return Inject.EndOfMember();
}
public XamlSetMarkupExtensionEventArgs(XamlMember member, MarkupExtension value, IServiceProvider serviceProvider)
: base(member, null)
{
MarkupExtension = value;
ServiceProvider = serviceProvider;
}
public XamlDuplicateMemberException (XamlMember member, XamlType type)
: this (String.Format ("duplicate member '{0}' in type '{1}'", member, type))
{
DuplicateMember = member;
ParentType = type;
}
void SetValue (XamlMember member, object target, object value)
{
if (!source.OnSetValue (target, member, value))
member.Invoker.SetValue (target, value);
}
// Note that it could return invalid (None) node to tell the caller that it is not really an object element.
IEnumerable<XamlXmlNodeInfo> ReadObjectElement (XamlType parentType, XamlMember currentMember)
{
if (r.NodeType != XmlNodeType.Element) {
//throw new XamlParseException (String.Format ("Element is expected, but got {0}", r.NodeType));
yield return Node (XamlNodeType.Value, r.Value);
yield break;
}
if (r.MoveToFirstAttribute ()) {
do {
if (r.NamespaceURI == XamlLanguage.Xmlns2000Namespace)
yield return Node (XamlNodeType.NamespaceDeclaration, new NamespaceDeclaration (r.Value, r.Prefix == "xmlns" ? r.LocalName : String.Empty));
} while (r.MoveToNextAttribute ());
r.MoveToElement ();
}
var sti = GetStartTagInfo ();
var xt = sctx.GetXamlType (sti.TypeName);
if (xt == null) {
// Current element could be for another member in the parent type (if exists)
if (parentType != null && (r.LocalName.IndexOf ('.') > 0 || parentType.GetMember (r.LocalName) != null)) {
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return Node (XamlNodeType.None, null);
yield break;
}
// creates name-only XamlType. Also, it does not seem that it does not store this XamlType to XamlSchemaContext (Try GetXamlType(xtn) after reading such xaml node, it will return null).
xt = new XamlType (sti.Namespace, sti.Name, sti.TypeName.TypeArguments == null ? null : sti.TypeName.TypeArguments.Select<XamlTypeName,XamlType> (xxtn => sctx.GetXamlType (xxtn)).ToArray (), sctx);
}
bool isGetObject = false;
if (currentMember != null && !xt.CanAssignTo (currentMember.Type)) {
if (currentMember.DeclaringType != null && currentMember.DeclaringType.ContentProperty == currentMember)
isGetObject = true;
// It could still be GetObject if current_member
// is not a directive and current type is not
// a markup extension.
// (I'm not very sure about the condition;
// it could be more complex.)
// seealso: bug #682131
else if (!(currentMember is XamlDirective) &&
!xt.IsMarkupExtension)
isGetObject = true;
}
if (isGetObject) {
yield return Node (XamlNodeType.GetObject, currentMember.Type);
foreach (var ni in ReadMembers (parentType, currentMember.Type))
yield return ni;
yield return Node (XamlNodeType.EndObject, currentMember.Type);
yield break;
}
// else
yield return Node (XamlNodeType.StartObject, xt);
// process attribute members (including MarkupExtensions)
ProcessAttributesToMember (sctx, sti, xt);
foreach (var pair in sti.Members) {
yield return Node (XamlNodeType.StartMember, pair.Key);
// Try markup extension
// FIXME: is this rule correct?
var v = pair.Value;
if (!String.IsNullOrEmpty (v) && v [0] == '{') {
var pai = ParsedMarkupExtensionInfo.Parse (v, xaml_namespace_resolver, sctx);
yield return Node (XamlNodeType.StartObject, pai.Type);
foreach (var xepair in pai.Arguments) {
yield return Node (XamlNodeType.StartMember, xepair.Key);
if (xepair.Value is List<string>)
foreach (var s in (List<string>) xepair.Value)
yield return Node (XamlNodeType.Value, s);
else
yield return Node (XamlNodeType.Value, xepair.Value);
yield return Node (XamlNodeType.EndMember, xepair.Key);
}
yield return Node (XamlNodeType.EndObject, pai.Type);
}
else
yield return Node (XamlNodeType.Value, pair.Value);
yield return Node (XamlNodeType.EndMember, pair.Key);
}
// process content members
if (!r.IsEmptyElement) {
r.Read ();
foreach (var ni in ReadMembers (parentType, xt))
yield return ni;
r.ReadEndElement ();
}
else
r.Read (); // consume empty element.
yield return Node (XamlNodeType.EndObject, xt);
}
// member element, implicit member, children via content property, or value
IEnumerable<XamlXmlNodeInfo> ReadMemberElement (XamlType parentType, XamlType xt)
{
XamlMember xm = null;
var name = r.LocalName;
int idx = name.IndexOf ('.');
string typeName = null;
if (idx >= 0) {
typeName = name.Substring (0, idx);
name = name.Substring (idx + 1);
// check if it is an attachable member first, either of this type or another type
// Should this also check the namespace to find the correct type?
if (typeName == xt.GetInternalXmlName())
xm = xt.GetMember (name);
else
xm = FindAttachableMember (r.Prefix, typeName, name);
} else {
xm = (XamlMember)FindStandardDirective (name, AllowedMemberLocations.MemberElement);
if (xm == null) {
// still not? could it be omitted as content property or items ?
if ((xm = GetExtraMember (xt)) != null) {
// Note that this does not involve r.Read()
foreach (var ni in ReadMember (xt, xm))
yield return ni;
yield break;
}
}
}
if (xm == null) {
// Current element could be for another member in the parent type (if exists)
if (parentType != null
&& typeName != null
&& typeName == parentType.GetInternalXmlName ()
&& parentType.GetMember (name) != null) {
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return Node (XamlNodeType.None, null);
yield break;
}
// ok, then create unknown member.
xm = new XamlMember (name, xt, false); // FIXME: not sure if isAttachable is always false.
}
if (!r.IsEmptyElement) {
r.Read ();
foreach (var ni in ReadMember (xt, xm))
yield return ni;
r.MoveToContent ();
r.ReadEndElement ();
}
else
r.Read ();
}
protected internal virtual bool OnSetValue (object eventSender, XamlMember member, object value)
{
if (settings.XamlSetValueHandler != null) {
var args = new XamlSetValueEventArgs (member, value);
settings.XamlSetValueHandler (eventSender, args);
return args.Handled;
}
return false;
}
public XamlDomMember(XamlMember xamlMember, object value)
: this(xamlMember)
{
Item = new XamlDomValue(value);
Resolve();
}
public static void SetValue(object instance, XamlMember parentProperty, object value)
{
parentProperty.XamlMemberValueConnector.SetValue(instance, value);
}
// We should avoid keying off the type of the invoker here
private static bool HasDefaultInvoker(XamlMember xamlMember)
{
return(xamlMember.Invoker.GetType() == typeof(XamlMemberInvoker));
}
public override object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value, XamlMember property)
{
if (!MemberAccessPermissionDenied || ts.IsPublic || !IsDefaultConverter(ts))
{
try
{
return(_transparentRuntime.CreateFromValue(serviceContext, ts, value, property));
}
// We don't know if MissingMethodException is due to visibility or not.
// So we fall back to the elevated runtime, but we don't set _memberAccessPermissionDenied.
catch (MissingMethodException)
{
EnsureElevatedRuntime();
}
catch (MethodAccessException)
{
MemberAccessPermissionDenied = true;
}
catch (SecurityException)
{
MemberAccessPermissionDenied = true;
}
}
return(_elevatedRuntime.CreateFromValue(serviceContext, ts, value, property));
}
// No partial-trust fallback on these methods because we're not doing PT support in ObjectReader.
public override ShouldSerializeResult ShouldSerialize(XamlMember member, object instance)
{
return(_transparentRuntime.ShouldSerialize(member, instance));
}
protected abstract void OnWriteStartMember(XamlMember xm);
public MemberAndValue(XamlMember xm)
{
Member = xm;
}
private IXamlMember CreateXamlMember(string longMemberName)
{
XamlMember xamlMember = null;
XamlUserType userType;
switch (longMemberName)
{
case "Bing.Maps.Map.MapType":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "MapType", "Bing.Maps.MapType");
xamlMember.Getter = get_0_Map_MapType;
xamlMember.Setter = set_0_Map_MapType;
break;
case "Bing.Maps.Map.ZoomLevel":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "ZoomLevel", "Double");
xamlMember.Getter = get_1_Map_ZoomLevel;
xamlMember.Setter = set_1_Map_ZoomLevel;
break;
case "Bing.Maps.Map.Credentials":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "Credentials", "String");
xamlMember.Getter = get_2_Map_Credentials;
xamlMember.Setter = set_2_Map_Credentials;
break;
case "Bing.Maps.Map.Center":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "Center", "Bing.Maps.Location");
xamlMember.Getter = get_3_Map_Center;
xamlMember.Setter = set_3_Map_Center;
break;
case "Bing.Maps.Map.ShowScaleBar":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "ShowScaleBar", "Boolean");
xamlMember.Getter = get_4_Map_ShowScaleBar;
xamlMember.Setter = set_4_Map_ShowScaleBar;
break;
case "Bing.Maps.Map.TileLayers":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "TileLayers", "Bing.Maps.MapTileLayerCollection");
xamlMember.Getter = get_5_Map_TileLayers;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.MapTileLayer.Visible":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapTileLayer");
xamlMember = new XamlMember(this, "Visible", "Boolean");
xamlMember.Getter = get_6_MapTileLayer_Visible;
xamlMember.Setter = set_6_MapTileLayer_Visible;
break;
case "Bing.Maps.MapTileLayer.ZIndex":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapTileLayer");
xamlMember = new XamlMember(this, "ZIndex", "Int32");
xamlMember.Getter = get_7_MapTileLayer_ZIndex;
xamlMember.Setter = set_7_MapTileLayer_ZIndex;
break;
case "Bing.Maps.MapTileLayer.TileSource":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapTileLayer");
xamlMember = new XamlMember(this, "TileSource", "String");
xamlMember.Getter = get_8_MapTileLayer_TileSource;
xamlMember.Setter = set_8_MapTileLayer_TileSource;
break;
case "Bing.Maps.MapTileLayer.Opacity":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapTileLayer");
xamlMember = new XamlMember(this, "Opacity", "Double");
xamlMember.Getter = get_9_MapTileLayer_Opacity;
xamlMember.Setter = set_9_MapTileLayer_Opacity;
break;
case "Bing.Maps.Map.ShapeLayers":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "ShapeLayers", "Bing.Maps.MapShapeLayerCollection");
xamlMember.Getter = get_10_Map_ShapeLayers;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.MapShapeLayer.Visible":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapShapeLayer");
xamlMember = new XamlMember(this, "Visible", "Boolean");
xamlMember.Getter = get_11_MapShapeLayer_Visible;
xamlMember.Setter = set_11_MapShapeLayer_Visible;
break;
case "Bing.Maps.MapShapeLayer.ZIndex":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapShapeLayer");
xamlMember = new XamlMember(this, "ZIndex", "Int32");
xamlMember.Getter = get_12_MapShapeLayer_ZIndex;
xamlMember.Setter = set_12_MapShapeLayer_ZIndex;
break;
case "Bing.Maps.MapShapeLayer.Shapes":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapShapeLayer");
xamlMember = new XamlMember(this, "Shapes", "Bing.Maps.MapShapeCollection");
xamlMember.Getter = get_13_MapShapeLayer_Shapes;
xamlMember.Setter = set_13_MapShapeLayer_Shapes;
break;
case "Bing.Maps.MapShape.Visible":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.MapShape");
xamlMember = new XamlMember(this, "Visible", "Boolean");
xamlMember.Getter = get_14_MapShape_Visible;
xamlMember.Setter = set_14_MapShape_Visible;
break;
case "Bing.Maps.Map.Children":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "Children", "Bing.Maps.MapUIElementCollection");
xamlMember.Getter = get_15_Map_Children;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.RotationEnabled":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "RotationEnabled", "Boolean");
xamlMember.Getter = get_16_Map_RotationEnabled;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.TargetBounds":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "TargetBounds", "Bing.Maps.LocationRect");
xamlMember.Getter = get_17_Map_TargetBounds;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.Bounds":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "Bounds", "Bing.Maps.LocationRect");
xamlMember.Getter = get_18_Map_Bounds;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.ShowTraffic":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "ShowTraffic", "Boolean");
xamlMember.Getter = get_19_Map_ShowTraffic;
xamlMember.Setter = set_19_Map_ShowTraffic;
break;
case "Bing.Maps.Map.PreloadArea":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "PreloadArea", "Bing.Maps.PreloadArea");
xamlMember.Getter = get_20_Map_PreloadArea;
xamlMember.Setter = set_20_Map_PreloadArea;
break;
case "Bing.Maps.Map.TargetHeading":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "TargetHeading", "Double");
xamlMember.Getter = get_21_Map_TargetHeading;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.TargetZoomLevel":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "TargetZoomLevel", "Double");
xamlMember.Getter = get_22_Map_TargetZoomLevel;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.TargetCenter":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "TargetCenter", "Bing.Maps.Location");
xamlMember.Getter = get_23_Map_TargetCenter;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Map.Heading":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "Heading", "Double");
xamlMember.Getter = get_24_Map_Heading;
xamlMember.Setter = set_24_Map_Heading;
break;
case "Bing.Maps.Map.MetersPerPixel":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Map");
xamlMember = new XamlMember(this, "MetersPerPixel", "Double");
xamlMember.Getter = get_25_Map_MetersPerPixel;
xamlMember.SetIsReadOnly();
break;
case "Bing.Maps.Location.Latitude":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Location");
xamlMember = new XamlMember(this, "Latitude", "Double");
xamlMember.Getter = get_26_Location_Latitude;
xamlMember.Setter = set_26_Location_Latitude;
break;
case "Bing.Maps.Location.Longitude":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Location");
xamlMember = new XamlMember(this, "Longitude", "Double");
xamlMember.Getter = get_27_Location_Longitude;
xamlMember.Setter = set_27_Location_Longitude;
break;
case "Bing.Maps.Pushpin.Text":
userType = (XamlUserType)GetXamlTypeByName("Bing.Maps.Pushpin");
xamlMember = new XamlMember(this, "Text", "String");
xamlMember.Getter = get_28_Pushpin_Text;
xamlMember.Setter = set_28_Pushpin_Text;
break;
}
return xamlMember;
}
public void Read()
{
bool isQuotedMarkupExtension = false;
bool readString = false;
_tokenText = string.Empty;
_tokenXamlType = null;
_tokenProperty = null;
_tokenNamespace = null;
Advance();
AdvanceOverWhitespace();
if (IsAtEndOfInput)
{
_token = MeTokenType.None;
return;
}
switch (CurrentChar)
{
case OpenCurlie:
if (NextChar == CloseCurlie) // the {} escapes the ME. return the string.
{
_token = MeTokenType.String;
_state = StringState.Value;
readString = true; // ReadString() will strip the leading {}
}
else
{
_token = MeTokenType.Open;
_state = StringState.Type; // types follow '{'
}
break;
case Quote1:
case Quote2:
if (NextChar == OpenCurlie)
{
Advance(); // read ahead one character
if (NextChar != CloseCurlie) // check for the '}' of a {}
{
isQuotedMarkupExtension = true;
}
PushBack(); // put back the read-ahead.
}
readString = true; // read substring"
break;
case CloseCurlie:
_token = MeTokenType.Close;
_state = StringState.Value;
break;
case EqualSign:
_token = MeTokenType.EqualSign;
_state = StringState.Value;
_context.CurrentBracketModeParseParameters.IsConstructorParsingMode = false;
break;
case Comma:
_token = MeTokenType.Comma;
_state = StringState.Value;
if (_context.CurrentBracketModeParseParameters.IsConstructorParsingMode)
{
_context.CurrentBracketModeParseParameters.IsConstructorParsingMode =
++_context.CurrentBracketModeParseParameters.CurrentConstructorParam <
_context.CurrentBracketModeParseParameters.MaxConstructorParams;
}
break;
default:
readString = true;
break;
}
if (readString)
{
if (_context.CurrentType.IsMarkupExtension &&
_context.CurrentBracketModeParseParameters != null &&
_context.CurrentBracketModeParseParameters.IsConstructorParsingMode)
{
int currentCtrParam = _context.CurrentBracketModeParseParameters.CurrentConstructorParam;
_currentParameterName = _context.CurrentLongestConstructorOfMarkupExtension[currentCtrParam].Name;
_currentSpecialBracketCharacters = GetBracketCharacterForProperty(_currentParameterName);
}
string str = ReadString();
_token = (isQuotedMarkupExtension) ? MeTokenType.QuotedMarkupExtension : MeTokenType.String;
switch (_state)
{
case StringState.Value:
break;
case StringState.Type:
_token = MeTokenType.TypeName;
ResolveTypeName(str);
break;
case StringState.Property:
_token = MeTokenType.PropertyName;
ResolvePropertyName(str);
break;
}
_state = StringState.Value;
_tokenText = RemoveEscapes(str);
}
}
public XamlMemberInvoker (XamlMember member)
{
if (member == null)
throw new ArgumentNullException ("member");
this.member = member;
}
public XamlXmlWriterTest()
{
xt = new XamlType(typeof(string), sctx);
xt2 = new XamlType(typeof(List <int>), sctx);
xm = new XamlMember(str_len, sctx);
}
private IEnumerable<XamlInstruction> ParseNestedProperty(XamlMember member)
{
yield return Inject.StartOfMember(member);
SetNextInstruction();
foreach (var instruction in ParseInnerContentOfNestedProperty())
{
yield return instruction;
}
yield return Inject.EndOfMember();
}
public XamlMemberInvokerAdapter(XamlMember member) : base(member)
{
this.member = member;
}
public AvaloniaPropertyInvoker(XamlMember member) : base(member)
{
}
public DelayedValue(object target, XamlMember member, object value)
{
Target = target;
Member = member;
Value = value;
}
protected override void OnWriteStartMember (XamlMember property)
{
if (property == XamlLanguage.PositionalParameters ||
property == XamlLanguage.Arguments)
{
var state = object_states.Peek();
escaped_objects.Push(state.Value);
state.Value = new List<object>();
}
// FIXME: this condition needs to be examined. What is known to be prevented are: PositionalParameters, Initialization and Base (the last one sort of indicates there's a lot more).
else
{
var directive = property as XamlDirective;
if (directive == null || directive.Name == "Name") // x:Name requires an object instance
InitializeObjectIfRequired(false);
}
}
static Boolean IsDesignerAttachedProperty(XamlMember xamlMember)
{
return(xamlMember.IsAttachable &&
xamlMember.PreferredXamlNamespace.Equals(c_sapNamespaceURI, StringComparison.OrdinalIgnoreCase));
}
object GetCorrectlyTypedValue (XamlMember xm, XamlType xt, object value)
{
try {
return DoGetCorrectlyTypedValue (xm, xt, value);
} catch (XamlObjectWriterException) {
throw;
} catch (Exception ex) {
// For + ex.Message, the runtime should print InnerException message like .NET does.
throw new XamlObjectWriterException (String.Format ("Could not convert object \'{0}' (of type {1}) to {2}: ", value, value != null ? (object) value.GetType () : "(null)", xt) + ex.Message, ex);
}
}
public PerspexXamlMemberValuePlugin(XamlMember xamlMember, IPerspexPropertyBinder propertyBinder) : base(xamlMember)
{
_xamlMember = xamlMember;
_propertyBinder = propertyBinder;
}
IEnumerable<XamlXmlNodeInfo> ReadMember (XamlType parentType, XamlMember xm)
{
yield return Node (XamlNodeType.StartMember, xm);
if (xm.IsEvent) {
yield return Node (XamlNodeType.Value, r.Value);
r.Read ();
} else if (!xm.IsWritePublic) {
if (xm.Type.IsXData)
foreach (var ni in ReadXData ())
yield return ni;
else if (xm.Type.IsCollection) {
yield return Node (XamlNodeType.GetObject, xm.Type);
yield return Node (XamlNodeType.StartMember, XamlLanguage.Items);
foreach (var ni in ReadCollectionItems (parentType, XamlLanguage.Items))
yield return ni;
yield return Node (XamlNodeType.EndMember, XamlLanguage.Items);
yield return Node (XamlNodeType.EndObject, xm.Type);
}
else
throw new XamlParseException (String.Format ("Read-only member '{0}' showed up in the source XML, and the xml contains element content that cannot be read.", xm.Name)) { LineNumber = this.LineNumber, LinePosition = this.LinePosition };
} else {
if (xm.Type.IsCollection || xm.Type.IsDictionary) {
foreach (var ni in ReadCollectionItems (parentType, xm))
yield return ni;
}
else
foreach (var ni in ReadObjectElement (parentType, xm)) {
if (ni.NodeType == XamlNodeType.None)
throw new Exception ("should not happen");
yield return ni;
}
}
yield return Node (XamlNodeType.EndMember, xm);
}
private ResourceDictionary FindTheResourceDictionary(IServiceProvider serviceProvider, bool isDeferredContentSearch)
{
var schemaContextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (schemaContextProvider == null)
{
throw new InvalidOperationException(SR.Get(SRID.MarkupExtensionNoContext, GetType().Name, "IXamlSchemaContextProvider"));
}
var ambientProvider = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider == null)
{
throw new InvalidOperationException(SR.Get(SRID.MarkupExtensionNoContext, GetType().Name, "IAmbientProvider"));
}
XamlSchemaContext schemaContext = schemaContextProvider.SchemaContext;
// This seems like a lot of work to do on every Provide Value
// but that types and properties are cached in the schema.
//
XamlType feXType = schemaContext.GetXamlType(typeof(FrameworkElement));
XamlType styleXType = schemaContext.GetXamlType(typeof(Style));
XamlType templateXType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlType appXType = schemaContext.GetXamlType(typeof(Application));
XamlType fceXType = schemaContext.GetXamlType(typeof(FrameworkContentElement));
XamlMember fceResourcesProperty = fceXType.GetMember("Resources");
XamlMember feResourcesProperty = feXType.GetMember("Resources");
XamlMember styleResourcesProperty = styleXType.GetMember("Resources");
XamlMember styleBasedOnProperty = styleXType.GetMember("BasedOn");
XamlMember templateResourcesProperty = templateXType.GetMember("Resources");
XamlMember appResourcesProperty = appXType.GetMember("Resources");
XamlType[] types = new XamlType[1] {
schemaContext.GetXamlType(typeof(ResourceDictionary))
};
IEnumerable <AmbientPropertyValue> ambientValues = null;
ambientValues = ambientProvider.GetAllAmbientValues(null, // ceilingTypes
isDeferredContentSearch,
types,
fceResourcesProperty,
feResourcesProperty,
styleResourcesProperty,
styleBasedOnProperty,
templateResourcesProperty,
appResourcesProperty);
List <AmbientPropertyValue> ambientList;
ambientList = ambientValues as List <AmbientPropertyValue>;
Debug.Assert(ambientList != null, "IAmbientProvider.GetAllAmbientValues no longer returns List<>, please copy the list");
for (int i = 0; i < ambientList.Count; i++)
{
AmbientPropertyValue ambientValue = ambientList[i];
if (ambientValue.Value is ResourceDictionary)
{
var resourceDictionary = (ResourceDictionary)ambientValue.Value;
if (resourceDictionary.Contains(ResourceKey))
{
return(resourceDictionary);
}
}
if (ambientValue.Value is Style)
{
var style = (Style)ambientValue.Value;
var resourceDictionary = style.FindResourceDictionary(ResourceKey);
if (resourceDictionary != null)
{
return(resourceDictionary);
}
}
}
return(null);
}
public XamlMemberReference(XamlMember member, int lineNo, int lineOffset)
{
Member = member;
LineNumber = lineNo;
LineOffset = lineOffset;
}
// It expects that it is not invoked when there is no value to
// assign.
// When it is passed null, then it returns a default instance.
// For example, passing null as Int32 results in 0.
// But do not immediately try to instantiate with the type, since the type might be abstract.
object DoGetCorrectlyTypedValue(XamlMember xm, XamlType xt, object value)
{
if (value == null)
{
if (xt.IsContentValue(service_provider)) // it is for collection/dictionary key and item
{
return(null);
}
else
{
return(xt.IsNullable ? null : xt.Invoker.CreateInstance(new object [0]));
}
}
if (xt == null)
{
return(value);
}
// Not sure if this is really required though...
var vt = sctx.GetXamlType(value.GetType());
if (vt.CanAssignTo(xt))
{
return(value);
}
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof(XamlType) && value is string)
{
value = ResolveTypeFromName((string)value);
}
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof(Type))
{
value = new TypeExtension((string)value).ProvideValue(service_provider);
}
if (xt == XamlLanguage.Type && value is string)
{
value = new TypeExtension((string)value);
}
if (IsAllowedType(xt, value))
{
return(value);
}
var xtc = (xm != null ? xm.TypeConverter : null) ?? xt.TypeConverter;
if (xtc != null && value != null)
{
var tc = xtc.ConverterInstance;
if (tc != null && tc.CanConvertFrom(value.GetType()))
{
value = tc.ConvertFrom(value);
}
return(value);
}
throw new XamlObjectWriterException(String.Format("Value '{0}' (of type {1}) is not of or convertible to type {0} (member {3})", value, value != null ? (object)value.GetType() : "(null)", xt, xm));
}
private IXamlMember CreateXamlMember(string longMemberName)
{
XamlMember xamlMember = null;
XamlUserType userType;
switch (longMemberName)
{
case "_8Tracks.Common.RichTextColumns.RichTextContent":
userType = (XamlUserType)GetXamlTypeByName("_8Tracks.Common.RichTextColumns");
xamlMember = new XamlMember(this, "RichTextContent", "Windows.UI.Xaml.Controls.RichTextBlock");
xamlMember.SetIsDependencyProperty();
xamlMember.Getter = get_0_RichTextColumns_RichTextContent;
xamlMember.Setter = set_0_RichTextColumns_RichTextContent;
break;
case "_8Tracks.Common.RichTextColumns.ColumnTemplate":
userType = (XamlUserType)GetXamlTypeByName("_8Tracks.Common.RichTextColumns");
xamlMember = new XamlMember(this, "ColumnTemplate", "Windows.UI.Xaml.DataTemplate");
xamlMember.SetIsDependencyProperty();
xamlMember.Getter = get_1_RichTextColumns_ColumnTemplate;
xamlMember.Setter = set_1_RichTextColumns_ColumnTemplate;
break;
}
return xamlMember;
}
private IEnumerable <XamlNode> LogicStream_CheckForStartGetCollectionFromMember()
{
XamlType currentType = _context.CurrentType;
XamlMember currentProperty = _context.CurrentMember;
XamlType propertyType = currentProperty.Type;
XamlType valueElementType = (_xamlScanner.NodeType == ScannerNodeType.TEXT)
? XamlLanguage.String
: _xamlScanner.Type;
if (propertyType.IsArray && _xamlScanner.Type != ArrayExtensionType)
{
IEnumerable <NamespaceDeclaration> newNamespaces = null;
XamlTypeName typeName = new XamlTypeName(propertyType.ItemType);
INamespacePrefixLookup prefixResolver = new NamespacePrefixLookup(out newNamespaces, _context.FindNamespaceByPrefix);
string typeNameString = typeName.ToString(prefixResolver); // SideEffects!!! prefixResolver will populate newNamespaces
foreach (NamespaceDeclaration nsDecl in newNamespaces)
{
yield return(new XamlNode(XamlNodeType.NamespaceDeclaration, nsDecl));
}
yield return(Logic_StartObject(ArrayExtensionType, null));
_context.CurrentInImplicitArray = true;
yield return(Logic_StartMember(ArrayTypeMember));
yield return(new XamlNode(XamlNodeType.Value, typeNameString));
yield return(Logic_EndMember());
yield return(Logic_EndOfAttributes());
yield return(Logic_StartMember(ItemsTypeMember));
currentType = _context.CurrentType;
currentProperty = _context.CurrentMember;
propertyType = currentProperty.Type;
}
// Now Consider inserting special preamble to "Get" the collection:
// . GO
// . . SM _items
if (!currentProperty.IsDirective && (propertyType.IsCollection || propertyType.IsDictionary))
{
bool emitPreamble = false;
// If the collection property is Readonly then "Get" the collection.
if (currentProperty.IsReadOnly || !_context.CurrentMemberIsWriteVisible())
{
emitPreamble = true;
}
// If the collection is R/W and there is a type converter and we have Text
// use the type converter rather than the GO; SM _items;
else if (propertyType.TypeConverter != null && !currentProperty.IsReadOnly &&
_xamlScanner.NodeType == ScannerNodeType.TEXT)
{
emitPreamble = false;
}
// Or if the Value (this is the first value in the collection)
// isn't assignable to the Collection then "Get" the collection.
else if (valueElementType == null || !valueElementType.CanAssignTo(propertyType))
{
if (valueElementType != null)
{
// Unless: the Value is a Markup extension, in which case it is
// assumed that the ProvideValue() type will be AssignableFrom
// or If the next object has an x:Key in which case it must be
// a dictionary entry.
// so Don't "Get" the collection.
if (!valueElementType.IsMarkupExtension || _xamlScanner.HasKeyAttribute)
{
emitPreamble = true;
}
// Except: the Array Extension can never return a dictionary
// so for Array Extension do "Get" the collection.
// Note Array Extension would be suitable for List Collections
// Note: a fully validating parser should look at MarkupExtensionReturnType
// for this choice, there might be other MarkupExtensions that fit this.
else if (valueElementType == XamlLanguage.Array)
{
emitPreamble = true;
}
}
}
if (emitPreamble)
{
yield return(Logic_StartGetObjectFromMember(propertyType));
yield return(Logic_StartItemsProperty(propertyType));
}
}
}
public static XamlNode StartOfMember(XamlMember member)
{
return new XamlNode(XamlNodeType.StartMember, member);
}
/// <summary>
/// Returns true if whitespace is discardable at this phase in
/// the parsing. Here we discard whitespace between property elements
/// but keep it between object elements for collections that accept it.
/// Discarding trailing whitespace in collections cannot be decided here.
/// [see: Logic_ReadAhead_ApplyFinalTextTrimming
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
private bool Logic_IsDiscardableWhitespace(XamlText text)
{
if (!text.IsWhiteSpaceOnly)
{
return(false);
}
else
{
// Force unknown members to behave as whitespace significant collections in order to preserve as much information as possible.
if (_context.CurrentMember != null && _context.CurrentMember.IsUnknown)
{
return(false);
}
else if (_context.CurrentInContainerDirective)
{
XamlType collectionType = _context.CurrentMember == XamlLanguage.Items ? _context.CurrentType : _context.CurrentMember.Type;
if (collectionType.IsWhitespaceSignificantCollection)
{
return(false);
}
}
else
{
// Whitespace, by itself does not start content. Eg. The WS between
// the Start Element and the first Property Element is not content, but
// the WS between the Start Element and the first child Element (ie. other content)
// is content.
XamlMember prop = _context.CurrentMember;
if (_xamlScanner.PeekNodeType == ScannerNodeType.ELEMENT)
{
if (prop == null)
{
prop = _context.CurrentType.ContentProperty;
}
if (prop != null && prop.Type != null && prop.Type.IsWhitespaceSignificantCollection)
{
return(false);
}
if (prop == null && _context.CurrentType.IsWhitespaceSignificantCollection)
{
return(false);
}
}
// Whitespace can also start content if space is preserved and it's at the end of an element and...
else if (text.IsSpacePreserved && _xamlScanner.PeekNodeType == ScannerNodeType.ENDTAG)
{
// ...it's by itself in a PE with no other children
if (prop != null)
{
if (_context.CurrentPreviousChildType == null)
{
return(false);
}
}
// ...it's in an element with a string content property
else if (_context.CurrentType.ContentProperty != null)
{
prop = _context.CurrentType.ContentProperty;
// For backcompat we need to support CPs of type object here.
// Theoretically we'd also like to support all type-convertible CPs.
// However, for non-string CPs, 3.0 only surfaced whitespace as text if
// the CP hadn't already been set. For string, it surfaced it in all cases.
// So to avoid a breaking change, we only surface string right now.
if (prop.Type == XamlLanguage.String)
{
return(false);
}
if (prop.Type.IsWhitespaceSignificantCollection)
{
return(false);
}
}
// ...it's in a type-convertible element
else if (_context.CurrentType.TypeConverter != null && !_context.CurrentForcedToUseConstructor)
{
return(false);
}
}
}
}
return(true);
}
public static object GetValue(object parentInstance, XamlMember property)
{
return property.XamlMemberValueConnector.GetValue(parentInstance);
}
///////////////////////////
// ElementContent ::= ( PREFIXDEFINITION* Element ) | TEXT
//
public IEnumerable <XamlNode> P_ElementContent()
{
XamlType currentType = _context.CurrentType;
List <XamlNode> savedPrefixDefinitions = null;
ScannerNodeType nodeType = _xamlScanner.NodeType;
switch (nodeType)
{
case ScannerNodeType.PREFIXDEFINITION:
case ScannerNodeType.ELEMENT:
case ScannerNodeType.EMPTYELEMENT:
case ScannerNodeType.TEXT:
if (nodeType == ScannerNodeType.TEXT)
{
XamlText text = _xamlScanner.TextContent;
if (Logic_IsDiscardableWhitespace(text))
{
_xamlScanner.Read();
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
break;
}
}
// Don't immediately emit the prefix Definitions.
// buffer them for moment because if this is the first object
// in a collection, we may need to jam an implicit _Items property
// on Content Property in before the PrefixDef's and then the ObjectType.
while (nodeType == ScannerNodeType.PREFIXDEFINITION)
{
if (savedPrefixDefinitions == null)
{
savedPrefixDefinitions = new List <XamlNode>();
}
if (ProvideLineInfo)
{
savedPrefixDefinitions.Add(Logic_LineInfo());
}
savedPrefixDefinitions.Add(Logic_PrefixDefinition());
_xamlScanner.Read();
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
nodeType = _xamlScanner.NodeType;
}
// Check for any preambles we need to emit before the
// emitting the actual element or Text.
bool isTextInitialization = false;
if (!_context.CurrentInItemsProperty && !_context.CurrentInUnknownContent)
{
bool isContentProperty = false;
// In case of text, we look first for a string or object content property,
// then a TypeConverter
if (nodeType == ScannerNodeType.TEXT)
{
if (currentType.ContentProperty != null && CanAcceptString(currentType.ContentProperty))
{
isContentProperty = true;
}
// If there have been "real" properties then we are forced to use the
// Constructor. Otherwise we can consider a TypeConverter on the TEXT.
else if (!_context.CurrentForcedToUseConstructor &&
!_xamlScanner.TextContent.IsEmpty &&
currentType.TypeConverter != null)
{
isTextInitialization = true;
}
}
// Otherwise, we look first for a collection, and then fall back to content property
if (!isTextInitialization && !isContentProperty)
{
// If we are first in a collection
if (currentType.IsCollection || currentType.IsDictionary)
{
yield return(Logic_StartItemsProperty(currentType));
}
else // Back to ContentProperty (either element or unknown content)
{
isContentProperty = true;
}
}
// Don't yield more than one unknown content property for multiple,
// contiguous content objects and values.
if (isContentProperty && !_context.CurrentInUnknownContent)
{
XamlMember contentProperty = currentType.ContentProperty;
if (contentProperty != null)
{
bool isVisible = _context.IsVisible(
contentProperty, _context.CurrentTypeIsRoot ? _context.CurrentType : null);
// Visible content properties produce known members.
// Invisible content properties produce unknown members.
// Protected content properties of root instances and internal
// content properties can be visible, depending on the reader settings.
if (!isVisible)
{
// We use the current type, not the actual declaring type of the non-visible property,
// for consistency with how non-visible PEs and Attribute Properties are handled.
contentProperty = new XamlMember(contentProperty.Name, currentType, false);
}
}
// A null argument produces an unknown content member.
yield return(Logic_StartContentProperty(contentProperty));
// Check for and emit the get collection from member.
foreach (XamlNode node in LogicStream_CheckForStartGetCollectionFromMember())
{
yield return(node);
}
}
}
// Now we are ready for the given element.
// so now emit the saved prefix definitions.
if (savedPrefixDefinitions != null)
{
for (int i = 0; i < savedPrefixDefinitions.Count; i++)
{
yield return(savedPrefixDefinitions[i]);
}
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
}
if (nodeType == ScannerNodeType.TEXT)
{
XamlText text = _xamlScanner.TextContent;
string trimmed = Logic_ApplyFinalTextTrimming(text);
bool isXDataText = _xamlScanner.IsXDataText;
_xamlScanner.Read();
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
if (string.IsNullOrEmpty(trimmed))
{
break;
}
if (isTextInitialization)
{
yield return(Logic_StartInitProperty(currentType));
}
if (isXDataText)
{
yield return(Logic_StartObject(XamlLanguage.XData, null));
XamlMember xDataTextProperty = XamlLanguage.XData.GetMember("Text");
yield return(Logic_EndOfAttributes());
yield return(Logic_StartMember(xDataTextProperty));
}
yield return(new XamlNode(XamlNodeType.Value, trimmed));
if (isXDataText)
{
yield return(Logic_EndMember());
yield return(Logic_EndObject());
}
}
else
{
foreach (XamlNode node in P_Element())
{
yield return(node);
}
}
// If we are not in an items or unknown content property, then
// there cannot be more objects or values that follow this content
// (a singular property), and thus we can end this property now.
if (!_context.CurrentInItemsProperty && !_context.CurrentInUnknownContent)
{
yield return(Logic_EndMember());
}
break;
} // end switch
}
bool ParseArgument ()
{
ReadWhitespace();
var escapedValue = ParseEscapedValue ();
if (escapedValue != null)
{
AddPositionalParameter(escapedValue);
ParseArgument();
return true;
}
var name = ReadUntil(new [] { '=', ' ', ',' }, readToEnd: true, skip: false, escape: '\\');
if (string.IsNullOrEmpty(name))
return false;
if (!ReadWhitespaceUntil('='))
{
AddPositionalParameter(name + ReadUntil(',', true, escape: '\\').TrimEnd());
ParseArgument();
return true;
}
member = Type.GetMember (name) ?? new XamlMember(name, Type, false);
ReadWhitespace ();
ParseValue ();
return true;
}
public XamlSetValueEventArgs(XamlMember member, object value)
{
Value = value;
Member = member;
}
public override void WriteStartMember (XamlMember xamlMember)
{
source.Add (new XamlNodeInfo (XamlNodeType.StartMember, new XamlNodeMember (default (XamlObject), xamlMember)));
}
private IEnumerable<XamlNode> ParseElements(XamlMember hostingProperty = null)
{
SkipTextNodes();
if (hostingProperty != null)
{
yield return Inject.StartOfMember(hostingProperty);
}
while (CurrentNodeIsElement && !EndOfStream)
{
switch (nodeStream.Current.NodeType)
{
case NodeType.Element:
foreach (var xamlNode in ParseNonEmptyElement()) yield return xamlNode;
break;
case NodeType.EmptyElement:
foreach (var xamlNode in ParseEmptyElement()) yield return xamlNode;
break;
}
// There may be text nodes after each element. Skip all of them.
SkipTextNodes();
}
if (hostingProperty != null)
{
yield return Inject.EndOfMember();
}
}
///////////////////////////
// PropertyContent ::= ( PREFIXDEFINITION* Element ) | TEXT
//
public IEnumerable <XamlNode> P_PropertyContent()
{
ScannerNodeType nodeType = _xamlScanner.NodeType;
List <XamlNode> _savedPrefixDefinitions = null;
string trimmed = string.Empty;
bool isTextXML = false;
switch (nodeType)
{
case ScannerNodeType.PREFIXDEFINITION:
case ScannerNodeType.ELEMENT:
case ScannerNodeType.EMPTYELEMENT:
case ScannerNodeType.TEXT:
if (nodeType == ScannerNodeType.TEXT)
{
XamlText text = _xamlScanner.TextContent;
if (Logic_IsDiscardableWhitespace(text))
{
trimmed = string.Empty;
}
else
{
trimmed = Logic_ApplyFinalTextTrimming(text);
}
isTextXML = _xamlScanner.IsXDataText;
_xamlScanner.Read();
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
if (string.IsNullOrEmpty(trimmed))
{
break;
}
}
// Don't immediately emit the prefix Definitions.
// buffer them for moment because if this is the first object
// in a collection, we may need to jam an implicit _Items property
// in before the PrefixDef's and then the ObjectType.
while (nodeType == ScannerNodeType.PREFIXDEFINITION)
{
if (_savedPrefixDefinitions == null)
{
_savedPrefixDefinitions = new List <XamlNode>();
}
_savedPrefixDefinitions.Add(Logic_PrefixDefinition());
if (ProvideLineInfo)
{
_savedPrefixDefinitions.Add(Logic_LineInfo());
}
_xamlScanner.Read();
if (ProvideLineInfo)
{
yield return(Logic_LineInfo());
}
nodeType = _xamlScanner.NodeType;
}
// If this is TEXT and the current Property has a TypeConverter
// Then emit the TEXT now.
if (nodeType == ScannerNodeType.TEXT &&
_context.CurrentMember.TypeConverter != null)
{
yield return(new XamlNode(XamlNodeType.Value, trimmed));
}
else
{
// Check for any preambles we need to emit before the
// emitting the actual element or Text.
if (!_context.CurrentInCollectionFromMember)
{
// Check for and emit the get collection from member.
foreach (XamlNode node in LogicStream_CheckForStartGetCollectionFromMember())
{
yield return(node);
}
}
// We couldn't emit text in the code above (directly under the property).
// We have now (possibly) started a get collection from member. This TEXT might go
// under the _items.
// This might be <XDATA>.
// It might still be an error, ie. Unknown Content.
// This is the last chance to emit the TEXT.
if (nodeType == ScannerNodeType.TEXT)
{
if (isTextXML)
{
yield return(Logic_StartObject(XamlLanguage.XData, null));
XamlMember xDataTextProperty = XamlLanguage.XData.GetMember("Text");
yield return(Logic_EndOfAttributes());
yield return(Logic_StartMember(xDataTextProperty));
}
yield return(new XamlNode(XamlNodeType.Value, trimmed));
if (isTextXML)
{
yield return(Logic_EndMember());
yield return(Logic_EndObject());
}
}
else
{
// Now we are ready for the given element.
// now emit the saved prefix definitions.
if (_savedPrefixDefinitions != null)
{
for (int i = 0; i < _savedPrefixDefinitions.Count; i++)
{
yield return(_savedPrefixDefinitions[i]);
}
}
foreach (XamlNode node in P_Element())
{
yield return(node);
}
}
}
break;
}
}
public PropertyInvoker(XamlMember member) : base(member)
{
}
private IXamlMember CreateXamlMember(string longMemberName)
{
XamlMember xamlMember = null;
XamlUserType userType;
switch (longMemberName)
{
case "metroflip.Flip.TextPrev":
userType = (XamlUserType)GetXamlTypeByName("metroflip.Flip");
xamlMember = new XamlMember(this, "TextPrev", "String");
xamlMember.SetIsDependencyProperty();
xamlMember.Getter = get_0_Flip_TextPrev;
xamlMember.Setter = set_0_Flip_TextPrev;
break;
case "metroflip.Flip.TextNext":
userType = (XamlUserType)GetXamlTypeByName("metroflip.Flip");
xamlMember = new XamlMember(this, "TextNext", "String");
xamlMember.SetIsDependencyProperty();
xamlMember.Getter = get_1_Flip_TextNext;
xamlMember.Setter = set_1_Flip_TextNext;
break;
}
return xamlMember;
}
//static readonly BindingFlags static_flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
protected override void OnWriteEndMember()
{
var xm = CurrentMember;
var state = object_states.Peek();
if (ReferenceEquals(xm, XamlLanguage.PositionalParameters))
{
var l = (List <object>)state.Value;
state.Value = escaped_objects.Pop();
state.IsInstantiated = true;
PopulateObject(true, l);
return;
}
else if (ReferenceEquals(xm, XamlLanguage.Arguments))
{
if (state.FactoryMethod != null)
{
var contents = (List <object>)state.Value;
bool found = false;
foreach (var mi in state.Type.UnderlyingType.GetRuntimeMethods())
{
if (mi.Name == state.FactoryMethod && mi.IsStatic && mi.GetParameters().Length == contents.Count)
{
state.Value = mi.Invoke(null, contents.ToArray());
found = true;
break;
}
}
if (!found)
{
throw new XamlObjectWriterException(String.Format("Specified static factory method '{0}' for type '{1}' was not found", state.FactoryMethod, state.Type));
}
}
else
{
PopulateObject(true, (List <object>)state.Value);
}
state.IsInstantiated = true;
escaped_objects.Pop();
}
else if (ReferenceEquals(xm, XamlLanguage.Initialization))
{
// ... and no need to do anything. The object value to pop *is* the return value.
}
else
{
XamlMember aliasedName = state.Type.GetAliasedProperty(XamlLanguage.Name);
if (ReferenceEquals(xm, XamlLanguage.Name) || xm == aliasedName)
{
string name = (string)CurrentMemberState.Value;
name_scope.RegisterName(name, state.Value);
// if x:Name is used, then we set the backing property defined by RuntimeNamePropertyAttribute
xm = aliasedName ?? xm;
}
if (!xm.IsReadOnly) // exclude read-only object such as collection item.
{
SetValue(xm, CurrentMemberState.Value);
}
}
}
private IEnumerable<XamlNode> ParseNestedProperty(XamlMember member)
{
yield return Inject.StartOfMember(member);
SetNextNode();
foreach (var xamlNode in ParseInnerContentOfNestedProperty()) yield return xamlNode;
yield return Inject.EndOfMember();
}
// It expects that it is not invoked when there is no value to
// assign.
// When it is passed null, then it returns a default instance.
// For example, passing null as Int32 results in 0.
// But do not immediately try to instantiate with the type, since the type might be abstract.
object GetCorrectlyTypedValue(XamlMember xm, XamlType xt, object value)
{
try
{
if (value == null)
{
if (xt.IsContentValue(service_provider)) // it is for collection/dictionary key and item
{
return(null);
}
else
{
return(xt.IsNullable ? null : xt.Invoker.CreateInstance(new object[0]));
}
}
if (ReferenceEquals(xt, null))
{
return(value);
}
// Not sure if this is really required though...
var vt = sctx.GetXamlType(value.GetType());
if (vt.CanAssignTo(xt))
{
return(value);
}
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof(XamlType) && value is string)
{
value = ResolveTypeFromName((string)value);
}
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof(Type))
{
value = new TypeExtension((string)value).ProvideValue(service_provider);
}
if (ReferenceEquals(xt, XamlLanguage.Type) && value is string)
{
value = new TypeExtension((string)value);
}
if (IsAllowedType(xt, value))
{
return(value);
}
var xtc = xm?.TypeConverter ?? xt.TypeConverter;
if (xtc != null && value != null)
{
var tc = xtc.ConverterInstance;
if (tc != null && tc.CanConvertFrom(service_provider, value.GetType()))
{
value = tc.ConvertFrom(service_provider, CultureInfo.InvariantCulture, value);
}
return(value);
}
}
catch (Exception ex)
{
// For + ex.Message, the runtime should print InnerException message like .NET does.
throw new XamlObjectWriterException(String.Format("Could not convert object \'{0}' (of type {1}) to {2}: ", value, value != null ? (object)value.GetType() : "(null)", xt) + ex.Message, ex);
}
throw new XamlObjectWriterException(String.Format("Value '{0}' (of type {1}) is not of or convertible to type {2} (member {3})", value, value != null ? (object)value.GetType() : "(null)", xt, xm));
}
public override void WriteStartMember (XamlMember property)
{
intl.WriteStartMember (property);
}
private XAML3.INameScopeDictionary HuntAroundForARootNameScope(ObjectWriterFrame rootFrame)
{
Debug.Assert(rootFrame.Depth == 1);
object inst = rootFrame.Instance;
if (inst == null && rootFrame.XamlType.IsNameScope)
{
throw new InvalidOperationException(SR.Get(SRID.NameScopeOnRootInstance));
}
XAML3.INameScopeDictionary nameScopeDictionary = null;
nameScopeDictionary = inst as XAML3.INameScopeDictionary;
if (nameScopeDictionary == null)
{
XAML3.INameScope nameScope = inst as XAML3.INameScope;
if (nameScope != null)
{
nameScopeDictionary = new NameScopeDictionary(nameScope);
}
}
// If the root instance isn't a name scope
// then perhaps it designated a property as the name scope.
if (nameScopeDictionary == null)
{
XamlType xamlType = rootFrame.XamlType;
if (xamlType.UnderlyingType != null)
{
// Get the Name Scope Property (from attribute on the class)
XamlMember nameScopeProperty = TypeReflector.LookupNameScopeProperty(xamlType);
if (nameScopeProperty != null)
{
// Read the value of the property. If it is an object we are good.
// if it is null create a stock name scope dictionary object and assign it back.
XAML3.INameScope nameScope = (XAML3.INameScope)_runtime.GetValue(inst, nameScopeProperty, false);
if (nameScope == null)
{
#if TARGETTING35SP1
nameScopeDictionary = new NameScopeDictionary(new NameScope());
#else
nameScopeDictionary = new NameScope();
#endif
_runtime.SetValue(inst, nameScopeProperty, nameScopeDictionary);
}
else
{
nameScopeDictionary = nameScope as XAML3.INameScopeDictionary;
if (nameScopeDictionary == null)
{
nameScopeDictionary = new NameScopeDictionary(nameScope);
}
}
}
}
}
if (nameScopeDictionary == null && _settings != null &&
_settings.RegisterNamesOnExternalNamescope)
{
ObjectWriterFrame frameZero = (ObjectWriterFrame)rootFrame.Previous;
nameScopeDictionary = frameZero.NameScopeDictionary;
}
// Otherwise we still need a namescope at the root of the parse
// for our own usage. For IXamlNameResolver() to use.
if (nameScopeDictionary == null)
{
#if TARGETTING35SP1
nameScopeDictionary = new NameScopeDictionary(new NameScope());
#else
nameScopeDictionary = new NameScope();
#endif
}
rootFrame.NameScopeDictionary = nameScopeDictionary;
return(nameScopeDictionary);
}
void SetValue (XamlMember member, object value)
{
if (member == XamlLanguage.FactoryMethod)
object_states.Peek ().FactoryMethod = (string) value;
else if (member.IsDirective)
return;
else
SetValue (member, object_states.Peek ().Value, value);
}
public override void WriteStartMember(XamlMember property)
{
intl.WriteStartMember(property);
}
bool AddToCollectionIfAppropriate (XamlType xt, XamlMember xm, object parent, object obj, object keyObj)
{
var mt = xm.Type;
if (xm == XamlLanguage.Items ||
xm == XamlLanguage.PositionalParameters ||
xm == XamlLanguage.Arguments) {
if (xt.IsDictionary)
mt.Invoker.AddToDictionary (parent, GetCorrectlyTypedValue (null, xt.KeyType, keyObj), GetCorrectlyTypedValue (null, xt.ItemType, obj));
else // collection. Note that state.Type isn't usable for PositionalParameters to identify collection kind.
mt.Invoker.AddToCollection (parent, GetCorrectlyTypedValue (null, xt.ItemType, obj));
return true;
}
else
return false;
}
protected override void OnWriteStartMember(XamlMember member)
{
if (ReferenceEquals(member, XamlLanguage.Initialization))
{
return;
}
if (ReferenceEquals(member, XamlLanguage.Items))
{
return;
}
if (member == member.TargetType?.ContentProperty)
{
return;
}
WritePendingValue(XamlNodeType.Value);
var state = object_states.Peek();
// Top-level positional parameters are somehow special.
// - If it has only one parameter, it is written as an
// attribute using the actual argument's member name.
// - If there are more than one, then it is an error at
// the second constructor argument.
// (Here "top-level" means an object that involves
// StartObject i.e. the root or a collection item.)
var posprms = ReferenceEquals(member, XamlLanguage.PositionalParameters) && IsAtTopLevelObject() && object_states.Peek().Type.HasPositionalParameters(service_provider) ? state.Type.GetSortedConstructorArguments().GetEnumerator() : null;
if (posprms != null)
{
posprms.MoveNext();
var arg = posprms.Current;
w.WriteStartAttribute(arg.GetInternalXmlName());
inside_toplevel_positional_parameter = true;
}
else if (w.WriteState == WriteState.Attribute)
{
inside_attribute_object = true;
}
if (w.WriteState == WriteState.Attribute)
{
if (state.PositionalParameterIndex < 0)
{
w.WriteString(" ");
w.WriteString(member.Name);
w.WriteString("=");
}
}
else if (ReferenceEquals(member, XamlLanguage.PositionalParameters) && posprms == null && state.Type.GetSortedConstructorArguments().All(m => m == state.Type.ContentProperty)) // PositionalParameters and ContentProperty, excluding such cases that it is already processed above (as attribute).
{
OnWriteStartMemberContent(state.Type, member);
}
else
{
switch (IsAttribute(state.Type, member))
{
case AllowedMemberLocations.Attribute:
OnWriteStartMemberAttribute(state.Type, member);
break;
case AllowedMemberLocations.MemberElement:
OnWriteStartMemberElement(state.Type, member);
break;
default: // otherwise - pending output
CurrentMemberState.OccuredAs = AllowedMemberLocations.Any; // differentiate from .None
break;
}
}
}
// It expects that it is not invoked when there is no value to
// assign.
// When it is passed null, then it returns a default instance.
// For example, passing null as Int32 results in 0.
// But do not immediately try to instantiate with the type, since the type might be abstract.
object DoGetCorrectlyTypedValue (XamlMember xm, XamlType xt, object value)
{
if (value == null) {
if (xt.IsContentValue (service_provider)) // it is for collection/dictionary key and item
return null;
else
return xt.IsNullable ? null : xt.Invoker.CreateInstance (new object [0]);
}
if (xt == null)
return value;
// Not sure if this is really required though...
var vt = sctx.GetXamlType (value.GetType ());
if (vt.CanAssignTo (xt))
return value;
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof (XamlType) && value is string)
value = ResolveTypeFromName ((string) value);
// FIXME: this could be generalized by some means, but I cannot find any.
if (xt.UnderlyingType == typeof (Type))
value = new TypeExtension ((string) value).ProvideValue (service_provider);
if (xt == XamlLanguage.Type && value is string)
value = new TypeExtension ((string) value);
if (IsAllowedType (xt, value))
return value;
var xtc = xm?.TypeConverter ?? xt.TypeConverter;
if (xtc != null && value != null) {
var tc = xtc.ConverterInstance;
if (tc != null && tc.CanConvertFrom (value.GetType ()))
value = tc.ConvertFrom (service_provider, null, value);
return value;
}
throw new XamlObjectWriterException (String.Format ("Value '{0}' (of type {1}) is not of or convertible to type {0} (member {3})", value, value != null ? (object) value.GetType () : "(null)", xt, xm));
}
void OnWriteStartMemberContent(XamlType xt, XamlMember member)
{
// FIXME: well, it is sorta nasty, would be better to define different enum.
CurrentMemberState.OccuredAs = (AllowedMemberLocations)0xFF;
}
// member element, implicit member, children via content property, or value
IEnumerable<XamlXmlNodeInfo> ReadMemberElement (XamlType parentType, XamlType xt)
{
XamlMember xm = null;
var name = r.LocalName;
int idx = name.IndexOf ('.');
// FIXME: it skips strict type name check, as it could result in MarkupExtension mismatch (could be still checked, though)
if (idx >= 0/* && name.Substring (0, idx) == xt.Name*/) {
name = name.Substring (idx + 1);
xm = xt.GetMember (name);
} else {
xm = (XamlMember) FindStandardDirective (name, AllowedMemberLocations.MemberElement) ??
// not a standard directive? then try attachable
xt.GetAttachableMember (name) ??
// still not? then try ordinal member
xt.GetMember (name);
if (xm == null) {
// still not? could it be omitted as content property or items ?
if ((xm = GetExtraMember (xt)) != null) {
// Note that this does not involve r.Read()
foreach (var ni in ReadMember (xt, xm))
yield return ni;
yield break;
}
}
}
if (xm == null) {
// Current element could be for another member in the parent type (if exists)
if (parentType != null && parentType.GetMember (name) != null) {
// stop the iteration and signal the caller to not read current element as an object. (It resolves conflicts between "start object for current collection's item" and "start member for the next member in the parent object".
yield return Node (XamlNodeType.None, null);
yield break;
}
// ok, then create unknown member.
xm = new XamlMember (name, xt, false); // FIXME: not sure if isAttachable is always false.
}
if (!r.IsEmptyElement) {
r.Read ();
foreach (var ni in ReadMember (xt, xm))
yield return ni;
r.MoveToContent ();
r.ReadEndElement ();
}
else
r.Read ();
}
void WritePendingValue(XamlNodeType nodeType)
{
if (!hasPendingValue)
{
return;
}
XamlMember xm = CurrentMember;
WritePendingStartMember(nodeType);
var isAttribute = w.WriteState == WriteState.Attribute;
if (!isAttribute)
{
WritePendingNamespaces();
}
var s = GetValueString(xm, pendingValue);
// It looks like a bad practice, but since .NET disables
// indent around XData, I assume they do this, instead
// of examining valid Text value by creating XmlReader
// and call XmlWriter.WriteNode().
if (ReferenceEquals(xm.DeclaringType, XamlLanguage.XData) && xm == XamlLanguage.XData.GetMember("Text"))
{
w.WriteRaw(s);
hasPendingValue = false;
pendingValue = null;
return;
}
var state = object_states.Peek();
switch (state.PositionalParameterIndex)
{
case -1:
break;
case 0:
state.PositionalParameterIndex++;
break;
default:
if (inside_toplevel_positional_parameter)
{
throw new XamlXmlWriterException(String.Format("The XAML reader input has more than one positional parameter values within a top-level object {0} because it tries to write all of the argument values as an attribute value of the first argument. While XamlObjectReader can read such an object, XamlXmlWriter cannot write such an object to XML.", state.Type));
}
state.PositionalParameterIndex++;
w.WriteString(", ");
break;
}
// when writing a markup extension value, we use quotes for an empty string.
if (CurrentState.Type.IsMarkupExtension && isAttribute && s.Length == 0)
{
s = "\"\"";
}
else if (isAttribute && s.Length > 0 && s[0] == '{')
{
w.WriteString("{}"); // escape value that starts with a curly brace
}
w.WriteString(s);
hasPendingValue = false;
pendingValue = null;
}
IEnumerable<XamlXmlNodeInfo> ReadCollectionItems (XamlType parentType, XamlMember xm)
{
for (r.MoveToContent (); r.NodeType != XmlNodeType.EndElement; r.MoveToContent ()) {
foreach (var ni in ReadObjectElement (parentType, xm)) {
if (ni.NodeType == XamlNodeType.None)
yield break;
yield return ni;
}
}
}
public XamlMemberNode(XamlMember member)
{
this.Member = member;
}
