Example #1
0
        internal object InvokeInternal(string name, params object [] args)
        {
            CheckName(name);
            CheckHandle();
            int    length = args == null ? 0 : args.Length;
            object result = null;

            Mono.Value    res;
            Mono.Value [] vargs = new Mono.Value [length];

            for (int i = 0; i < length; i++)
            {
                ScriptObjectHelper.ToValue(ref vargs [i], args [i]);
            }

            if (!NativeMethods.html_object_invoke(PluginHost.Handle, Handle, name, vargs, (uint)length, out res))
            {
                throw new InvalidOperationException();
            }

            using (res)
                if (res.k != Mono.Kind.INVALID)
                {
                    result = ScriptObjectHelper.FromValue(res);
                }

            return(result);
        }
Example #2
0
        internal object InvokeSelfInternal(params object [] args)
        {
            CheckHandle();
            int    length = args == null ? 0 : args.Length;
            object result = null;

            Mono.Value    res;
            Mono.Value [] vargs = new Mono.Value [length];

            for (int i = 0; i < length; i++)
            {
                ScriptObjectHelper.ToValue(ref vargs [i], args [i]);
            }

            try {
                if (!NativeMethods.html_object_invoke_self(PluginHost.Handle, Handle, vargs, (uint)length, out res))
                {
                    throw new InvalidOperationException();
                }

                if (res.k != Mono.Kind.INVALID)
                {
                    result = ScriptObjectHelper.FromValue(res);
                }
            }
            finally {
                res.Dispose();
                foreach (var v in vargs)
                {
                    v.Dispose();
                }
            }
            return(result);
        }
Example #3
0
 internal static void SetPropertyInternal(IntPtr h, string name, object value)
 {
     CheckName(name);
     Mono.Value dp = new Mono.Value();
     ScriptObjectHelper.ToValue(ref dp, value);
     using (dp) {
         NativeMethods.html_object_set_property(PluginHost.Handle, h, name, ref dp);
     }
 }
Example #4
0
		private unsafe bool AddChild (XamlCallbackData *data, Value* parent_parent_ptr, bool parent_is_property, string parent_xmlns, Value *parent_ptr, IntPtr parent_data, Value* child_ptr, IntPtr child_data)
		{
			object parent = Value.ToObject (null, parent_ptr);
			object child = Value.ToObject (null, child_ptr);

			if (parent_is_property) {
				object parent_parent = Value.ToObject (null, parent_parent_ptr);
				return AddChildToProperty (data, parent_parent, parent_xmlns, parent, child, child_data);
			}

			return AddChildToItem (data, parent_parent_ptr, parent, parent_data, child_ptr, child, child_data);
		}
