internal static object GetRootTemplatedActivity(IServiceProvider serviceProvider)
{
IRootObjectProvider service = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (service == null)
{
return(null);
}
IAmbientProvider provider2 = serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (provider2 == null)
{
return(null);
}
IXamlSchemaContextProvider provider3 = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (provider3 == null)
{
return(null);
}
XamlMember member = GetXamlMember(provider3.SchemaContext, typeof(Activity), "Implementation");
XamlMember member2 = GetXamlMember(provider3.SchemaContext, typeof(DynamicActivity), "Implementation");
if ((member == null) || (member2 == null))
{
return(null);
}
if (provider2.GetFirstAmbientValue(null, new XamlMember[] { member, member2 }) == null)
{
return(null);
}
return(service.RootObject as Activity);
}
public object ProvideValue(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IRootObjectProvider rootObjectProvider = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootObjectProvider == null)
{
throw new ArgumentException("serviceProvider does not provide an IRootObjectProvider");
}
if (string.IsNullOrEmpty(this.Name))
{
throw new ArgumentNullException("Name");
}
Element nameScope = rootObjectProvider.RootObject as Element;
Element element = nameScope.FindByName <Element>(this.Name);
if (element == null)
{
throw new ArgumentNullException(string.Format("Can't find element named '{0}'", this.Name));
}
object context = element.BindingContext;
this.rootElement = element;
IProvideValueTarget ipvt = (IProvideValueTarget)serviceProvider.GetService(typeof(IProvideValueTarget));
this.attachedObject = ipvt.TargetObject as BindableObject;
this.attachedObject.BindingContextChanged += this.OnContextChanged;
return(context ?? new object());
}
internal static void GetRootObjectAndDelegateType(ITypeDescriptorContext context, out object rootObject, out Type delegateType)
{
rootObject = null;
delegateType = null;
if (context == null)
{
return;
}
IRootObjectProvider rootObjectService = context.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootObjectService == null)
{
return;
}
rootObject = rootObjectService.RootObject;
IDestinationTypeProvider targetService = context.GetService(typeof(IDestinationTypeProvider)) as IDestinationTypeProvider;
if (targetService == null)
{
return;
}
delegateType = targetService.GetDestinationType();
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IRootObjectProvider rootObjectProvider = (IRootObjectProvider)serviceProvider.GetService(typeof(IRootObjectProvider));
IDictionary dictionary = rootObjectProvider?.RootObject as IDictionary;
return(dictionary?[ResourceKey]);
}
/// <summary>
/// Gets the source type for the root object from markup or from an object graph.
/// </summary>
/// <param name="serviceProvider">The object that can provide services for the markup extension.</param>
/// <returns>The source type for the root object.</returns>
private static Type GetRootType(IServiceProvider serviceProvider)
{
IRootObjectProvider provider = serviceProvider.GetService <IRootObjectProvider>();
if (provider != null)
{
object root = provider.RootObject;
if (root != null)
{
if (Designer.DesignMode)
{
if (root is DependencyObject element)
{
return(Designer.GetDesignType(element));
}
return(null);
}
return(root.GetType());
}
}
return(null);
}
public object ProvideValue(IServiceProvider serviceProvider)
{
if (String.IsNullOrEmpty(Source))
{
System.Diagnostics.Debug.WriteLine("ImageResourceExtension::ProvideValue - No value supplied for Source.");
return(null);
}
System.Diagnostics.Debug.WriteLine("ImageResourceExtension::ProvideValue - Attempting to load resource '{0}'...", Source);
ImageSource imageSource = null;
var match = _resourceSplitter.Match(Source);
if (match.Success)
{
var resourceName = match.Groups["resourceName"].Value;
var assemblyName = match.Groups["assemblyName"].Value;
Assembly assembly = null;
if (!String.IsNullOrEmpty(assemblyName))
{
assembly = System.Reflection.Assembly.Load(new AssemblyName(assemblyName));
}
else
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IRootObjectProvider rootObjectProvider = serviceProvider.GetService <IRootObjectProvider>();
if (rootObjectProvider == null)
{
throw new ArgumentException("serviceProvider did not provide an IRootObjectProvider");
}
// Find the root visual element (our view)
var visualElement = rootObjectProvider.RootObject as VisualElement;
var visualElementType = visualElement.GetType();
assembly = visualElementType.GetTypeInfo().Assembly;
}
#if DEBUG
if (assembly != null && !assembly.GetManifestResourceNames().Contains(resourceName))
{
System.Diagnostics.Debug.WriteLine("ImageResourceExtension::ProvideValue - No resource found for stream name '{0}'.", Source);
}
else
{
System.Diagnostics.Debug.WriteLine("ImageResourceExtension::ProvideValue - Found resource '{0}'.", Source);
}
#endif
// Do your translation lookup here, using whatever method you require
imageSource = ImageSource.FromStream(() => assembly.GetManifestResourceStream(resourceName));
}
else
{
System.Diagnostics.Debug.WriteLine("ImageResourceExtension::ProvideValue - Unable to parse source string '{0}'.", Source);
}
return(imageSource);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (string.IsNullOrEmpty(Message))
{
throw new InvalidOperationException("Required property Message is invalid.");
}
if (serviceProvider == null)
{
return(Message);
}
var target = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
FrameworkElement targetControl = null;
if (target != null)
{
targetControl = target.TargetObject as FrameworkElement;
}
if (targetControl == null)
{
return(Message);
}
if (System.ComponentModel.DesignerProperties.GetIsInDesignMode(targetControl))
{
return(Message);
}
string qualifiedName = null;
IRootObjectProvider rootProvider = null;
if (serviceProvider != null)
{
rootProvider = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
}
string rootName = null;
if (rootProvider != null)
{
var rootObject = rootProvider.RootObject;
if (rootObject != null)
{
rootName = rootObject.GetType().ToString();
}
}
if (!string.IsNullOrEmpty(rootName))
{
var controlName = targetControl.Name;
if (!string.IsNullOrEmpty(controlName))
{
qualifiedName = string.Format("{0}:{1}", rootName, controlName);
}
}
string value = (qualifiedName == null) ? Message : $"[{qualifiedName}] {Message}";
return(value);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IRootObjectProvider provider = (IRootObjectProvider)serviceProvider.GetService(typeof(IRootObjectProvider));
return((provider?.RootObject) switch
{
FrameworkElement element => element.TryFindResource(Resource),
IDictionary dictionary => dictionary[Resource],
_ => null,
});
void Initialize(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, Func <IAmbientProvider> ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider, IXamlObjectWriterFactory objectWriterFactory)
{
prefix_lookup = prefixLookup ?? throw new ArgumentNullException("prefixLookup");
sctx = schemaContext ?? throw new ArgumentNullException("schemaContext");
_ambientProviderProvider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
this.objectWriterFactory = objectWriterFactory;
}
private void Initialize(IProvideValueTarget valueTargetProvider, IRootObjectProvider rootObjectProvider)
{
// if XamlCompilation is active, IRootObjectProvider is not available, but SimpleValueTargetProvider is available
// if XamlCompilation is inactive, IRootObjectProvider is available, but SimpleValueTargetProvider is not available
object rootObject;
var propertyInfo = valueTargetProvider.GetType().GetTypeInfo().DeclaredProperties.FirstOrDefault(dp => dp.Name.Contains("ParentObjects"));
if (propertyInfo == null)
{
throw new ArgumentNullException("ParentObjects");
}
var parentObjects = (propertyInfo.GetValue(valueTargetProvider) as IEnumerable <object>).ToList();
BindableTree = parentObjects.Cast <BindableObject>();
if (rootObjectProvider == null && valueTargetProvider == null)
{
throw new ArgumentException("serviceProvider does not provide an IRootObjectProvider or SimpleValueTargetProvider");
}
if (rootObjectProvider == null)
{
var parentObject = parentObjects.FirstOrDefault(pO => pO.GetType().GetTypeInfo().IsSubclassOf(typeof(Page)));
BindableObjectRaw = parentObjects.FirstOrDefault();
Bindable = BindableObjectRaw as BindableObject;
rootObject = parentObject;
}
else
{
rootObject = rootObjectProvider.RootObject;
BindableObjectRaw = valueTargetProvider.TargetObject;
Bindable = BindableObjectRaw as BindableObject;
}
BindablePropertyRaw = valueTargetProvider.TargetProperty;
if (BindablePropertyRaw is BindableProperty bp)
{
BindableProp = bp;
PropertyName = bp.PropertyName;
}
else if (BindablePropertyRaw is PropertyInfo pi)
{
PropertyName = pi.Name;
}
else if (BindablePropertyRaw != null)
{
PropertyName = BindablePropertyRaw.ToString();
}
if (rootObject is Page providedPage)
{
SourcePage = SourcePage ?? providedPage;
}
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IRootObjectProvider rootObjectProvider = (IRootObjectProvider)serviceProvider.GetService(typeof(IRootObjectProvider));
object obj = ((Service)rootObjectProvider.RootObject).Resources[this.Name];
if (obj is Activity)
{
return(((Activity)obj).Clone());
}
throw new InvalidOperationException("ActivityReference can't reference to a value which is not an Activity");
}
/// <summary>
/// Returns an object that is provided as the value of the target property for this markup extension.
/// </summary>
/// <param name="serviceProvider">A service provider helper that can provide services for the markup extension.</param>
/// <returns>The object value to set on the property where the extension is applied.</returns>
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (serviceProvider != null)
{
IRootObjectProvider provider = serviceProvider.GetService <IRootObjectProvider>();
return(provider?.RootObject);
}
return(this);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IRootObjectProvider provider = serviceProvider.GetService
(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (provider != null)
{
return(provider.RootObject);
}
return(null);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value != null)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
XamlSchemaContext xamlSchemaContext =
RequireService <IXamlSchemaContextProvider>(context).SchemaContext;
Baml2006SchemaContext schemaContext = xamlSchemaContext as Baml2006SchemaContext;
if (schemaContext == null)
{
throw new InvalidOperationException(SR.Get(SRID.ExpectedBamlSchemaContext));
}
IXamlObjectWriterFactory objectWriterFactory =
RequireService <IXamlObjectWriterFactory>(context);
IProvideValueTarget ipvt =
RequireService <IProvideValueTarget>(context);
IRootObjectProvider rootObjectProvider =
RequireService <IRootObjectProvider>(context);
ResourceDictionary dictionary = ipvt.TargetObject as ResourceDictionary;
if (dictionary == null)
{
throw new InvalidOperationException(SR.Get(SRID.ExpectedResourceDictionaryTarget));
}
Stream stream = value as Stream;
if (stream == null)
{
byte[] bytes = value as byte[];
if (bytes != null)
{
stream = new MemoryStream(bytes);
}
}
if (stream == null)
{
throw new InvalidOperationException(SR.Get(SRID.ExpectedBinaryContent));
}
//
DeferrableContent deferrableContext = new DeferrableContent(stream, schemaContext,
objectWriterFactory, context, rootObjectProvider.RootObject);
return(deferrableContext);
}
return(base.ConvertFrom(context, culture, value));
}
protected TypeInfo GetRootObjectType(IServiceProvider serviceProvider)
{
// Little workaround to get page object https://forums.xamarin.com/discussion/33678/x-reference-not-working
IRootObjectProvider rootObjectProvider = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
SimpleValueTargetProvider valueTargetProvider =
serviceProvider.GetService(typeof(IProvideValueTarget)) as SimpleValueTargetProvider;
// If XamlCompilation is active, IRootObjectProvider is not available, but SimpleValueTargetProvider is available
// If XamlCompilation is inactive, IRootObjectProvider is available, but SimpleValueTargetProvider is not available
if (rootObjectProvider == null && valueTargetProvider == null)
{
throw new ArgumentException(
$"{nameof(serviceProvider)} does not provide an {nameof(IRootObjectProvider)} or {nameof(SimpleValueTargetProvider)}");
}
if (rootObjectProvider != null)
{
if (rootObjectProvider.RootObject is ResourceDictionary dictionary)
{
return(dictionary?.GetType().GetTypeInfo());
}
return((rootObjectProvider.RootObject as Element)?.GetType().GetTypeInfo());
}
PropertyInfo propertyInfo = valueTargetProvider.GetType()
.GetTypeInfo()
.DeclaredProperties.FirstOrDefault(dp => dp.Name.Contains("ParentObjects"));
if (propertyInfo == null)
{
throw new ArgumentNullException("ParentObjects");
}
IEnumerable <object> parentObjects = propertyInfo.GetValue(valueTargetProvider) as IEnumerable <object>;
object parentObject = parentObjects?.LastOrDefault(x => x.GetType().GetTypeInfo().IsSubclassOf(typeof(ResourceDictionary)));
if (parentObject == null)
{
parentObject = parentObjects?.LastOrDefault(x => x.GetType().GetTypeInfo().IsSubclassOf(typeof(Element)));
}
if (parentObject == null)
{
throw new ArgumentNullException("parentObject");
}
return(parentObject.GetType().GetTypeInfo());
}
public ValueSerializerContext (PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider)
{
if (prefixLookup == null)
throw new ArgumentNullException ("prefixLookup");
if (schemaContext == null)
throw new ArgumentNullException ("schemaContext");
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver (prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver (namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
}
public object ProvideValue(IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IRootObjectProvider rootObjectProvider = serviceProvider.GetService <IRootObjectProvider>();
if (rootObjectProvider == null)
{
throw new ArgumentException("serviceProvider did not provide an IRootObjectProvider");
}
// Find the root visual element (our view)
var visualElement = rootObjectProvider.RootObject as VisualElement;
var visualElementType = visualElement.GetType();
// If the XAML contains an explicit resource namespace and/or name,
// we will use those.
var resourceNamespace = ResourceNamespace;
var resourceName = ResourceName;
// If no resource namespace was provided, we'll use whatever was
// supplied as a default.
if (String.IsNullOrEmpty(resourceNamespace))
{
resourceNamespace = DefaultResourceNamespace;
}
// If no resource name was provided, we'll use the name of the
// class that backs the XAML view.
if (String.IsNullOrEmpty(resourceName))
{
resourceName = visualElementType.Name;
}
// Use the class factory to get an instance of an ILocalizer
var localizer = GetLocalizer(visualElementType.GetTypeInfo().Assembly);
// Combine the name and resource namespace to get the localized string
String localizationResult = _localizer.GetText(resourceNamespace, resourceName, ID);
if (String.IsNullOrEmpty(localizationResult))
{
localizationResult = "ResourceNotFound";
}
return(localizationResult);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IRootObjectProvider rootObjectProvider = (IRootObjectProvider)
serviceProvider.GetService(typeof(IRootObjectProvider));
if (rootObjectProvider == null)
{
return(null);
}
IDictionary dictionary = rootObjectProvider.RootObject as IDictionary;
if (dictionary == null)
{
return(null);
}
return(dictionary[ResourceKey]);
}
internal static void GetRootObjectAndDelegateType(ITypeDescriptorContext context, out object rootObject, out Type delegateType)
{
rootObject = null;
delegateType = null;
if (context != null)
{
IRootObjectProvider service = context.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (service != null)
{
rootObject = service.RootObject;
IDestinationTypeProvider provider2 = context.GetService(typeof(IDestinationTypeProvider)) as IDestinationTypeProvider;
if (provider2 != null)
{
delegateType = provider2.GetDestinationType();
}
}
}
}
public void XamlServiceProviderIRootObjectProvider()
{
tlog.Debug(tag, $"XamlServiceProviderIRootObjectProvider START");
try
{
IRootObjectProvider i1 = x1.IRootObjectProvider;
x1.IRootObjectProvider = i1;
}
catch (Exception e)
{
Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"XamlServiceProviderIRootObjectProvider END (OK)");
Assert.Pass("XamlServiceProviderIRootObjectProvider");
}
public ValueSerializerContext(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider, IXamlObjectWriterFactory objectWriterFactory)
{
if (prefixLookup == null)
{
throw new ArgumentNullException("prefixLookup");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
prefix_lookup = prefixLookup;
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
this.objectWriterFactory = objectWriterFactory;
}
object GetSourceObject(IServiceProvider serviceProvider)
{
IRootObjectProvider rootObjectProvider = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
FrameworkElement rootObject = rootObjectProvider?.RootObject as FrameworkElement;
if (rootObject == null)
{
throw new NullReferenceException();
}
if (ElementName != null)
{
return(rootObject.FindName(ElementName));
}
else
{
return(rootObject);
}
}
/// <summary>
/// Convert a string like "Button.Click" into the corresponding RoutedEvent
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext,
CultureInfo cultureInfo,
object source)
{
if (typeDescriptorContext == null)
{
throw new ArgumentNullException("typeDescriptorContext");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (s_ServiceProviderContextType == null)
{
// get typeof(MS.Internal.Xaml.ServiceProviderContext) via reflection
Assembly a = typeof(IRootObjectProvider).Assembly;
s_ServiceProviderContextType = a.GetType("MS.Internal.Xaml.ServiceProviderContext");
}
if (typeDescriptorContext.GetType() != s_ServiceProviderContextType)
{
// if the caller is not the XAML parser, don't answer. This avoids
// returning an arbitrary delegate to a (possibly malicious) caller.
// See Dev11 629384.
throw new ArgumentException(SR.Get(SRID.TextRange_InvalidParameterValue), "typeDescriptorContext");
}
IRootObjectProvider rootProvider = typeDescriptorContext.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootProvider != null && source is String)
{
IProvideValueTarget ipvt = typeDescriptorContext.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
if (ipvt != null)
{
EventSetter setter = ipvt.TargetObject as EventSetter;
string handlerName;
if (setter != null && (handlerName = source as string) != null)
{
handlerName = handlerName.Trim();
return(Delegate.CreateDelegate(setter.Event.HandlerType, rootProvider.RootObject, handlerName));
}
}
}
throw GetConvertFromException(source);
}
public ValueSerializerContext(PrefixLookup prefixLookup, XamlSchemaContext schemaContext, IAmbientProvider ambientProvider, IProvideValueTarget provideValue, IRootObjectProvider rootProvider, IDestinationTypeProvider destinationProvider)
{
if (prefixLookup == null)
{
throw new ArgumentNullException("prefixLookup");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
prefix_lookup = prefixLookup;
namespace_resolver = new NamespaceResolver(prefix_lookup.Namespaces);
type_resolver = new XamlTypeResolver(namespace_resolver, schemaContext);
sctx = schemaContext;
ambient_provider = ambientProvider;
this.provideValue = provideValue;
this.rootProvider = rootProvider;
this.destinationProvider = destinationProvider;
}
/// <summary>Converts the specified stream to a new <see cref="T:System.Windows.DeferrableContent" /> object.</summary>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
/// <param name="culture">The <see cref="T:System.Globalization.CultureInfo" /> to use as the current culture. </param>
/// <param name="value">The source stream to convert.</param>
/// <returns>A new <see cref="T:System.Windows.DeferrableContent" /> object.</returns>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="context" /> is <see langword="null" />.</exception>
/// <exception cref="T:System.InvalidOperationException">
/// <paramref name="context" /> is not able to provide the necessary XAML schema context for BAML.-or-
/// <see cref="T:System.Windows.Markup.IProvideValueTarget" /> service interpretation of <paramref name="context" /> determines that the target object is not a <see cref="T:System.Windows.ResourceDictionary" />.-or-
/// <paramref name="value" /> is not a valid byte stream.</exception>
// Token: 0x060003AC RID: 940 RVA: 0x0000A73C File Offset: 0x0000893C
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value == null)
{
return(base.ConvertFrom(context, culture, value));
}
if (context == null)
{
throw new ArgumentNullException("context");
}
XamlSchemaContext schemaContext = DeferrableContentConverter.RequireService <IXamlSchemaContextProvider>(context).SchemaContext;
Baml2006SchemaContext baml2006SchemaContext = schemaContext as Baml2006SchemaContext;
if (baml2006SchemaContext == null)
{
throw new InvalidOperationException(SR.Get("ExpectedBamlSchemaContext"));
}
IXamlObjectWriterFactory objectWriterFactory = DeferrableContentConverter.RequireService <IXamlObjectWriterFactory>(context);
IProvideValueTarget provideValueTarget = DeferrableContentConverter.RequireService <IProvideValueTarget>(context);
IRootObjectProvider rootObjectProvider = DeferrableContentConverter.RequireService <IRootObjectProvider>(context);
if (!(provideValueTarget.TargetObject is ResourceDictionary))
{
throw new InvalidOperationException(SR.Get("ExpectedResourceDictionaryTarget"));
}
Stream stream = value as Stream;
if (stream == null)
{
byte[] array = value as byte[];
if (array != null)
{
stream = new MemoryStream(array);
}
}
if (stream == null)
{
throw new InvalidOperationException(SR.Get("ExpectedBinaryContent"));
}
return(new DeferrableContent(stream, baml2006SchemaContext, objectWriterFactory, context, rootObjectProvider.RootObject));
}
private void Initialize(IProvideValueTarget valueTargetProvider, IRootObjectProvider rootObjectProvider)
{
// if XamlCompilation is active, IRootObjectProvider is not available, but SimpleValueTargetProvider is available
// if XamlCompilation is inactive, IRootObjectProvider is available, but SimpleValueTargetProvider is not available
object rootObject;
//object bindable;
var propertyInfo = valueTargetProvider.GetType().GetTypeInfo().DeclaredProperties.FirstOrDefault(dp => dp.Name.Contains("ParentObjects"));
if (propertyInfo == null)
{
throw new ArgumentNullException("ParentObjects");
}
var parentObjects = (propertyInfo.GetValue(valueTargetProvider) as IEnumerable <object>).ToList();
BindableTree = parentObjects.Cast <BindableObject>();
if (rootObjectProvider == null && valueTargetProvider == null)
{
throw new ArgumentException("serviceProvider does not provide an IRootObjectProvider or SimpleValueTargetProvider");
}
if (rootObjectProvider == null)
{
var parentObject = parentObjects.FirstOrDefault(pO => pO.GetType().GetTypeInfo().IsSubclassOf(typeof(Page)));
Bindable = (BindableObject)parentObjects.FirstOrDefault();
rootObject = parentObject ?? throw new ArgumentNullException("parentObject");
}
else
{
rootObject = rootObjectProvider.RootObject;
Bindable = (BindableObject)valueTargetProvider.TargetObject;
}
SetRaiseCanExecuteChangedInternal(Bindable, RaiseCanExecuteChanged);
if (rootObject is Page page)
{
Page = Page ?? page; // allow the user's defined page to take precedence
}
}
/// <summary>
/// Returns an object that is provided as the value of the target property for this markup extension.
/// </summary>
/// <param name="serviceProvider">A service provider helper that can provide services for the markup extension.</param>
/// <returns>The object value to set on the property where the extension is applied.</returns>
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (serviceProvider != null)
{
Type type = Type;
if (Designer.DesignMode)
{
IRootObjectProvider provider = serviceProvider.GetService <IRootObjectProvider>();
if (provider != null && provider.RootObject is DependencyObject element)
{
Designer.SetDesignType(element, type);
}
}
return(type?.FullName);
}
return(this);
}
internal static object GetRootTemplatedActivity(IServiceProvider serviceProvider)
{
// For now, we only support references to the root Activity when we're inside an Activity.Body
// Note that in the case of nested activity bodies, this gives us the outer activity
IRootObjectProvider rootProvider =
serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootProvider == null)
{
return(null);
}
IAmbientProvider ambientProvider =
serviceProvider.GetService(typeof(IAmbientProvider)) as IAmbientProvider;
if (ambientProvider == null)
{
return(null);
}
IXamlSchemaContextProvider schemaContextProvider =
serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider;
if (schemaContextProvider == null)
{
return(null);
}
XamlMember activityBody = GetXamlMember(schemaContextProvider.SchemaContext, typeof(Activity), "Implementation");
XamlMember dynamicActivityBody = GetXamlMember(schemaContextProvider.SchemaContext, typeof(DynamicActivity), "Implementation");
if (activityBody == null || dynamicActivityBody == null)
{
return(null);
}
if (ambientProvider.GetFirstAmbientValue(null, activityBody, dynamicActivityBody) == null)
{
return(null);
}
object rootActivity = rootProvider.RootObject as Activity;
return(rootActivity);
}
private static object RetrieveDataContext(DependencyObject target, IRootObjectProvider rootProvider)
{
object dataContext = target.GetValue(FrameworkElement.DataContextProperty)
?? target.GetValue(FrameworkContentElement.DataContextProperty);
if (dataContext == null)
{
var root = rootProvider.RootObject as DependencyObject;
if (root != null)
{
dataContext = root.GetValue(FrameworkElement.DataContextProperty)
?? root.GetValue(FrameworkContentElement.DataContextProperty);
if (dataContext == null)
{
throw new InvalidOperationException("DataContext could not be found.");
}
}
}
return(dataContext);
}
/// <summary>Converts the specified string to a new <see cref="T:System.Delegate" /> for the event handler.</summary>
/// <param name="typeDescriptorContext">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
/// <param name="cultureInfo">The <see cref="T:System.Globalization.CultureInfo" /> to use as the current culture. </param>
/// <param name="source">The source string to convert.</param>
/// <returns>A new <see cref="T:System.Delegate" /> that represents the referenced event handler.</returns>
/// <exception cref="T:System.NotSupportedException">The necessary services are not available.-or-Could not perform the specific conversion.</exception>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="typeDescriptorContext" /> or <paramref name="source" /> are <see langword="null" />.</exception>
// Token: 0x06001D03 RID: 7427 RVA: 0x00087740 File Offset: 0x00085940
public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object source)
{
if (typeDescriptorContext == null)
{
throw new ArgumentNullException("typeDescriptorContext");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (EventSetterHandlerConverter.s_ServiceProviderContextType == null)
{
Assembly assembly = typeof(IRootObjectProvider).Assembly;
EventSetterHandlerConverter.s_ServiceProviderContextType = assembly.GetType("MS.Internal.Xaml.ServiceProviderContext");
}
if (typeDescriptorContext.GetType() != EventSetterHandlerConverter.s_ServiceProviderContextType)
{
throw new ArgumentException(SR.Get("TextRange_InvalidParameterValue"), "typeDescriptorContext");
}
IRootObjectProvider rootObjectProvider = typeDescriptorContext.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
if (rootObjectProvider != null && source is string)
{
IProvideValueTarget provideValueTarget = typeDescriptorContext.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
if (provideValueTarget != null)
{
EventSetter eventSetter = provideValueTarget.TargetObject as EventSetter;
string text;
if (eventSetter != null && (text = (source as string)) != null)
{
text = text.Trim();
return(Delegate.CreateDelegate(eventSetter.Event.HandlerType, rootObjectProvider.RootObject, text));
}
}
}
throw base.GetConvertFromException(source);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
try
{
IRootObjectProvider service = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider;
var locAttribute = (LocalizationAttribute)Attribute.GetCustomAttribute(service.RootObject.GetType(), typeof(LocalizationAttribute));
ResourceManager resman = new ResourceManager(locAttribute.ResourceClassPath, service.RootObject.GetType().Assembly);
if (resman.GetString(Key) != null)
{
return(resman.GetString(Key));
}
else
{
GuiLogMessageOccured(string.Format(Resources.Can_t_find_localization_key, Key, service.RootObject.GetType()), NotificationLevel.Warning);
return(Key);
}
}
catch (Exception ex)
{
GuiLogMessageOccured(string.Format(Resources.Error_trying_to_lookup_localization_key, Key, ex.Message), NotificationLevel.Warning);
return(Key);
}
}
