public HeapRef (bool strong, INativeEventObjectWrapper referent, string name) { Strong = strong; Referent = referent; Name = name; }
public HeapRef(bool strong, INativeEventObjectWrapper referent, string name) { Strong = strong; Referent = referent; Name = name; }
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); } }
/* 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); }
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 { } } }
public EventHandlerList(INativeEventObjectWrapper wrapper) { }
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; }
public void UnregisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler) { UnregisterEvent(obj.NativeHandle, eventId, managedHandler); }
public DependencyObjectHandle (IntPtr handle, INativeEventObjectWrapper wrapper) { Object = wrapper; Handle = handle; }
public void RegisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler, UnmanagedEventHandler nativeHandler) { RegisterEvent(obj, eventId, managedHandler, nativeHandler, false); }
/* 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); }
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); }
public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler, DestroyUnmanagedEvent dtor_action, bool handledEventsToo) { return AddHandler (obj.NativeHandle, eventId, handler, dtor_action, handledEventsToo); }
public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler) { return AddHandler (obj, eventId, handler, false); }
public DependencyObjectHandle(IntPtr handle, INativeEventObjectWrapper wrapper) { Object = wrapper; Handle = handle; }
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); }
public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler, GDestroyNotify dtor_action) { return AddHandler (obj.NativeHandle, eventId, handler, dtor_action); }
/* 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; }
/* 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); }
// // 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); }
public static int AddHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler) { return AddHandler (obj.NativeHandle, eventId, handler); }
public static int AddHandler(INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler) { return(AddHandler(obj, eventId, handler, false)); }
public static void RemoveHandler (INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandler handler) { RemoveHandler (obj.NativeHandle, eventId, handler); }
public static int AddHandler(INativeEventObjectWrapper obj, int eventId, UnmanagedEventHandlerInvoker handler, DestroyUnmanagedEvent dtor_action, bool handledEventsToo) { return(AddHandler(obj.NativeHandle, eventId, handler, dtor_action, handledEventsToo)); }
public HeapRef (INativeEventObjectWrapper referent) : this (true, referent, "") { }
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); }
public HeapRef(INativeEventObjectWrapper referent) : this(true, referent, "") { }
/* thread-safe */ public static void FreeNativeMapping (INativeEventObjectWrapper wrapper) { FreeNativeMapping (wrapper.NativeHandle); }
public void RegisterEvent(INativeEventObjectWrapper obj, int eventId, Delegate managedHandler, UnmanagedEventHandler nativeHandler, bool handledEventsToo) { RegisterEvent(obj.NativeHandle, eventId, managedHandler, nativeHandler, handledEventsToo); }