Esempio n. 1
0
		public HeapRef (bool strong,
				INativeEventObjectWrapper referent,
				string name)
		{
			Strong = strong;
			Referent = referent;
			Name = name;
		}
Esempio n. 2
0
 public HeapRef(bool strong,
                INativeEventObjectWrapper referent,
                string name)
 {
     Strong   = strong;
     Referent = referent;
     Name     = name;
 }
Esempio n. 3
0
        public static void SetManagedPeerCallbacks(INativeEventObjectWrapper obj)
        {
            IRefContainer container = obj as IRefContainer;

            NativeMethods.event_object_set_managed_peer_callbacks(obj.NativeHandle,
                                                                  container == null ? null : NativeDependencyObjectHelper.add_strong_ref,
                                                                  container == null ? null : NativeDependencyObjectHelper.clear_strong_ref,
                                                                  NativeDependencyObjectHelper.mentor_changed);

            if (obj is INativeCollectionWrapper)
            {
                Events.AddHandler(obj, EventIds.Collection_ChangedEvent, native_collection_changed_callback);
            }
        }
Esempio n. 4
0
        /* thread-safe */
        public static bool AddNativeMapping(IntPtr native, INativeEventObjectWrapper wrapper)
        {
            if (native == IntPtr.Zero)
            {
                return(false);
            }

            NativeMethods.event_object_set_managed_handle(native, GCHandle.ToIntPtr(GCHandle.Alloc(wrapper, GCHandleType.Normal)));

#if DEBUG_REF
            Console.WriteLine("adding native mapping from {0:x} to {1}/{2}", (int)native, wrapper.GetHashCode(), wrapper.GetType());
#endif
            return(true);
        }
Esempio n. 5
0
        static void MentorChanged(IntPtr ptr, IntPtr mentor_ptr)
        {
            try {
                INativeEventObjectWrapper wrapper = NativeDependencyObjectHelper.Lookup(ptr);
                if (wrapper == null)
                {
                    return;
                }

                wrapper.MentorChanged(mentor_ptr);
            } catch (Exception ex) {
                try {
                    Console.WriteLine("Moonlight: Unhandled exception in NativeDependencyObjectHelper.MentorChanged: {0}", ex);
                } catch {
                }
            }
        }
Esempio n. 6
0
 public EventHandlerList(INativeEventObjectWrapper wrapper)
 {
 }
Esempio n. 7
0
		public EventObjectToggleRef (INativeEventObjectWrapper target)
			: base (target.NativeHandle, target)
		{
		}
		/* thread-safe */
		public static bool AddNativeMapping (IntPtr native, INativeEventObjectWrapper wrapper)
		{
			if (native == IntPtr.Zero)
				return false;

			NativeMethods.event_object_set_managed_handle (native, GCHandle.ToIntPtr (GCHandle.Alloc (wrapper, GCHandleType.Normal)));

#if DEBUG_REF
			Console.WriteLine ("adding native mapping from {0:x} to {1}/{2}", (int)native, wrapper.GetHashCode(), wrapper.GetType());
#endif
			return true;
		}
Esempio n. 9
0
 public void UnregisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler)
 {
     UnregisterEvent(obj.NativeHandle, eventId, managedHandler);
 }
Esempio n. 10
0
		public DependencyObjectHandle (IntPtr handle, INativeEventObjectWrapper wrapper)
		{
			Object = wrapper;
			Handle = handle;
		}
Esempio n. 11
0
 public void RegisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler, UnmanagedEventHandler nativeHandler)
 {
     RegisterEvent(obj, eventId, managedHandler, nativeHandler, false);
 }
Esempio n. 12
0
 /* thread-safe */
 public static void FreeNativeMapping(INativeEventObjectWrapper wrapper)
 {
     FreeNativeMapping(wrapper.NativeHandle);
 }
		/* thread-safe */
		public static void FreeNativeMapping (INativeEventObjectWrapper wrapper)
		{
			EventObjectToggleRef tref;
			IntPtr native = wrapper.NativeHandle;
			
			if (native == IntPtr.Zero)
				return;

			lock (objects) {
				if (objects.TryGetValue (native, out tref)) {
#if DEBUG_REF
					Console.WriteLine ("freeing native mapping for {0:x} - {1}/{2}", (int)native, wrapper.GetHashCode(), wrapper.GetType());
#endif
					objects.Remove (native);
				}
			}
			if (tref != null)
				tref.Free ();
			GC.SuppressFinalize (wrapper);
		}