Example #5
0
		private unsafe MethodInfo GetMethodForAttachedProperty (Value *top_level, string xmlns, string type_name, string full_type_name, string prop_name, string method_prefix, Type [] arg_types)
		{
			string assembly_name = AssemblyNameFromXmlns (xmlns);
			string ns = ClrNamespaceFromXmlns (xmlns);
				
			if (assembly_name == null && !TryGetDefaultAssemblyName (top_level, out assembly_name)) {
				Console.Error.WriteLine ("Unable to find an assembly to load type from.");
				return null;
			}

			Assembly clientlib;
			if (LoadAssembly (assembly_name, out clientlib) != AssemblyLoadResult.Success) {
				Console.Error.WriteLine ("couldn't load assembly:  {0}   namespace:  {1}", assembly_name, ns);
				return null;
			}

			Type attach_type = clientlib.GetType (full_type_name, false);
			if (attach_type == null) {
				attach_type = Application.GetComponentTypeFromName (type_name);
				if (attach_type == null) {
					Console.Error.WriteLine ("attach type is null type name: {0} full type name: {1}", type_name, full_type_name);
					return null;
				}
			}

			MethodInfo [] methods = attach_type.GetMethods (BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

			string method_name = String.Concat (method_prefix, prop_name);
			foreach (MethodInfo method in methods) {

				if (method.Name != method_name)
					continue;

				ParameterInfo [] the_params = method.GetParameters ();
				if (the_params.Length != arg_types.Length)
					continue;

				bool match = true;
				for (int i = 0; i < arg_types.Length; i++) {
					if (!arg_types [i].IsAssignableFrom (the_params [i].ParameterType)) {
						Console.WriteLine ("NOT A MATCH:  {0} -- {1} : {2}", method, arg_types [i], the_params [i]);
						match = false;
						break;
					}
				}

				if (match)
					return method;
			}

			return null;
		}
Example #6
0
		private unsafe bool SetProperty (XamlCallbackData *data, string xmlns, Value* target_ptr, IntPtr target_data, Value* target_parent_ptr, string prop_xmlns, string name, Value* value_ptr, IntPtr value_data)
		{
			string error;
			object target = Value.ToObject (null, target_ptr);

			if (target == null) {
				Console.Error.WriteLine ("target is null: {0} {1} {2}", (IntPtr)target_ptr, name, xmlns);
				return false;
			}

			if (name == null) {
				if (TrySetEnumContentProperty (data, xmlns, target, target_ptr, target_data, value_ptr, value_data))
					return true;
				if (TrySetCollectionContentProperty (xmlns, target, target_ptr, target_data, value_ptr, value_data))
					return true;
				if (TrySetObjectTextProperty (data, xmlns, target, target_ptr, target_data, value_ptr, value_data))
					return true;
				Console.Error.WriteLine ("no property name supplied");
				return false;
			}

			string full_name = name;
			int dot = name.IndexOf ('.');
			string type_name = null;

			if (dot >= 0) {
				type_name = name.Substring (0, dot);
				if (prop_xmlns != null) {
					string ns = ClrNamespaceFromXmlns (prop_xmlns);
					if (ns != null)
						type_name = String.Concat (ns, ".", type_name);
				}
				name = name.Substring (++dot, name.Length - dot);
			}

			if (TrySetExpression (data, xmlns, target, target_data, target_parent_ptr, type_name, prop_xmlns, name, full_name, value_ptr, value_data))
				return true;

			if (!IsAttachedProperty (data, target, xmlns, prop_xmlns, full_name)) {
				if (TrySetPropertyReflection (data, xmlns, target, target_data, target_parent_ptr, type_name, name, value_ptr, value_data, out error))
					return true;

				if (TrySetEventReflection (data, xmlns, target, type_name, name, value_ptr, out error))
					return true;
			} else {
				if (TrySetAttachedProperty (data, xmlns, target, target_data, prop_xmlns, full_name, value_ptr))
					return true;
			}

			
			return false;
		}
Example #7
0
		private IntPtr ValueToIntPtr (Value v)
		{
			IntPtr ptr = Marshal.AllocHGlobal (Marshal.SizeOf (v));

			Marshal.StructureToPtr (v, ptr, false);
			return ptr;
		}
Example #8
0
		//
		// Proxy so that we return bool in case of any failures, instead of
		// generating an exception and unwinding the stack.
		//
		private unsafe bool cb_set_property (XamlCallbackData *data, string xmlns, Value* target, IntPtr target_data, Value* target_parent, string prop_xmlns, string name, Value* value_ptr, IntPtr value_data, ref MoonError error)
		{
			try {
				return SetProperty (data, xmlns, target, target_data, target_parent, prop_xmlns, name, value_ptr, value_data);
			} catch (Exception ex) {
				try {
					Console.Error.WriteLine ("ManagedXamlLoader::SetProperty ({0}, {1}, {2}, {3}, {4}) threw an exception: {5}", (IntPtr) data->top_level, xmlns, (IntPtr)target, name, (IntPtr)value_ptr, ex.Message);
					Console.Error.WriteLine (ex);
					error = new MoonError (ex);
					return false;
				}
				catch {
					return false;
				}
			}
		}
Example #9
0
		public void Hydrate (Value value, string xaml, bool createNamescope, bool validateTemplates)
		{
			Hydrate (value, xaml, createNamescope, validateTemplates, false);
		}
Example #10
0
		protected abstract void HydrateInternal (Value value, string xaml, bool createNamescope, bool validateTemplates, bool import_default_xmlns);
Example #11
0
		private unsafe bool TrySetExpression (XamlCallbackData *data, string xmlns, object target, IntPtr target_data, Value* target_parent_ptr, string type_name, string prop_xmlns, string name, string full_name, Value* value_ptr, IntPtr value_data)
		{
			DependencyObject dob = target as DependencyObject;
			object obj_value = Value.ToObject (null, value_ptr);
			string str_value = obj_value as string;

			if (str_value == null)
				return false;
			
			if (!str_value.StartsWith ("{"))
				return false;

			MarkupExpressionParser p = new SL3MarkupExpressionParser (target, name, data->parser, target_data);
			string expression = str_value;
			object o = p.ParseExpression (ref expression);

			if (o == null)
				return false;

			
			if (o is Binding) {
				Binding binding = o as Binding;
				DependencyProperty prop = null;

				if (dob != null) {
					string full_type_name = type_name;
					if (IsAttachedProperty (full_name))
						GetNameForAttachedProperty (xmlns, prop_xmlns, full_name, out type_name, out full_type_name);
					prop = LookupDependencyPropertyForBinding (data, dob, full_type_name, name);
					if (prop == null && IsAttachedProperty (full_name))
						prop = LookupDependencyPropertyForBinding (data, dob, full_name.Split ('.')[0], name);
				}

				// If it's null we should look for a regular CLR property
				if (prop != null) {
					BindingOperations.SetBinding (dob, prop, binding);
					return true;
				}
			}
			if (o is TemplateBindingExpression) {
				// Applying a {TemplateBinding} to a DO which is not a FrameworkElement should silently discard
				// the binding.
				if (!(dob is FrameworkElement))
					return true;

				TemplateBindingExpression tb = o as TemplateBindingExpression;

				IntPtr context = NativeMethods.sl3_xaml_loader_get_context (data->loader);
				IntPtr source_ptr = NativeMethods.xaml_context_get_template_binding_source (context);

				// Silently discard TemplateBindings which are not in ControlTemplates
				FrameworkTemplate source_template = (FrameworkTemplate) NativeDependencyObjectHelper.Lookup (NativeMethods.xaml_context_get_source_template (context));
				if (!(source_template is ControlTemplate))
					return true;

				DependencyObject templateSourceObject = NativeDependencyObjectHelper.FromIntPtr (source_ptr) as DependencyObject;
				if (templateSourceObject == null)
					return false;

				DependencyProperty sourceProperty = DependencyProperty.Lookup (templateSourceObject.GetKind(),
												       tb.SourcePropertyName);
				if (sourceProperty == null)
					return false;

				DependencyProperty prop = null;

				if (dob != null)
					prop = LookupDependencyPropertyForBinding (data, dob, type_name, name);

				if (prop == null)
					return false;

				tb.TargetProperty = prop;
				tb.SourceProperty = sourceProperty;

				((FrameworkElement) dob).SetTemplateBinding (prop, tb);

				return true;
			}

			if (IsAttachedProperty (full_name))
				return TrySetAttachedProperty (data, xmlns, target, target_data, prop_xmlns, full_name, o);

			PropertyInfo pi = target.GetType ().GetProperty (name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);

			o = ConvertType (pi, pi.PropertyType, o);
			SetValue (data, target_data, pi, target, o);
			return true;
		}
Example #12
0
		private unsafe bool TrySetAttachedProperty (XamlCallbackData *data, string xmlns, object target, IntPtr target_data, string prop_xmlns, string name, Value* value_ptr)
		{
			string full_name = name;
			string type_name = null;
			string full_type_name = null;

			name = GetNameForAttachedProperty (xmlns, prop_xmlns, name, out type_name, out full_type_name);

			if (name == null)
				return false;

			string error = null;
			object o_value = GetObjectValue (target, target_data, name, data->parser, value_ptr, out error);
			
			return TrySetAttachedProperty (data, xmlns, target, target_data, prop_xmlns, full_name, o_value);
		}
Example #13
0
		private unsafe bool LookupPropertyObject (Value* top_level, Value* parent_value, string xmlns, string name, int dot, bool create, out Value value)
		{
			string prop_name = name.Substring (dot + 1);
			object parent = Value.ToObject (null, parent_value);

			if (parent == null) {
				value = Value.Empty;
				return false;
			}

			PropertyInfo pi = null;
			bool is_attached = true;
			string type_name = name.Substring (0, dot);

			Type t = parent.GetType ();
			while (t != typeof (object)) {
				if (t.Name == type_name) {
					is_attached = false;
					break;
				}
				t = t.BaseType;
			}

			if (is_attached) {
				Type attach_type = null;
				string full_type_name = type_name;
				if (xmlns != null) {
					string ns = ClrNamespaceFromXmlns (xmlns);
					full_type_name = String.Concat (ns, ".", type_name);
				}

				MethodInfo get_method = GetGetMethodForAttachedProperty (top_level, xmlns, type_name, full_type_name, prop_name);

				if (get_method != null)
					attach_type = get_method.ReturnType;

				if (attach_type == null) {
					value = Value.Empty;
					return false;
				}

				ManagedType mt = Deployment.Current.Types.Find (attach_type);
				value = Value.Empty;
				value.IsNull = true;
				value.k = mt.native_handle;
				return true;
			} else {
				pi = parent.GetType ().GetProperty (name.Substring (dot + 1), BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);

				if (pi == null) {
					value = Value.Empty;
					return false;
				}

				ManagedType mt = Deployment.Current.Types.Find (pi.PropertyType);
				value = Value.Empty;
				value.k = mt.native_handle;
				value.IsNull = true;

				return true;
			}
		}
Example #14
0
		private unsafe bool LookupComponentFromName (Value* top_level, string name, bool create, out Value value)
		{
			if (!create) {
				Type type = Application.GetComponentTypeFromName (name);
				if (type == null) {
					value = Value.Empty;
					return false;
				}
				value = Value.Empty;
				value.k = Deployment.Current.Types.Find (type).native_handle;
				return true;
			}

			object obj = Application.CreateComponentFromName (name);
			if (obj == null) {
				value = Value.Empty;
				return false;
			}

			value = Value.FromObject (obj, false);
			return true;
		}
Example #15
0
		private unsafe bool LookupObject (Value *top_level, Value *parent, string xmlns, string name, bool create, bool is_property, out Value value)
		{
			if (name == null)
				throw new ArgumentNullException ("type_name");

			
			if (is_property) {
				int dot = name.IndexOf ('.');
				return LookupPropertyObject (top_level, parent, xmlns, name, dot, create, out value);
			}

			if (top_level == null && xmlns == null) {
				return LookupComponentFromName (top_level, name, create, out value);
			}

			string assembly_name = AssemblyNameFromXmlns (xmlns);
			string clr_namespace = ClrNamespaceFromXmlns (xmlns);
			string full_name = string.IsNullOrEmpty (clr_namespace) ? name : clr_namespace + "." + name;

			Type type = LookupType (top_level, assembly_name, full_name);
			if (type == null) {
				Console.Error.WriteLine ("ManagedXamlLoader::LookupObject: GetType ({0}) failed using assembly: {1} ({2}, {3}).", name, assembly_name, xmlns, full_name);
				value = Value.Empty;
				return false;
			}

			if (create) {

				if (!type.IsPublic) {
					value = Value.Empty;
					throw new XamlParseException ("Attempting to create a private type");
				}

				object res = null;
				try {
					res = Activator.CreateInstance (type);
				} catch (TargetInvocationException ex) {
					Console.WriteLine (ex);
					Console.Error.WriteLine ("ManagedXamlLoader::LookupObject: CreateInstance ({0}) failed: {1}", name, ex.InnerException);
					value = Value.Empty;
					return false;
				}

				if (res == null) {
					Console.Error.WriteLine ("ManagedXamlLoader::LookupObject ({0}, {1}, {2}): unable to create object instance: '{3}', the object was of type '{4}'",
								 assembly_name, xmlns, name, full_name, type.FullName);
					value = Value.Empty;
					return false;
				}
				// This is freed in native.
				value = Value.FromObject (res, false);
			} else {
				value = Value.Empty;
				value.k = Deployment.Current.Types.Find (type).native_handle;
			}

			return true;
		}
Example #16
0
		private unsafe bool TryGetDefaultAssemblyName (Value* top_level, out string assembly_name)
		{
			if (assembly != null) {
				assembly_name = assembly.GetName ().Name;
				return true;
			}

			object obj = Value.ToObject (null, top_level);

			if (obj == null) {
				assembly_name = null;
				return false;
			}

			assembly_name = obj.GetType ().Assembly.GetName ().Name;
			return true;
		}
Example #17
0
		private unsafe bool cb_add_child (XamlCallbackData *data, Value* parent_parent, bool parent_is_property, string parent_xmlns, Value *parent, IntPtr parent_data, Value* child, IntPtr child_data, ref MoonError error)
		{
			try {
				return AddChild (data, parent_parent, parent_is_property, parent_xmlns, parent, parent_data, child, child_data);
			} catch (Exception ex) {
				Console.Error.WriteLine (ex);
				error = new MoonError (ex);
				return false;
			}
				
		}
Example #18
0
		//
		// Hydrates the object dob from the given xaml
		//
		public void Hydrate (Value value, string xaml)
		{
			Hydrate (value, xaml, true, false, false);
		}
Example #19
0
		private unsafe bool TrySetPropertyReflection (XamlCallbackData *data, string xmlns, object target, IntPtr target_data, Value* target_parent_ptr, string type_name, string name, Value* value_ptr, IntPtr value_data, out string error)
		{	
			PropertyInfo pi = target.GetType ().GetProperty (name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);

			if (pi == null) {
				error = "Property does not exist.";
				return false;
			}

			if (!SetPropertyFromValue (data, target, target_data, target_parent_ptr, pi, value_ptr, value_data, out error))
				return false;

			error = null;
			return true;
		}
Example #20
0
		public void Hydrate (Value value, string xaml, bool createNamescope)
		{
			Hydrate (value, xaml, createNamescope, false, false);
		}
Example #21
0
		private static unsafe object GetObjectValue (object target, IntPtr target_data, string prop_name, IntPtr parser, Value* value_ptr, out string error)
		{
			error = null;

			IntPtr unmanaged_value = IntPtr.Zero;
			object o_value = Value.ToObject (null, value_ptr);
			if (error == null && unmanaged_value != IntPtr.Zero)
				o_value = Value.ToObject (null, unmanaged_value);

			if (o_value is String && SL3MarkupExpressionParser.IsStaticResource ((string) o_value)) {
				MarkupExpressionParser mp = new SL3MarkupExpressionParser ((DependencyObject) target, prop_name, parser, target_data);
				string str_value = o_value as String;
				o_value = mp.ParseExpression (ref str_value);
			}

			return o_value;
		}
Example #22
0
		public void Hydrate (Value value, string xaml, bool createNamescope, bool validateTemplates, bool import_default_xmlns)
		{
			HydrateInternal (value, xaml, createNamescope, validateTemplates, import_default_xmlns);
		}
Example #23
0
		private static unsafe IntPtr ParseTemplate (Value *context_ptr, string resource_base, IntPtr surface, IntPtr binding_source, string xaml, ref MoonError error)
		{
			XamlContext context = Value.ToObject (typeof (XamlContext), context_ptr) as XamlContext;

			var parser = new XamlParser (context);

			var source = NativeDependencyObjectHelper.FromIntPtr (binding_source);
			if (source == null) {
				error = new MoonError (parser.ParseException ("Attempting to parse a template with an invalid binding source."));
				return IntPtr.Zero;
			}

			FrameworkElement fwe = source as FrameworkElement;
			if (fwe == null) {
				error = new MoonError (parser.ParseException ("Only FrameworkElements can be used as TemplateBinding sources."));
				return IntPtr.Zero;
			}

			context.IsExpandingTemplate = true;
			context.TemplateBindingSource = fwe;

			INativeEventObjectWrapper dob = null;
			try {
				dob = parser.ParseString (xaml) as INativeEventObjectWrapper;
			} catch (Exception e) {
				error = new MoonError (e);
				return IntPtr.Zero;
			}

			if (dob == null) {
				error = new MoonError (parser.ParseException ("Unable to parse template item."));
				return IntPtr.Zero;
			}

			return dob.NativeHandle;
		}
Example #24
0
        private static DependencyProperty RegisterAny(string name, Type propertyType, Type ownerType, PropertyMetadata metadata, bool attached, bool readOnly, bool setsParent, bool custom)
        {
            ManagedType property_type;
            ManagedType owner_type;
            UnmanagedPropertyChangeHandler handler = null;
            CustomDependencyProperty result;
            bool is_nullable = false;
            object default_value = DependencyProperty.UnsetValue;
            PropertyChangedCallback property_changed_callback = null;

            if (name == null)
                throw new ArgumentNullException ("name");

            if (name.Length == 0)
                throw new ArgumentException("The 'name' argument cannot be an empty string");

            if (propertyType == null)
                throw new ArgumentNullException ("propertyType");

            if (ownerType == null)
                throw new ArgumentNullException ("ownerType");

            if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition () == typeof (Nullable<>)) {
                is_nullable = true;
                // Console.WriteLine ("DependencyProperty.RegisterAny (): found nullable {0}, got nullable {1}", propertyType.FullName, propertyType.GetGenericArguments () [0].FullName);
                propertyType = propertyType.GetGenericArguments () [0];
            }

            Types types = Deployment.Current.Types;

            property_type = types.Find (propertyType);
            owner_type = types.Find (ownerType);

            if (metadata != null) {
                default_value = metadata.DefaultValue ?? UnsetValue;
                property_changed_callback = metadata.property_changed_callback;
            }

            if ((default_value == DependencyProperty.UnsetValue) && propertyType.IsValueType && !is_nullable)
                default_value = Activator.CreateInstance (propertyType);

            if (default_value != null && default_value != UnsetValue && !propertyType.IsAssignableFrom (default_value.GetType ()))
                throw new ArgumentException (string.Format ("DefaultValue is of type {0} which is not compatible with type {1}", default_value.GetType (), propertyType));

            if (property_changed_callback != null)
                handler = UnmanagedPropertyChangedCallbackSafe;

            Value v;
            if (default_value == DependencyProperty.UnsetValue) {
                v = new Value { k = types.TypeToKind (propertyType), IsNull = true };
                default_value = null;
            } else {
                v = Value.FromObject (default_value, true);
            }

            IntPtr handle;
            using (v) {
                var val = v;
                if (custom)
                    handle = NativeMethods.dependency_property_register_custom_property (name, property_type.native_handle, owner_type.native_handle, ref val, attached, readOnly, handler);
                else
                    handle = NativeMethods.dependency_property_register_core_property (name, property_type.native_handle, owner_type.native_handle, ref val, attached, readOnly, handler);
            }

            if (handle == IntPtr.Zero)
                return null;

            if (is_nullable)
                NativeMethods.dependency_property_set_is_nullable (handle, true);

            result = new CustomDependencyProperty (handle, name, property_type, owner_type, default_value);
            result.attached = attached;
            result.PropertyChangedHandler = handler;
            result.property_changed_callback = property_changed_callback;

            return result;
        }
