/// <summary> /// DelegateObject __new__ implementation. The result of this is a new /// PyObject whose type is DelegateObject and whose ob_data is a handle /// to an actual delegate instance. The method wrapped by the actual /// delegate instance belongs to an object generated to relay the call /// to the Python callable passed in. /// </summary> public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw) { var self = (DelegateObject)GetManagedObject(tp); if (!self.type.Valid) { return(Exceptions.RaiseTypeError(self.type.DeletedMessage)); } Type type = self.type.Value; if (Runtime.PyTuple_Size(args) != 1) { return(Exceptions.RaiseTypeError("class takes exactly one argument")); } IntPtr method = Runtime.PyTuple_GetItem(args, 0); if (Runtime.PyCallable_Check(method) != 1) { return(Exceptions.RaiseTypeError("argument must be callable")); } Delegate d = PythonEngine.DelegateManager.GetDelegate(type, method); return(CLRObject.GetInstHandle(d, self.pyHandle)); }
/// <summary> /// DelegateObject __new__ implementation. The result of this is a new /// PyObject whose type is DelegateObject and whose ob_data is a handle /// to an actual delegate instance. The method wrapped by the actual /// delegate instance belongs to an object generated to relay the call /// to the Python callable passed in. /// </summary> public static NewReference tp_new(BorrowedReference tp, BorrowedReference args, BorrowedReference kw) { var self = (DelegateObject)GetManagedObject(tp) !; if (!self.type.Valid) { return(Exceptions.RaiseTypeError(self.type.DeletedMessage)); } Type type = self.type.Value; if (Runtime.PyTuple_Size(args) != 1) { return(Exceptions.RaiseTypeError("class takes exactly one argument")); } BorrowedReference method = Runtime.PyTuple_GetItem(args, 0); if (Runtime.PyCallable_Check(method) != 1) { return(Exceptions.RaiseTypeError("argument must be callable")); } Delegate d = PythonEngine.DelegateManager.GetDelegate(type, new PyObject(method)); return(CLRObject.GetReference(d, ClassManager.GetClass(type))); }
/// <summary> /// EventBinding += operator implementation. /// </summary> public static NewReference nb_inplace_add(BorrowedReference ob, BorrowedReference arg) { var self = (EventBinding)GetManagedObject(ob) !; if (Runtime.PyCallable_Check(arg) < 1) { Exceptions.SetError(Exceptions.TypeError, "event handlers must be callable"); return(default);
/// <summary> /// EventBinding -= operator implementation. /// </summary> public static IntPtr nb_inplace_subtract(IntPtr ob, IntPtr arg) { var self = (EventBinding)GetManagedObject(ob); if (Runtime.PyCallable_Check(arg) < 1) { Exceptions.SetError(Exceptions.TypeError, "invalid event handler"); return(IntPtr.Zero); } if (!self.e.RemoveEventHandler(self.target, arg)) { return(IntPtr.Zero); } Runtime.XIncref(self.pyHandle); return(self.pyHandle); }
public static IntPtr nb_inplace_add(IntPtr ob, IntPtr arg) { EventBinding self = (EventBinding)GetManagedObject(ob); if (Runtime.PyCallable_Check(arg) < 1) { Exceptions.SetError(Exceptions.TypeError, "event handlers must be callable" ); return(IntPtr.Zero); } if (!self.e.AddEventHandler(self.target, arg)) { return(IntPtr.Zero); } Runtime.Incref(self.pyHandle); return(self.pyHandle); }
public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw) { DelegateObject self = (DelegateObject)GetManagedObject(tp); if (Runtime.PyTuple_Size(args) != 1) { string message = "class takes exactly one argument"; return(Exceptions.RaiseTypeError(message)); } IntPtr method = Runtime.PyTuple_GetItem(args, 0); if (Runtime.PyCallable_Check(method) != 1) { return(Exceptions.RaiseTypeError("argument must be callable")); } Delegate d = DelegateManager.GetDelegate(self.type, method); return(CLRObject.GetInstHandle(d, self.pyHandle)); }
/// <summary> /// IsCallable Method /// </summary> /// <remarks> /// Returns true if the object is a callable object. This method /// always succeeds. /// </remarks> public bool IsCallable() { return(Runtime.PyCallable_Check(obj) != 0); }