static IntPtr NewObject(uint sizeofClosure, GISharp.GObject.Object @object) { if (@object == null) { throw new ArgumentNullException(nameof(@object)); } var ret = g_closure_new_object(sizeofClosure, @object.Handle); return(ret); }
static void UnmanagedNetworkChanged(IntPtr monitorPtr, bool available) { try { var monitor = (INetworkMonitor)Object.GetInstance(monitorPtr, Transfer.None); monitor.OnNetworkChanged(available); } catch (Exception ex) { ex.LogUnhandledException(); } }
static void UnmanagedCanReachAsyncFinish(IntPtr monitorPtr, IntPtr result, ref IntPtr errorPtr) { try { var monitor = (INetworkMonitor)Object.GetInstance(monitorPtr, Transfer.None); monitor.CanReachFinish(result); } catch (GErrorException ex) { GMarshal.PropagateError(errorPtr, ex.Error); } catch (Exception ex) { // FIXME: convert managed exception to GError ex.LogUnhandledException(); } }
static void UnmanagedCanReachAsync(IntPtr monitorPtr, IntPtr connectablePtr, IntPtr cancellablePtr, Action <IntPtr, IntPtr, IntPtr> callback, IntPtr userData) { try { var monitor = (INetworkMonitor)Object.GetInstance(monitorPtr, Transfer.None); Action <IntPtr> managedCallback = (result) => { callback(monitorPtr, result, userData); }; monitor.CanReachAsync(connectablePtr, cancellablePtr, managedCallback); } catch (Exception ex) { ex.LogUnhandledException(); } }
public static Object New(GType objectType, params object[] parameters) { IntPtr errorPtr; var ret_ = g_initable_newv(objectType, 0, IntPtr.Zero, IntPtr.Zero, out errorPtr); if (errorPtr != IntPtr.Zero) { var error = Opaque.GetInstance <Error> (errorPtr, Transfer.Full); throw new GErrorException(error); } var ret = Object.GetInstance(ret_, Transfer.Full); return(ret); }
static bool UnmanagedInit(IntPtr initablePtr, IntPtr cancellablePtr, ref IntPtr errorPtr) { try { var initable = (IInitable)Object.GetInstance(initablePtr, Transfer.None); var ret = initable.Init(cancellablePtr); return(ret); } catch (GErrorException ex) { GMarshal.PropagateError(errorPtr, ex.Error); } catch (Exception ex) { // FIXME: we should convert managed exception to GError ex.LogUnhandledException(); } return(false); }
static bool UnmanagedCanReach(IntPtr monitorPtr, IntPtr connectablePtr, IntPtr cancellablePtr, ref IntPtr errorPtr) { try { var monitor = (INetworkMonitor)Object.GetInstance(monitorPtr, Transfer.None); var ret = monitor.CanReach(connectablePtr, cancellablePtr); return(ret); } catch (GErrorException ex) { GMarshal.PropagateError(errorPtr, ex.Error); } catch (Exception ex) { // FIXME: convert managed exception to GError ex.LogUnhandledException(); } return(false); }
public void TestStopEmission() { bool stopEmission = false; int handler1Count = 0; int handler2Count = 0; using (var pspec = new ParamSpecBoolean("test-param", "test-param", "test-param", false, ParamFlags.Readwrite | ParamFlags.StaticStrings)) using (var obj = new Object()) { var id = Signal.TryLookup("notify", GType.Object); Assume.That(id, Is.Not.EqualTo(0)); Object.NotifyEventHandler handler1 = (s, e) => { handler1Count++; if (stopEmission) { obj.StopEmission(id); } }; Object.NotifyEventHandler handler2 = (s, e) => handler2Count++; obj.Notify += handler1; obj.Notify += handler2; // make sure our callbacks are working obj.Emit(id, 0, pspec); Assume.That(handler1Count, Is.EqualTo(1)); Assume.That(handler2Count, Is.EqualTo(1)); // now try to stop the emission stopEmission = true; obj.Emit(id, 0, pspec); Assert.That(handler1Count, Is.EqualTo(2)); Assert.That(handler2Count, Is.EqualTo(1)); } Utility.AssertNoGLibLog(); }
public void TestToggleRef() { WeakReference weakRef = null; new Action(() => weakRef = new WeakReference(new Object())).Invoke(); // first make sure our testing method is sane and Object is really GC'ed GC.Collect(); GC.WaitForPendingFinalizers(); Assume.That(weakRef.IsAlive, Is.False); // Now for the actual test. IntPtr handle = IntPtr.Zero; new Action(() => { var o = new Object(); weakRef = new WeakReference(o); // Simulate unmanaged code taking a reference. This should trigger // the toggle reference which prevents the object from being GC'ed handle = o.Handle; g_object_ref(handle); }).Invoke(); GC.Collect(); GC.WaitForPendingFinalizers(); Assert.That(weakRef.IsAlive, Is.True); // Simulates unmanaged code releasing the last reference. This should // free the GCHandle. g_object_unref(handle); GC.Collect(); GC.WaitForPendingFinalizers(); Assert.That(weakRef.IsAlive, Is.False); Utility.AssertNoGLibLog(); }
public void TestReferences() { using (var o1 = new Object()) { var handle = o1.Handle; // getting an object that already exists should return that object var o2 = Object.GetInstance(handle, Transfer.None); try { Assert.That(ReferenceEquals(o1, o2), Is.True); // Simulate unmanaged code taking a reference so that the handle is // not freed when o1 is disposed. g_object_ref(handle); // After an object is disposed we should get a new object rather // than the disposed object. o1.Dispose(); // Normally, we would not dispose an object if there is a possibility // that it could be used again because it will loose any state that // is stored in the managed object. Instead, a GCHandle will keep // the object alive as long as unmanaged code has a reference to the // object. // Transfer.All means the new object takes ownership of the reference // from the manual call to g_object_ref(), so we don't need to call // g_object_unref() manually. o2 = Object.GetInstance(handle, Transfer.Full); Assert.That(ReferenceEquals(o1, o2), Is.False); } finally { o2.Dispose(); } } Utility.AssertNoGLibLog(); }
/// <summary> /// A variant of g_closure_new_simple() which stores @object in the /// @data field of the closure and calls g_object_watch_closure() on /// @object and the created closure. This function is mainly useful /// when implementing new types of closures. /// </summary> /// <param name="object"> /// a #GObject pointer to store in the @data field of the newly /// allocated #GClosure /// </param> /// <returns> /// a newly allocated #GClosure /// </returns> public Closure(Func <object[], object> callback, GISharp.GObject.Object @object) : this(NewObject((uint)Marshal.SizeOf <ManagedClosure> (), @object), Transfer.None) { SetCallback(callback, ManagedClosureFuncCallback); }