public void Dispose() { if (_self != null) { Release(); _self = null; } GC.SuppressFinalize(this); }
public static int is_editable(cef_domnode_t *self) { is_editable_delegate d; var p = self->_is_editable; if (p == _p6) { d = _d6; } else { d = (is_editable_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_editable_delegate)); if (_p6 == IntPtr.Zero) { _d6 = d; _p6 = p; } } return(d(self)); }
public static int release(cef_domnode_t *self) { release_delegate d; var p = self->_base._release; if (p == _p1) { d = _d1; } else { d = (release_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_delegate)); if (_p1 == IntPtr.Zero) { _d1 = d; _p1 = p; } } return(d(self)); }
public static int is_element(cef_domnode_t *self) { is_element_delegate d; var p = self->_is_element; if (p == _p5) { d = _d5; } else { d = (is_element_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_element_delegate)); if (_p5 == IntPtr.Zero) { _d5 = d; _p5 = p; } } return(d(self)); }
public static CefDomNodeType get_type(cef_domnode_t *self) { get_type_delegate d; var p = self->_get_type; if (p == _p3) { d = _d3; } else { d = (get_type_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_type_delegate)); if (_p3 == IntPtr.Zero) { _d3 = d; _p3 = p; } } return(d(self)); }
public static int has_one_ref(cef_domnode_t *self) { has_one_ref_delegate d; var p = self->_base._has_one_ref; if (p == _p2) { d = _d2; } else { d = (has_one_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_one_ref_delegate)); if (_p2 == IntPtr.Zero) { _d2 = d; _p2 = p; } } return(d(self)); }
public static void add_ref(cef_domnode_t *self) { add_ref_delegate d; var p = self->_base._add_ref; if (p == _p0) { d = _d0; } else { d = (add_ref_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(add_ref_delegate)); if (_p0 == IntPtr.Zero) { _d0 = d; _p0 = p; } } d(self); }
private void on_focused_node_changed(cef_render_process_handler_t *self, cef_browser_t *browser, cef_frame_t *frame, cef_domnode_t *node) { CheckSelf(self); var m_browser = CefBrowser.FromNative(browser); var m_frame = CefFrame.FromNative(frame); var m_node = CefDomNode.FromNativeOrNull(node); OnFocusedNodeChanged(m_browser, m_frame, m_node); if (m_node != null) { m_node.Dispose(); } }
/// <summary> /// Called for global uncaught exceptions in a frame. Execution of this /// callback is disabled by default. To enable set /// CefSettings.uncaught_exception_stack_size > 0. /// </summary> // protected abstract void OnUncaughtException(cef_browser_t* browser, cef_frame_t* frame, cef_v8context_t* context, cef_v8exception_t* exception, cef_v8stack_trace_t* stackTrace); private void on_focused_node_changed(cef_render_process_handler_t *self, cef_browser_t *browser, cef_frame_t *frame, cef_domnode_t *node) { CheckSelf(self); throw new NotImplementedException(); // TODO: CefRenderProcessHandler.OnFocusedNodeChanged }
/// <summary> /// Returns true if this object is pointing to the same handle as |that| /// object. /// </summary> public int IsSame(cef_domnode_t *that) { throw new NotImplementedException(); // TODO: CefDomNode.IsSame }
private CefDomNode(cef_domnode_t* ptr) { if (ptr == null) throw new ArgumentNullException("ptr"); _self = ptr; }
/// <summary> /// Called when a new node in the the browser gets focus. The |node| /// value may be empty if no specific node has gained focus. The node /// object passed to this method represents a snapshot of the DOM at the /// time this method is executed. DOM objects are only valid for the /// scope of this method. Do not keep references to or attempt to access /// any DOM objects outside the scope of this method. /// </summary> private void on_focused_node_changed(cef_focus_handler_t *self, cef_browser_t *browser, cef_frame_t *frame, cef_domnode_t *node) { ThrowIfObjectDisposed(); var mBrowser = CefBrowser.From(browser); var mFrame = CefFrame.From(frame); var mNode = CefDomNode.FromOrDefault(node); // TODO: DOM nodes context this.OnFocusedNodeChanged(mBrowser, mFrame, mNode); if (mNode != null) { mNode.Dispose(); } }
public unsafe extern int IsSame(cef_domnode_t *that);
public CefDOMNode(cef_domnode_t *instance) : base((cef_base_ref_counted_t *)instance) { }
public unsafe extern void OnFocusedNodeChanged(cef_browser_t *browser, cef_frame_t *frame, cef_domnode_t *node);
internal static CefDomNode FromNative(cef_domnode_t *ptr) { return(new CefDomNode(ptr)); }
public unsafe void OnFocusedNodeChanged(cef_browser_t *browser, cef_frame_t *frame, cef_domnode_t *node) { fixed(cef_render_process_handler_t *self = &this) { ((delegate * unmanaged[Stdcall] < cef_render_process_handler_t *, cef_browser_t *, cef_frame_t *, cef_domnode_t *, void >)on_focused_node_changed)(self, browser, frame, node); } }