Esempio n. 14
0
File: Events.cs Progetto: dfr0/moon
		public static void RemoveHandler (INativeEventObjectWrapper obj, int eventId, int token)
		{
			RemoveHandler (obj.NativeHandle, eventId, token);
		}
		public static void ClearManagedPeerCallbacks (INativeEventObjectWrapper obj)
		{
			NativeMethods.event_object_set_managed_peer_callbacks (obj.NativeHandle,
									       null, null,
									       null,
									       null, null);
		}
Esempio n. 16
0
File: Events.cs Progetto: dfr0/moon
		public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler, DestroyUnmanagedEvent dtor_action, bool handledEventsToo)
		{
			return AddHandler (obj.NativeHandle, eventId, handler, dtor_action, handledEventsToo);
		}
Esempio n. 17
0
File: Events.cs Progetto: dfr0/moon
		public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler)
		{
			return AddHandler (obj, eventId, handler, false);
		}
Esempio n. 18
0
 public DependencyObjectHandle(IntPtr handle, INativeEventObjectWrapper wrapper)
 {
     Object = wrapper;
     Handle = handle;
 }
Esempio n. 19
0
		public static void SetManagedPeerCallbacks (INativeEventObjectWrapper obj)
		{
			IRefContainer container = obj as IRefContainer;
			NativeMethods.event_object_set_managed_peer_callbacks (obj.NativeHandle,
									       container == null ? null : NativeDependencyObjectHelper.add_strong_ref,
									       container == null ? null : NativeDependencyObjectHelper.clear_strong_ref,
									       NativeDependencyObjectHelper.mentor_changed,
									       NativeDependencyObjectHelper.attached,
									       NativeDependencyObjectHelper.detached);
		}
Esempio n. 20
0
		public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler, GDestroyNotify dtor_action)
		{
			return AddHandler (obj.NativeHandle, eventId, handler, dtor_action);
		}
Esempio n. 21
0
		/* thread-safe */
		public static bool AddNativeMapping (IntPtr native, INativeEventObjectWrapper wrapper)
		{
			EventObjectToggleRef tref;
			
			if (native == IntPtr.Zero)
				return false;

			lock (objects) {
				if (objects.ContainsKey (native)) {
	#if DEBUG
					throw new ExecutionEngineException ("multiple mappings registered for the same unmanaged peer");
	#endif
					Console.WriteLine ("multiple mappings registered for the same unmanaged peer 0x{0:x}, type = {1}", native, wrapper.GetType());
					Console.WriteLine (Environment.StackTrace);
					return false;
				}
				
				tref = new EventObjectToggleRef (wrapper);
				objects[native] = tref;
			}
			tref.Initialize ();
			return true;
		}
		/* thread-safe */
		public static bool AddNativeMapping (IntPtr native, INativeEventObjectWrapper wrapper)
		{
			EventObjectToggleRef tref;
			
			if (native == IntPtr.Zero)
				return false;

			lock (objects) {
				if (objects.ContainsKey (native)) {
					Console.WriteLine ("multiple mappings registered for the same unmanaged peer 0x{0:x}, type = {1}", native, wrapper.GetType());
#if DEBUG
					throw new ExecutionEngineException (string.Format ("multiple mappings registered for the same unmanaged peer."));
#else
					return false;
#endif
				}
				
				tref = new EventObjectToggleRef (wrapper);

#if DEBUG_REF
				Console.WriteLine ("adding native mapping from {0:x} to {1}/{2}", (int)native, wrapper.GetHashCode(), wrapper.GetType());
#endif

				objects[native] = tref;
			}
			tref.Initialize ();
			return true;
		}
Esempio n. 23
0
		/* thread-safe */
		public static void FreeNativeMapping (INativeEventObjectWrapper wrapper)
		{
			EventObjectToggleRef tref;
			IntPtr native = wrapper.NativeHandle;
			
			if (native == IntPtr.Zero)
				return;
			
			lock (objects) {
				if (objects.TryGetValue (native, out tref))
					objects.Remove (native);
			}
			if (tref != null)
				tref.Free ();
			GC.SuppressFinalize (wrapper);
		}