Example #25
0
File: Value.cs Project: shana/moon
		//
		// How do we support "null" values, should the caller take care of that?
		//
		// The caller is responsible for calling value_free_value on the returned Value
		public static Value FromObject (object v, bool box_value_types)
		{
			Value value = new Value ();
			
			unsafe {
				// get rid of this case right away.
				if (box_value_types && v.GetType().IsValueType) {
					//Console.WriteLine ("Boxing a value of type {0}:", v.GetType());

					GCHandle handle = GCHandle.Alloc (v);
					value.k = Deployment.Current.Types.TypeToKind (v.GetType ());
					value.IsGCHandle = true;
					value.u.p = GCHandle.ToIntPtr (handle);
					return value;
				}

				if (v is IEasingFunction && !(v is EasingFunctionBase))
					v = new EasingFunctionWrapper (v as IEasingFunction);

				if (v is INativeEventObjectWrapper) {
					INativeEventObjectWrapper dov = (INativeEventObjectWrapper) v;

					if (dov.NativeHandle == IntPtr.Zero)
						throw new Exception (String.Format (
							"Object {0} has not set its native property", dov.GetType()));

					NativeMethods.event_object_ref (dov.NativeHandle);

					value.k = dov.GetKind ();
					value.u.p = dov.NativeHandle;

				} else if (v is DependencyProperty) {
					value.k = Kind.DEPENDENCYPROPERTY;
					value.u.p = ((DependencyProperty)v).Native;
				}
				else if (v is int || (v.GetType ().IsEnum && Enum.GetUnderlyingType (v.GetType()) == typeof(int))) {
					value.k = Deployment.Current.Types.TypeToKind (v.GetType ());
					value.u.i32 = (int) v;
				}
				else if (v is bool) {
					value.k = Kind.BOOL;
					value.u.i32 = ((bool) v) ? 1 : 0;
				}
				else if (v is double) {
					value.k = Kind.DOUBLE;
					value.u.d = (double) v;
				}
				else if (v is float) {
					value.k = Kind.FLOAT;
					value.u.f = (float) v;
				}
				else if (v is long) {
					value.k = Kind.INT64;
					value.u.i64 = (long) v;
				}
				else if (v is TimeSpan) {
					TimeSpan ts = (TimeSpan) v;
					value.k = Kind.TIMESPAN;
					value.u.i64 = ts.Ticks;
				}
				else if (v is ulong) {
					value.k = Kind.UINT64;
					value.u.ui64 = (ulong) v;
				}
				else if (v is uint) {
					value.k = Kind.UINT32;
					value.u.ui32 = (uint) v;
				}
				else if (v is char) {
					value.k = Kind.CHAR;
					value.u.ui32 = (uint) (char) v;
				}
				else if (v is string) {
					value.k = Kind.STRING;

					value.u.p = StringToIntPtr ((string) v);
				}
				else if (v is Rect) {
					Rect rect = (Rect) v;
					value.k = Kind.RECT;
					value.u.p = Marshal.AllocHGlobal (sizeof (Rect));
					Marshal.StructureToPtr (rect, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is Size) {
					Size size = (Size) v;
					value.k = Kind.SIZE;
					value.u.p = Marshal.AllocHGlobal (sizeof (Size));
					Marshal.StructureToPtr (size, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is CornerRadius) {
					CornerRadius corner = (CornerRadius) v;
					value.k = Kind.CORNERRADIUS;
					value.u.p = Marshal.AllocHGlobal (sizeof (CornerRadius));
					Marshal.StructureToPtr (corner, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is AudioFormat) {
					AudioFormat f = (AudioFormat) v;
					value.k = Kind.AUDIOFORMAT;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedAudioFormat));
					UnmanagedAudioFormat *format = (UnmanagedAudioFormat*) value.u.p;
					format->bitsPerSample = f.BitsPerSample;
					format->channels = f.Channels;
					format->samplesPerSecond = f.SamplesPerSecond;
					format->waveFormat = f.WaveFormat;
				}
				else if (v is VideoFormat) {
					VideoFormat f = (VideoFormat) v;
					value.k = Kind.VIDEOFORMAT;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedVideoFormat));
					UnmanagedVideoFormat *format = (UnmanagedVideoFormat*) value.u.p;
					format->framesPerSecond = f.FramesPerSecond;
					format->height = f.PixelHeight;
					format->width = f.PixelWidth;
					format->stride = f.Stride;
					format->pixelFormat = f.PixelFormat;
				}
				else if (v is Point) {
					Point pnt = (Point) v;
					value.k = Kind.POINT;
					value.u.p = Marshal.AllocHGlobal (sizeof (Point));
					Marshal.StructureToPtr (pnt, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is Thickness) {
					Thickness thickness = (Thickness)v;
					value.k = Kind.THICKNESS;
					value.u.p = Marshal.AllocHGlobal (sizeof (Thickness));
					Marshal.StructureToPtr (thickness, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is Color) {
					Color c = (Color) v;
					value.k = Kind.COLOR;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedColor));
					UnmanagedColor* color = (UnmanagedColor*) value.u.p;
					color->r = c.R / 255.0f;
					color->g = c.G / 255.0f;
					color->b = c.B / 255.0f;
					color->a = c.A / 255.0f;
				}
				else if (v is Matrix) {
					// hack around the fact that managed Matrix is a struct while unmanaged Matrix is a DO
					// i.e. the unmanaged and managed structure layouts ARE NOT equal
					return FromObject (new UnmanagedMatrix ((Matrix) v), box_value_types);
				}
				else if (v is StylusPoint) {
					return FromObject (new UnmanagedStylusPoint ((StylusPoint) v), box_value_types);
				}
				else if (v is Matrix3D) {
					// hack around the fact that managed Matrix3D is a struct while unmanaged Matrix3D is a DO
					// i.e. the unmanaged and managed structure layouts ARE NOT equal
					return FromObject (new UnmanagedMatrix3D ((Matrix3D) v), box_value_types);
				}
				else if (v is Duration) {
					Duration d = (Duration) v;
					value.k = Kind.DURATION;
					value.u.p = Marshal.AllocHGlobal (sizeof (Duration));
					Marshal.StructureToPtr (d, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is KeyTime) {
					KeyTime k = (KeyTime) v;
					value.k = Kind.KEYTIME;
					value.u.p = Marshal.AllocHGlobal (sizeof (KeyTime));
					Marshal.StructureToPtr (k, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is RepeatBehavior) {
					RepeatBehavior d = (RepeatBehavior) v;
					value.k = Kind.REPEATBEHAVIOR;
					value.u.p = Marshal.AllocHGlobal (sizeof (RepeatBehavior));
					Marshal.StructureToPtr (d, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is FontFamily) {
					FontFamily family = (FontFamily) v;
					value.k = Kind.FONTFAMILY;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedFontFamily));
					Marshal.StructureToPtr (family, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}

				else if (v is FontSource) {
					FontSource source = (FontSource) v;
					
					value.k = Kind.FONTSOURCE;
					
					if (source.wrapper != null || source.typeface != null) {
						value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedFontSource));
						UnmanagedFontSource *ufs = (UnmanagedFontSource *) value.u.p;
						ufs->type = source.type;
						
						switch (source.type) {
						case FontSourceType.ManagedStream:
							ManagedStreamCallbacks callbacks = source.wrapper.GetCallbacks ();
							ufs->source.stream = Marshal.AllocHGlobal (sizeof (UnmanagedStreamCallbacks));
							Marshal.StructureToPtr (callbacks, ufs->source.stream, false);
							break;
						case FontSourceType.GlyphTypeface:
							ufs->source.typeface = source.typeface.Native;
							break;
						}
					} else {
						value.IsNull = true;
					}
				}

				else if (v is PropertyPath) {
					PropertyPath propertypath = (PropertyPath) v;
					value.k = Kind.PROPERTYPATH;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedPropertyPath));

					UnmanagedPropertyPath *upp = (UnmanagedPropertyPath *) value.u.p;
					upp->property = propertypath.NativeDP;
					if (upp->property == IntPtr.Zero)
						upp->pathString = StringToIntPtr (propertypath.Path);
					else
						upp->pathString = IntPtr.Zero;
					upp->expandedPathString = IntPtr.Zero;
				}
				else if (v is Uri) {
					Uri uri = (Uri) v;

					value.k = Kind.URI;
					value.u.p = UnmanagedUri.FromUri (uri);
				}
				else if (v is XmlLanguage) {
					XmlLanguage lang = (XmlLanguage) v;
					
					value.k = Kind.STRING;
					
					value.u.p = StringToIntPtr (lang.IetfLanguageTag);
				}
				else if (v is Cursor) {
					Cursor c = (Cursor) v;

					value.k = Kind.CURSORTYPE;
					value.u.i32 = (int)c.cursor;
				}
				else if (v is GridLength) {
					GridLength gl = (GridLength) v;
					value.k = Kind.GRIDLENGTH;
					value.u.p = Marshal.AllocHGlobal (sizeof (GridLength));
					Marshal.StructureToPtr (gl, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is FontStretch) {
					FontStretch stretch = (FontStretch) v;
					value.k = Kind.FONTSTRETCH;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedFontStretch));
					Marshal.StructureToPtr (stretch, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is FontStyle) {
					FontStyle style = (FontStyle) v;
					value.k = Kind.FONTSTYLE;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedFontStyle));
					Marshal.StructureToPtr (style, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is FontWeight) {
					FontWeight weight = (FontWeight) v;
					value.k = Kind.FONTWEIGHT;
					value.u.p = Marshal.AllocHGlobal (sizeof (UnmanagedFontWeight));
					Marshal.StructureToPtr (weight, value.u.p, false); // Unmanaged and managed structure layout is equal.
				}
				else if (v is TextDecorationCollection) {
					value.k = Kind.TEXTDECORATIONS;
					value.u.i32 = (int) (v as TextDecorationCollection).Kind;
				}
				else if (v is Type) {
					Type t = v as Type;
					ManagedTypeInfo mti = new ManagedTypeInfo ();
					mti.full_name = StringToIntPtr (t.FullName);
					mti.Kind = Deployment.Current.Types.TypeToKind (t);

					value.k = Kind.MANAGEDTYPEINFO;
					value.u.p = Marshal.AllocHGlobal (sizeof (ManagedTypeInfo));
					Marshal.StructureToPtr (mti, value.u.p, false);
				}
				else {
					//Console.WriteLine ("Do not know how to encode {0} yet, boxing it", v.GetType ());

					// TODO: We probably need to marshal types that can animate as the 
					// corresponding type (Point, Double, Color, etc).
					// TODO: We need to store the GCHandle somewhere so that we can free it,
					// or register a callback on the surface for the unmanaged code to call.
					GCHandle handle = GCHandle.Alloc (v);
					value.IsGCHandle = true;
					value.k = Deployment.Current.Types.TypeToKind (v.GetType ());
					value.u.p = GCHandle.ToIntPtr (handle);
				}
			}
			return value;
		}
