FromIntPtr() static private method

static private FromIntPtr ( IntPtr ptr ) : INativeEventObjectWrapper
ptr System.IntPtr
return INativeEventObjectWrapper
Exemplo n.º 1
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateRoutedEventHandlerDispatcher(RoutedEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => { object o = NativeDependencyObjectHelper.FromIntPtr(closure);
                                handler(o,
                                        NativeDependencyObjectHelper.FromIntPtr(calldata) as RoutedEventArgs ?? new RoutedEventArgs(calldata, false)); }));
 }
Exemplo n.º 2
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateCaptureFormatChangedEventArgsEventHandlerDispatcher(EventHandler <CaptureFormatChangedEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => { object o = NativeDependencyObjectHelper.FromIntPtr(closure);
                                CaptureFormatChangedEventArgs args = new CaptureFormatChangedEventArgs(calldata);
                                handler(o, args); }));
 }
Exemplo n.º 3
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateCaptureImageCompletedEventArgsEventHandlerDispatcher(EventHandler <CaptureImageCompletedEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => {
         handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                 (CaptureImageCompletedEventArgs)NativeDependencyObjectHelper.Lookup(calldata) ?? new CaptureImageCompletedEventArgs(calldata, CaptureImageCompletedEventArgs.GetExceptionFromUnmanaged(calldata), false));
     }));
 }
Exemplo n.º 4
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateExceptionRoutedEventArgsEventHandlerDispatcher(EventHandler <ExceptionRoutedEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => { object o = NativeDependencyObjectHelper.FromIntPtr(closure);
                                ExceptionRoutedEventArgs args = ExceptionRoutedEventArgs.FromErrorEventArgs(calldata);
                                args.OriginalSource = o;
                                handler(o, args); }));
 }
Exemplo n.º 5
0
Arquivo: Events.cs Projeto: ynkbt/moon
        public static UnmanagedEventHandler CreateSendCompletedEventArgsEventHandlerDispatcher(EventHandler <SendCompletedEventArgs> handler)
        {
            return(SafeDispatcher((sender, calldata, closure)
                                  => {
                Exception exc = SendCompletedEventArgsGetError(calldata);

                handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                        (SendCompletedEventArgs)NativeDependencyObjectHelper.Lookup(calldata) ?? new SendCompletedEventArgs(calldata, exc, false));
            }));
        }
Exemplo n.º 6
0
 static void DestroyUnmanagedEventCallback(IntPtr dep_ob, int event_id, int token)
 {
     try {
         var ob = (INativeEventObjectWrapper)NativeDependencyObjectHelper.FromIntPtr(dep_ob);
         if (ob != null)
         {
             ob.EventList.RemoveHandler(event_id, token);
         }
     } catch (Exception ex) {
         try {
             Console.WriteLine("Unhandled exception in EventHandlerList.DestroyUnmanagedEventCallback");
         } catch {
         }
     }
 }
Exemplo n.º 7
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateSizeChangedEventHandlerDispatcher(SizeChangedEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      NativeDependencyObjectHelper.FromIntPtr(calldata) as SizeChangedEventArgs ?? new SizeChangedEventArgs(calldata))));
 }
Exemplo n.º 8
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateTextCompositionEventHandlerDispatcher(TextCompositionEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      NativeDependencyObjectHelper.FromIntPtr(calldata) as TextCompositionEventArgs ?? new TextCompositionEventArgs(calldata, false))));
 }
Exemplo n.º 9
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateLogReadyRoutedEventHandlerDispatcher(LogReadyRoutedEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      NativeDependencyObjectHelper.FromIntPtr(calldata) as LogReadyRoutedEventArgs ?? new LogReadyRoutedEventArgs(calldata, false))));
 }
Exemplo n.º 10
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateClosingEventArgsEventHandlerDispatcher(EventHandler <ClosingEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      new ClosingEventArgs())));
 }
Exemplo n.º 11
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateLoadCompletedEventHandlerDispatcher(LoadCompletedEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      new NavigationEventArgs())));
 }