Esempio n. 24
0
File: Value.cs Progetto: ynkbt/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 {
                if (box_value_types && (v is ValueType || v is string))
                {
                    value.boxed_valuetype = GCHandle.Alloc(v);
                }

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

                    value.u.p = StringToIntPtr((string)v);
                }
                else if (v is Rect)
                {
                    Rect rect = (Rect)v;
                    value.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind = 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);
                        upp->expandedPathString = StringToIntPtr(propertypath.ExpandedPath);
                    }
                    else
                    {
                        upp->pathString         = IntPtr.Zero;
                        upp->expandedPathString = IntPtr.Zero;
                    }
                }
                else if (v is Uri)
                {
                    Uri uri = (Uri)v;

                    value.Kind = Kind.URI;
                    value.u.p  = UriHelper.ToNativeUri(uri);
                }
                else if (v is XmlLanguage)
                {
                    XmlLanguage lang = (XmlLanguage)v;

                    value.Kind = Kind.XMLLANGUAGE;
                    value.u.p  = StringToIntPtr(lang.IetfLanguageTag);
                }
                else if (v is Cursor)
                {
                    Cursor c = (Cursor)v;

                    value.Kind  = Kind.CURSORTYPE;
                    value.u.i32 = (int)c.cursor;
                }
                else if (v is GridLength)
                {
                    GridLength gl = (GridLength)v;
                    value.Kind = 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.Kind = 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.Kind = 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.Kind = 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.Kind  = Kind.TEXTDECORATIONS;
                    value.u.i32 = (int)(v as TextDecorationCollection).Kind;
                }
                else if (v is Type)
                {
                    Type t = v as Type;
                    value.Kind = Kind.MANAGEDTYPEINFO;
                    value.u.p  = NativeMethods.managed_type_info_new(Deployment.Current.Types.TypeToKind(t));
                }
                else if (v is Value)
                {
                    throw new InvalidOperationException("You can not create a Mono.Value from a Mono.Value.");
                }
                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.Kind       = Deployment.Current.Types.TypeToKind(v.GetType());
                    value.u.p        = GCHandle.ToIntPtr(handle);
                }
            }
            return(value);
        }
Esempio n. 25
0
		public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler)
		{
			return AddHandler (obj.NativeHandle, eventId, handler);
		}
Esempio n. 26
0
File: Events.cs Progetto: ynkbt/moon
 public static int AddHandler(INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler)
 {
     return(AddHandler(obj, eventId, handler, false));
 }
Esempio n. 27
0
		public static void RemoveHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler)
		{
			RemoveHandler (obj.NativeHandle, eventId, handler);
		}
Esempio n. 28
0
File: Events.cs Progetto: ynkbt/moon
 public static int AddHandler(INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler, DestroyUnmanagedEvent dtor_action, bool handledEventsToo)
 {
     return(AddHandler(obj.NativeHandle, eventId, handler, dtor_action, handledEventsToo));
 }
Esempio n. 29
0
		public HeapRef (INativeEventObjectWrapper referent)
			: this (true, referent, "")
		{
		}
Esempio n. 30
0
File: Events.cs Progetto: ynkbt/moon
 public static void RemoveHandler(INativeEventObjectWrapper obj, int eventId, int token)
 {
     RemoveHandler(obj.NativeHandle, eventId, token);
 }
		public static void SetManagedPeerCallbacks (INativeEventObjectWrapper obj)
		{
			IRefContainer container = obj as IRefContainer;
			NativeMethods.event_object_set_managed_peer_callbacks (obj.NativeHandle,
									       container == null ? null : NativeDependencyObjectHelper.add_strong_ref,
									       container == null ? null : NativeDependencyObjectHelper.clear_strong_ref,
									       NativeDependencyObjectHelper.mentor_changed);

			if (obj is INativeCollectionWrapper)
				Events.AddHandler (obj, EventIds.Collection_ChangedEvent, native_collection_changed_callback);
		}
Esempio n. 32
0
 public HeapRef(INativeEventObjectWrapper referent)
     : this(true, referent, "")
 {
 }
		/* thread-safe */
		public static void FreeNativeMapping (INativeEventObjectWrapper wrapper)
		{
			FreeNativeMapping (wrapper.NativeHandle);
		}
Esempio n. 34
0
 public void RegisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler, UnmanagedEventHandler nativeHandler, bool handledEventsToo)
 {
     RegisterEvent(obj.NativeHandle, eventId, managedHandler, nativeHandler, handledEventsToo);
 }