Example #26
0
		private unsafe bool TrySetEventReflection (XamlCallbackData *data, string xmlns, object publisher, string type_name, string name, Value* value_ptr, out string error)
		{
			object subscriber = null;
			EventInfo ie = publisher.GetType ().GetEvent (name);
			string handler_name = Value.ToObject (null, value_ptr) as string;

			try {
				subscriber = Value.ToObject (null, data->top_level);
			} catch {

			}
				
			//Console.WriteLine ("TrySetEventReflection ({0}, {1}, {2}, {3}, {4}, {5}) handler_name: {6}", data->top_level, xmlns, publisher, type_name, name, value_ptr, handler_name);
			
			if (ie == null) {
				error = "Event does not exist.";
				return false;
			}


			if (handler_name == null) {
				error = "No method name supplied for event handler.";
				return false;
			}

			MethodInfo invoker_info = ie.EventHandlerType.GetMethod ("Invoke");
			ParameterInfo [] event_params = invoker_info.GetParameters ();

			Delegate d = null;
			Type stype = subscriber.GetType ();
			MethodInfo [] methods = stype.GetMethods (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
			MethodInfo candidate = null;
			bool name_match = false;
			
			for (int i = 0; i < methods.Length; i++) {
				MethodInfo m = methods [i];
				ParameterInfo [] parameters;
				
				if (m.Name != handler_name)
					continue;

				if (name_match) {
					error = "Multiple candidates with the same name found for event handler.";
					// Console.WriteLine (error);
					return false;
				}

				name_match = true;

				if (m.ReturnType != typeof (void))
					continue;

				parameters = m.GetParameters ();

				if (parameters.Length != event_params.Length)
					continue;

				bool match = true;
				for (int p = 0; p < parameters.Length; p++) {
					if (!event_params [p].ParameterType.IsSubclassOf (parameters [p].ParameterType) && parameters [p].ParameterType != event_params [p].ParameterType) {
						Console.WriteLine ("mismatch:  {0}  and {1}", parameters [p].ParameterType, event_params [p].ParameterType);
						match = false;
						break;
					}
				}

				if (!match)
					continue;

				if (candidate != null) {
					error = "Multiple candidates for event handler found.";
					// Console.WriteLine (error);
					return false;
				}

				candidate = m;
			}

			if (candidate == null) {
				error = "Event handler not found.";
				// Console.WriteLine (error);
				return false;
			}

			d = Delegate.CreateDelegate (ie.EventHandlerType, subscriber, candidate, false);
			
			if (d == null) {
				Console.Error.WriteLine ("ManagedXamlLoader::HookupEvent ({0}, {1}, {2}): unable to create delegate (src={3} target={4}).", (IntPtr) data->top_level, name, (IntPtr)value_ptr, ie.EventHandlerType, publisher);
				error = "Can not create even delegate.";
				return false;
			}

			// Console.Error.WriteLine ("ManagedXamlLoader::HookupEvent ({0}, {1}, {2}): Successfully created delegate (src={3} target={4}).", (IntPtr) data->top_level, name, value_ptr, ie.EventHandlerType, publisher);
				
			error = null;
			ie.AddEventHandler (publisher, d);
			return true;
		}
Example #27
0
		///
		///
		/// Callbacks invoked by the xaml.cpp C++ parser
		///
		///

#region Callbacks from xaml.cpp
		//
		// Proxy so that we return IntPtr.Zero in case of any failures, instead of
		// genereting an exception and unwinding the stack.
		//
		private unsafe bool cb_lookup_object (XamlCallbackData *data, Value* parent, string xmlns, string name, bool create, bool is_property, out Value value, ref MoonError error)
		{
			value = Value.Empty;
			try {
				return LookupObject (data->top_level, parent, xmlns, name, create, is_property, out value);
			} catch (Exception ex) {
				NativeMethods.value_free_value (ref value);
				value = Value.Empty;
				Console.Error.WriteLine ("ManagedXamlLoader::LookupObject ({0}, {1}, {2}, {3}) failed: {3} ({4}).", (IntPtr) data->top_level, xmlns, create, name, ex.Message, ex.GetType ().FullName);
				Console.WriteLine (ex);
				error = new MoonError (ex);
				return false;
			}
		}
Example #28
0
		private unsafe bool TrySetEnumContentProperty (XamlCallbackData *data, string xmlns, object target, Value* target_ptr, IntPtr target_data, Value* value_ptr, IntPtr value_data)
		{
			object obj_value = Value.ToObject (null, value_ptr);
			string str_value = obj_value as string;

			if (str_value == null)
				return false;
			
			string assembly_name = AssemblyNameFromXmlns (xmlns);
			string clr_namespace = ClrNamespaceFromXmlns (xmlns);
			string type_name = NativeMethods.xaml_get_element_name (data->parser, target_data);
			string full_name = String.IsNullOrEmpty (clr_namespace) ? type_name : clr_namespace + "." + type_name;

			Type type = LookupType (data->top_level, assembly_name, full_name);

			if (type == null || !type.IsEnum)
				return false;

			object e = Enum.Parse (type, str_value, true);

			NativeMethods.value_free_value2 ((IntPtr)target_ptr);

			unsafe {
				Value *val = (Value *) target_ptr;

				GCHandle handle = GCHandle.Alloc (e);
				val->IsGCHandle = true;
				val->k = Deployment.Current.Types.TypeToKind (e.GetType ());
				val->u.p = GCHandle.ToIntPtr (handle);
			}

			return true;
		}
Example #29
0
		private unsafe bool TrySetCollectionContentProperty (string xmlns, object target, Value* target_ptr, IntPtr target_data, Value* value_ptr, IntPtr value_data)
		{
			IList list = target as IList;

			if (list == null)
				return false;

			object value = Value.ToObject (null, value_ptr);

			list.Add (value);
			return true;
		}
Example #30
0
File: Value.cs Project: shana/moon
		public static unsafe object ToObject (Type type, Value* value)
		{
			if (value == null || value->IsNull) {
				return null;
			}
			if (value->IsGCHandle) {
				IntPtr managed_object = value->u.p;
				GCHandle handle = GCHandle.FromIntPtr (managed_object);
				return handle.Target;
			}
			switch (value->k) {
			case Kind.INVALID:
				return null;
					
			case Kind.DEPENDENCYPROPERTY:
				return DependencyProperty.Lookup (value->u.p);
				
			case Kind.BOOL:
				return value->u.i32 != 0;

			case Kind.DOUBLE:
				return value->u.d;
					
			case Kind.FLOAT:
				return value->u.f;
					
			case Kind.UINT64:
				return value->u.ui64;
					
			case Kind.INT64:
				return value->u.i64;
					
			case Kind.TIMESPAN:
				return new TimeSpan (value->u.i64);
			case Kind.CURSORTYPE:
				return Cursors.FromEnum ((CursorType) value->u.i32);
			case Kind.TEXTDECORATIONS:
				return (value->u.i32 == (int) TextDecorationKind.Underline) ? TextDecorations.Underline : null;
			case Kind.INT32:
				return value->u.i32;
			case Kind.CHAR:
				return (char) value->u.ui32;

			case Kind.SURFACE:
				return NativeDependencyObjectHelper.FromIntPtr (value->u.p);

			case Kind.STRING: {
				string str = Marshal.PtrToStringAuto (value->u.p);
				if (type == null)
					return str;
				
				// marshall back to the .NET type that we simply serialised as 'string' for unmanaged usage
				if (type == typeof (System.Windows.Markup.XmlLanguage))
					return XmlLanguage.GetLanguage (str);
				else
					return str;
			}

			case Kind.URI: {
				UnmanagedUri *uri = (UnmanagedUri*)value->u.p;
				return uri->originalString == IntPtr.Zero
					? new Uri("", UriKind.Relative)
					: new Uri (Marshal.PtrToStringAuto (uri->originalString),
						   uri->isAbsolute ? UriKind.Absolute : UriKind.Relative);
			}

			case Kind.XMLLANGUAGE: {
				string str = Marshal.PtrToStringAuto (value->u.p);
				return XmlLanguage.GetLanguage (str);
			}

			case Kind.FONTFAMILY: {
				UnmanagedFontFamily *family = (UnmanagedFontFamily*)value->u.p;
				return new FontFamily (family == null ? null : Marshal.PtrToStringAuto (family->source));
			}

			case Kind.FONTSTRETCH: {
				UnmanagedFontStretch *stretch = (UnmanagedFontStretch*)value->u.p;
				return new FontStretch (stretch == null ? FontStretchKind.Normal : stretch->stretch);
			}

			case Kind.FONTSTYLE: {
				UnmanagedFontStyle *style = (UnmanagedFontStyle*)value->u.p;
				return new FontStyle (style == null ? FontStyleKind.Normal : style->style);
			}

			case Kind.FONTWEIGHT: {
				UnmanagedFontWeight *weight = (UnmanagedFontWeight*)value->u.p;
				return new FontWeight (weight == null ? FontWeightKind.Normal : weight->weight);
			}

			case Kind.FONTSOURCE: {
				UnmanagedFontSource *fs = (UnmanagedFontSource *) value->u.p;
				ManagedStreamCallbacks callbacks;
				GlyphTypeface typeface;
				StreamWrapper wrapper;
				
				switch (fs->type) {
				case FontSourceType.ManagedStream:
					callbacks = (ManagedStreamCallbacks) Marshal.PtrToStructure (fs->source.stream, typeof (ManagedStreamCallbacks));
					
					wrapper = (StreamWrapper) GCHandle.FromIntPtr (callbacks.handle).Target;
					
					return new FontSource (wrapper.stream);
				case FontSourceType.GlyphTypeface:
					typeface = new GlyphTypeface (fs->source.typeface);
					return new FontSource (typeface);
				default:
					throw new Exception (String.Format ("Do not know how to create a FontSource of type {0}",
									    fs->type.ToString ()));
				}
			}

			case Kind.GLYPHTYPEFACE: {
				return new GlyphTypeface (value->u.p);
			}

			case Kind.PROPERTYPATH: {
				UnmanagedPropertyPath *propertypath = (UnmanagedPropertyPath *) value->u.p;
				if (propertypath == null)
					return new PropertyPath (null);
				if (propertypath->property != IntPtr.Zero)
					return null;
				return new PropertyPath (Marshal.PtrToStringAuto (propertypath->pathString));
			}

			case Kind.POINT: {
				Point *point = (Point*)value->u.p;
				return (point == null) ? new Point (0,0) : *point;
			}
				
			case Kind.RECT: {
				Rect *rect = (Rect*)value->u.p;
				return (rect == null) ? new Rect (0,0,0,0) : *rect;
			}

			case Kind.SIZE: {
				Size *size = (Size*)value->u.p;
				return (size == null) ? new Size (0,0) : *size;
			}

			case Kind.CORNERRADIUS: {
				CornerRadius *corner = (CornerRadius*)value->u.p;
				return (corner == null) ? new CornerRadius (0) : *corner;
			}

			case Kind.AUDIOFORMAT: {
				UnmanagedAudioFormat *format = (UnmanagedAudioFormat*)value->u.p;
				return (format == null) ? new AudioFormat () : format->ToAudioFormat ();
			}

			case Kind.VIDEOFORMAT: {
				UnmanagedVideoFormat *format = (UnmanagedVideoFormat*)value->u.p;
				return (format == null) ? new VideoFormat () : format->ToVideoFormat ();
			}

			case Kind.THICKNESS: {
				Thickness *thickness = (Thickness*)value->u.p;
				return (thickness == null) ? new Thickness (0) : *thickness;
			}
					
			case Kind.COLOR: {
				UnmanagedColor *color = (UnmanagedColor*)value->u.p;
				if (color == null)
					return new Color ();
				return color->ToColor ();
			}

			case Kind.MATRIX:
			case Kind.UNMANAGEDMATRIX: {
				return new Matrix (value->u.p);
			}

			case Kind.MATRIX3D:
			case Kind.UNMANAGEDMATRIX3D: {
				return new Matrix3D (value->u.p);
			}

			case Kind.STYLUSPOINT:
			case Kind.UNMANAGEDSTYLUSPOINT: {
				var kind = value->k;
				var ptr = value->u.p;
				var x = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.XProperty.Native));
				var y = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.YProperty.Native));
				var pressure = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.PressureFactorProperty.Native));
				return new StylusPoint { X = x, Y = y, PressureFactor = (float) pressure };
			}

			case Kind.DURATION: {
				Duration* duration = (Duration*)value->u.p;
				return (duration == null) ? Duration.Automatic : *duration;
			}
					
			case Kind.KEYTIME: {
				KeyTime* keytime = (KeyTime*)value->u.p;
				return (keytime == null) ? KeyTime.FromTimeSpan (TimeSpan.Zero) : *keytime;
			}

			case Kind.GRIDLENGTH: {
				GridLength* gridlength = (GridLength*)value->u.p;
				return (gridlength == null) ? new GridLength () : *gridlength;
			}
					
			case Kind.REPEATBEHAVIOR: {
				RepeatBehavior *repeat = (RepeatBehavior*)value->u.p;
				return (repeat == null) ? new RepeatBehavior () : *repeat;
			}

			case Kind.MEDIAATTRIBUTE_COLLECTION: {
				MediaAttributeCollection attrs = (MediaAttributeCollection) NativeDependencyObjectHelper.Lookup (value->k, value->u.p);
				return attrs.AsDictionary ();
			}

			case Kind.MANAGEDTYPEINFO: {
				ManagedTypeInfo *type_info = (ManagedTypeInfo *) value->u.p;
				if (type_info == null)
					return null;
				return Deployment.Current.Types.KindToType (type_info->Kind);
			}
			default:
				Type tt = Deployment.Current.Types.KindToType (value->k);
				if (tt != null && tt.IsEnum)
					return Enum.ToObject (tt, value->u.i32);
				break;
			}

			if (NativeMethods.type_is_dependency_object (value->k)){
				if (value->u.p == IntPtr.Zero)
					return null;
					
				return NativeDependencyObjectHelper.Lookup (value->k, value->u.p);
			}

			throw new Exception (String.Format ("Do not know how to convert {0}  {1}. Managed type: {2}",
			                                    value->k, (int) value->k, Deployment.Current.Types.KindToType (value->k)));
		}