Exemplo n.º 12
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateMessageReceivedEventArgsEventHandlerDispatcher(EventHandler <MessageReceivedEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      new MessageReceivedEventArgs(calldata, false))));
 }
Exemplo n.º 13
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateCursorPositionChangedEventHandlerDispatcher(CursorPositionChangedEventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      new CursorPositionChangedEventArgs(calldata))));
 }
Exemplo n.º 14
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateDownloadProgressEventArgsEventHandlerDispatcher(EventHandler <DownloadProgressEventArgs> handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      new DownloadProgressEventArgs(calldata))));
 }
Exemplo n.º 15
0
Arquivo: Events.cs Projeto: ynkbt/moon
 public static UnmanagedEventHandler CreateEventHandlerDispatcher(EventHandler handler)
 {
     return(SafeDispatcher((sender, calldata, closure)
                           => handler(NativeDependencyObjectHelper.FromIntPtr(closure),
                                      EventArgs.Empty)));
 }
Exemplo n.º 16
0
Arquivo: Value.cs Projeto: ynkbt/moon
        public static unsafe object ToObject(Type type, Value *value)
        {
            if (value == null || value->IsNull)
            {
                return(null);
            }

            if (value->boxed_valuetype.IsAllocated)
            {
                return(value->boxed_valuetype.Target);
            }

            if (value->IsGCHandle)
            {
                IntPtr   managed_object = value->u.p;
                GCHandle handle         = GCHandle.FromIntPtr(managed_object);
                return(handle.Target);
            }

            switch (value->Kind)
            {
            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.UINT32:
                return(value->u.ui32);

            case Kind.CHAR:
                return((char)value->u.ui32);

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

            case Kind.STRING: {
                return(Marshal.PtrToStringAuto(value->u.p));
            }

            case Kind.URI:
                return(UriHelper.FromNativeUri(value->u.p));

            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), Marshal.PtrToStringAuto(propertypath->expandedPathString)));
            }

            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->Kind;
                var ptr      = value->u.p;
                var x        = (double)Value.ToObject(typeof(double), NativeMethods.dependency_object_get_value(ptr, UnmanagedStylusPoint.XProperty.Native));
                var y        = (double)Value.ToObject(typeof(double), NativeMethods.dependency_object_get_value(ptr, UnmanagedStylusPoint.YProperty.Native));
                var pressure = (double)Value.ToObject(typeof(double), NativeMethods.dependency_object_get_value(ptr, 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: {
                IntPtr p = value->u.p;
                if (p == IntPtr.Zero)
                {
                    return(null);
                }

                int count = NativeMethods.collection_get_count(p);
                var dict  = new Dictionary <string, string> ();
                for (int i = 0; i < count; i++)
                {
                    IntPtr map = NativeMethods.collection_get_value_at(p, i);
                    if (map == IntPtr.Zero)
                    {
                        continue;
                    }
                    Value *attribute = (Value *)map;
                    if (attribute->Kind != Kind.MEDIAATTRIBUTE || attribute->u.p == IntPtr.Zero)
                    {
                        continue;
                    }
                    string name = NativeMethods.media_attribute_get_name(attribute->u.p);
                    string val  = NativeMethods.media_attribute_get_value(attribute->u.p);

                    dict.Add(name, val);
                }
                return(dict);
            }

            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->Kind);
                if (tt != null && tt.IsEnum)
                {
                    return(Enum.ToObject(tt, value->u.i32));
                }
                break;
            }

            if (NativeMethods.type_is_event_object(value->Kind))
            {
                if (value->u.p == IntPtr.Zero)
                {
                    return(null);
                }

                return(NativeDependencyObjectHelper.Lookup(value->u.p));
            }

            throw new Exception(String.Format("Do not know how to convert {0}  {1}. Managed type: {2}",
                                              value->Kind, (int)value->Kind, Deployment.Current.Types.KindToType(value->Kind)));
        }