Example #31
0
		private unsafe bool TrySetObjectTextProperty (XamlCallbackData *data, string xmlns, object target, Value* target_ptr, IntPtr target_data, Value* value_ptr, IntPtr value_data)
		{
			object obj_value = Value.ToObject (null, value_ptr);
			string str_value = obj_value as string;

			if (str_value == null)
				return false;
			
			string assembly_name = AssemblyNameFromXmlns (xmlns);
			string clr_namespace = ClrNamespaceFromXmlns (xmlns);
			string type_name = NativeMethods.xaml_get_element_name (data->parser, target_data);
			string full_name = String.IsNullOrEmpty (clr_namespace) ? type_name : clr_namespace + "." + type_name;

			Type type = LookupType (data->top_level, assembly_name, full_name);

			if (type == null || type.IsSubclassOf (typeof (DependencyObject)))
				return false;

			// For now just trim the string right here, in the future this should probably be done in the xaml parser
			object e = ConvertType (null, type, str_value.Trim ());

			NativeMethods.value_free_value2 ((IntPtr)target_ptr);

			unsafe {
				Value *val = (Value *) target_ptr;

				GCHandle handle = GCHandle.Alloc (e);
				val->IsGCHandle = true;
				val->k = Deployment.Current.Types.TypeToKind (e.GetType ());
				val->u.p = GCHandle.ToIntPtr (handle);
			}

			return true;
		}
		public static void SetValue (INativeDependencyObjectWrapper wrapper, DependencyProperty dp, object value)
		{
			Type object_type;

			if (dp == null)
				throw new ArgumentNullException ("property");

			CheckNativeAndThread (wrapper);
			
			if (dp.DeclaringType != null && !dp.IsAttached) {
				if (!dp.DeclaringType.IsAssignableFrom (wrapper.GetType ()))
					throw new System.ArgumentException (string.Format ("The DependencyProperty '{2}', registered on type {0} can't be used to set a value on an object of type {1}", dp.DeclaringType.AssemblyQualifiedName, wrapper.GetType ().AssemblyQualifiedName, dp.Name));
			}
			
			if (value == null) {
				using (var val = new Value { k = NativeMethods.dependency_property_get_property_type(dp.Native), IsNull = true }) {
					var v = val;
					NativeMethods.dependency_object_set_value (wrapper.NativeHandle, dp.Native, ref v);
				}
				return;
			}

			if (value == DependencyProperty.UnsetValue) {
				// Setting to UnsetValue appears to be equivalent to ClearValue
				ClearValue (wrapper, dp);
				return;
			}

			// XXX we need this to work with all
			// INativeDependencyObjectWrapper, I expect..
			// but right now the only one other than DO is
			// Application, which doesn't have any
			// settable properties, so we're safe for now.
			if (wrapper is DependencyObject)
				dp.Validate ((DependencyObject)wrapper, dp, value);

			object_type = value.GetType ();

			bool type_valid = false;
			if (dp.PropertyType.IsGenericTypeDefinition) {
				Type t = object_type;
				while (t != null) {
					if (dp.PropertyType.IsAssignableFrom (t)) {
						type_valid = true;
						break;
					}

					if (t.IsGenericType && !t.IsGenericTypeDefinition)
						t = t.GetGenericTypeDefinition ();
					else
						t = t.BaseType;
				}
			}
			else {
				type_valid = dp.PropertyType.IsAssignableFrom (object_type);
			}

			if (!type_valid) {
				throw new ArgumentException (string.Format ("The DependencyProperty '{3}.{2}', whose property type is {0} can't be set to value whose type is {1}", dp.PropertyType.FullName, object_type.FullName, dp.Name, dp.DeclaringType.FullName));
			}
				                     
			using (var val = Value.FromObject (value, dp is CustomDependencyProperty)) {
				var v = val;
				NativeMethods.dependency_object_set_value (wrapper.NativeHandle, dp.Native, ref v);
			}
		}
Example #33
0
		private unsafe MethodInfo GetGetMethodForAttachedProperty (Value *top_level, string xmlns, string type_name, string full_type_name, string prop_name)
		{
			return GetMethodForAttachedProperty (top_level, xmlns, type_name, full_type_name, prop_name, "Get", new Type [] { typeof (DependencyObject) } );
		}