protected override void Dispose (bool disposing)
{
if (!disposed) {
if (disposing) {
this.resources.Clear ();
this.node = null;
}
}
base.Dispose(disposing);
}
Boolean nsITooltipTextProvider.GetNodeText(nsIDOMNode aNode, out String aText)
{
WebBrowser browser = GetBrowserFromDomDocument(aNode.OwnerDocument);
if (browser == null)
{
aText = null;
return false;
}
var e = new ProvideTooltipTextEventArgs(aNode);
browser.Events.Raise(EventKey.ProvideTooltipText, e);
aText = e.TooltipText;
return String.IsNullOrWhiteSpace(e.TooltipText);
}
internal static DomNode Create(nsIDOMNode domNode)
{
if (domNode == null)
{
return null;
}
switch (domNode.NodeType)
{
case nsIDOMNodeConstants.ELEMENT_NODE:
return DomElement.Create((nsIDOMElement)domNode);
case nsIDOMNodeConstants.ATTRIBUTE_NODE:
return DomAttribute.Create((nsIDOMAttr)domNode);
case nsIDOMNodeConstants.TEXT_NODE:
return DomText.Create((nsIDOMText)domNode);
case nsIDOMNodeConstants.CDATA_SECTION_NODE:
return DomCDataSection.Create((nsIDOMCDATASection)domNode);
case nsIDOMNodeConstants.ENTITY_REFERENCE_NODE:
return DomEntityReference.Create((nsIDOMEntityReference)domNode);
case nsIDOMNodeConstants.ENTITY_NODE:
return DomEntity.Create((nsIDOMEntity)domNode);
case nsIDOMNodeConstants.PROCESSING_INSTRUCTION_NODE:
return DomProcessingInstruction.Create((nsIDOMProcessingInstruction)domNode);
case nsIDOMNodeConstants.COMMENT_NODE:
return DomComment.Create((nsIDOMComment)domNode);
case nsIDOMNodeConstants.DOCUMENT_NODE:
return DomDocument.Create((nsIDOMDocument)domNode);
case nsIDOMNodeConstants.DOCUMENT_TYPE_NODE:
return DomDocumentType.Create((nsIDOMDocumentType)domNode);
case nsIDOMNodeConstants.DOCUMENT_FRAGMENT_NODE:
return DomDocumentFragment.Create((nsIDOMDocumentFragment)domNode);
case nsIDOMNodeConstants.NOTATION_NODE:
return DomNotation.Create((nsIDOMNotation)domNode);
}
return new DomNode(domNode);
}
internal static GeckoNode CreateWrapper(nsIDOMNode domObject)
{
if (domObject == null)
return null;
nsIDOMHTMLElement element = Xpcom.QueryInterface<nsIDOMHTMLElement>(domObject);
if (element != null)
return GeckoElement.Create(element);
nsIDOMAttr attr = Xpcom.QueryInterface<nsIDOMAttr>(domObject);
if (attr != null)
return GeckoAttribute.Create(attr);
nsIDOMComment comment = domObject as nsIDOMComment;
if (comment != null)
return GeckoComment.Create(comment);
return new GeckoNode(domObject);
}
public void SerializeToStream(nsIDOMNode root, nsISupports stream, string charset)
{
this.CallVoidMethod("serializeToStream", root, stream, charset);
}
internal GeckoNode(nsIDOMNode domObject)
{
//ComDebug.WriteDebugInfo( domObject );
_domNode = new ComPtr<nsIDOMNode>( domObject );
}
public void Observe(nsIDOMNode target, object options)
{
this.CallVoidMethod("observe", target, options);
}
public bool OnClientMouseOver (MouseInfo mouseInfo, ModifierKeys modifiers, nsIDOMNode target)
{
#if debug
OnGeneric ("OnClientMouseOver");
Console.Error.WriteLine ("OnClientMouseOver");
#endif
DOM.DOMObject helper = new DOM.DOMObject(this.owner);
INode node = helper.GetTypedNode (target);
string key = String.Intern (node.GetHashCode () + ":mouseover");
EventHandler eh1 = (EventHandler) owner.DomEvents[key];
if (eh1 != null) {
EventArgs e1 = new EventArgs ();
eh1 (node, e1);
}
NodeEventHandler eh = (NodeEventHandler) (owner.Events[WebBrowser.MouseEnterEvent]);
if (eh != null) {
NodeEventArgs e = new NodeEventArgs (node);
eh (node, e);
return true;
}
return false;
}
public void InitMutationEvent(string type, bool canBubble, bool cancelable, nsIDOMNode relatedNode, string prevValue, string newValue, string attrName, ushort attrChange)
{
this.CallVoidMethod("initMutationEvent", type, canBubble, cancelable, relatedNode, prevValue, newValue, attrName, attrChange);
}
internal static GeckoNode Create(nsIDOMNode domObject)
{
return(m_nodeCache.Get(domObject));
}
public void SetEndAfter(nsIDOMNode refNode)
{
this.CallVoidMethod("setEndAfter", refNode);
}
internal ContextMenuEventArgs(ContextMenuContext context, nsIDOMEvent domEvent, nsIDOMNode domNode)
{
m_Context = context;
m_DomEvent = DomEvent.Create(domEvent);
m_DomNode = DomNode.Create(domNode);
}
public void Extend(nsIDOMNode node, uint offset)
{
this.CallVoidMethod("extend", node, offset);
}
internal DomNode(nsIDOMNode domNode)
{
m_DomNode = domNode;
}
public void Collapse(nsIDOMNode node, uint offset)
{
this.CallVoidMethod("collapse", node, offset);
}
public nsISupports[] GetRangesForInterval(nsIDOMNode beginNode, int beginOffset, nsIDOMNode endNode, int endOffset, bool allowAdjacent)
{
return(this.CallMethod <nsISupports[]>("GetRangesForInterval", beginNode, beginOffset, endNode, endOffset, allowAdjacent));
}
public bool ContainsNode(nsIDOMNode node, bool allowPartialContainment)
{
return(this.CallMethod <bool>("containsNode", node, allowPartialContainment));
}
internal GeckoNode(nsIDOMNode domObject)
{
_DomObject = domObject;
}
public ushort AcceptNode(nsIDOMNode node)
{
return(this.CallMethod <ushort>("acceptNode", node));
}
public void SelectAllChildren(nsIDOMNode node)
{
this.CallVoidMethod("selectAllChildren", node);
}
public Node (WebBrowser control, nsIDOMNode domNode) : base (control)
{
this.control = control;
this.node = domNode;
}
public string SerializeToString(nsIDOMNode root)
{
return(this.CallMethod <string>("serializeToString", root));
}
public void ImportStylesheet(nsIDOMNode style)
{
this.CallVoidMethod("importStylesheet", style);
}
internal GeckoNode(nsIDOMNode domObject)
{
_DomObject = domObject;
}
public nsISupports TransformToFragment(nsIDOMNode source, nsIDOMDocument output)
{
return(this.CallMethod <nsISupports>("transformToFragment", source, output));
}
public void InitMutationEvent(string type, bool canBubble, bool cancelable, nsIDOMNode relatedNode, string prevValue)
{
this.CallVoidMethod("initMutationEvent", type, canBubble, cancelable, relatedNode, prevValue);
}
public nsIDOMDocument TransformToDocument(nsIDOMNode source)
{
return(this.CallMethod <nsIDOMDocument>("transformToDocument", source));
}
internal GeckoNode(nsIDOMNode domObject)
{
//ComDebug.WriteDebugInfo( domObject );
_domNode = new ComPtr <nsIDOMNode>(domObject);
}
public void SelectNode(nsIDOMNode refNode)
{
this.CallVoidMethod("selectNode", refNode);
}
public void Observe(nsIDOMNode target)
{
this.CallVoidMethod("observe", target);
}
public void SelectNodeContents(nsIDOMNode refNode)
{
this.CallVoidMethod("selectNodeContents", refNode);
}
internal Mono.WebBrowser.DOM.INode GetTypedNode (nsIDOMNode obj)
{
if (obj == null)
return null;
obj.getLocalName (storage);
ushort type;
obj.getNodeType (out type);
switch (type) {
case (ushort)NodeType.Element:
#if DEBUG
Console.Write (Base.StringGet (storage) + ":Getting typed object from NodeType.Element:");
#endif
if (obj is Mono.Mozilla.nsIDOMHTMLBodyElement) {
#if DEBUG
Console.WriteLine ("HTMLElement-nsIDOMHTMLBodyElement");
#endif
return new HTMLElement (control, obj as nsIDOMHTMLBodyElement);
}
else if (obj is Mono.Mozilla.nsIDOMHTMLStyleElement) {
#if DEBUG
Console.WriteLine ("HTMLElement-nsIDOMHTMLStyleElement");
#endif
return new HTMLElement (control, obj as nsIDOMHTMLStyleElement);
}
else if (obj is nsIDOMHTMLElement) {
#if DEBUG
Console.WriteLine ("HTMLElement-nsIDOMHTMLElement");
#endif
return new HTMLElement (control, obj as nsIDOMHTMLElement);
}
#if DEBUG
Console.WriteLine ("HTMLElement-nsIDOMHTMLElement");
#endif
return new Element (control, obj as nsIDOMElement);
break;
case (ushort)NodeType.Attribute:
return new Attribute (control, obj as nsIDOMAttr);
break;
case (ushort)NodeType.Document:
if (obj is nsIDOMHTMLDocument)
return new Document (control, obj as nsIDOMHTMLDocument);
return new Document (control, obj as nsIDOMDocument);
break;
case (ushort)NodeType.Text:
case (ushort)NodeType.CDataSection:
case (ushort)NodeType.EntityReference:
case (ushort)NodeType.Entity:
case (ushort)NodeType.ProcessingInstruction:
case (ushort)NodeType.Comment:
case (ushort)NodeType.DocumentType:
case (ushort)NodeType.DocumentFragment:
case (ushort)NodeType.Notation:
default:
return new Node (control, obj);
break;
}
}
public void InsertNode(nsIDOMNode node)
{
this.CallVoidMethod("insertNode", node);
}
public bool OnClientMouseOut (MouseInfo mouseInfo, ModifierKeys modifiers, nsIDOMNode target)
{
#if debug
OnGeneric ("OnClientMouseOut");
Console.Error.WriteLine ("OnClientMouseOut");
#endif
INode node = new Mono.Mozilla.DOM.Node (owner, target);
string key = String.Intern (node.GetHashCode () + ":mouseout");
EventHandler eh1 = (EventHandler) owner.DomEvents[key];
if (eh1 != null) {
EventArgs e1 = new EventArgs ();
eh1 (node, e1);
}
NodeEventHandler eh = (NodeEventHandler) (owner.Events[WebBrowser.MouseLeaveEvent]);
if (eh != null) {
NodeEventArgs e = new NodeEventArgs (node);
eh (this, e);
return true;
}
return false;
}
public void SurroundContents(nsIDOMNode newParent)
{
this.CallVoidMethod("surroundContents", newParent);
}
private void Recurse (HTMLElementCollection col, nsIDOMNode parent) {
nsIDOMNodeList children;
parent.getChildNodes (out children);
uint count;
children.getLength (out count);
for (int i = 0; i < count;i++) {
nsIDOMNode node;
children.item ((uint)i, out node);
ushort type;
node.getNodeType (out type);
if (type == (ushort)NodeType.Element) {
col.Add (new HTMLElement (control, (nsIDOMHTMLElement)node));
Recurse (col, node);
}
}
}
public bool IsPointInRange(nsIDOMNode node, uint offset)
{
return(this.CallMethod <bool>("isPointInRange", node, offset));
}
public static nsIDOMNode GetProxy (Mono.WebBrowser.IWebBrowser control, nsIDOMNode obj)
{
object o = Base.GetProxyForObject (control, typeof(nsIDOMNode).GUID, obj);
return o as nsIDOMNode;
}
public short ComparePoint(nsIDOMNode node, uint offset)
{
return(this.CallMethod <short>("comparePoint", node, offset));
}
internal static GeckoNode Create(nsIDOMNode domObject)
{
return m_nodeCache.Get(domObject);
}
public bool IntersectsNode(nsIDOMNode node)
{
return(this.CallMethod <bool>("intersectsNode", node));
}
void nsIContextMenuListener.OnShowContextMenu(UInt32 aContextFlags, nsIDOMEvent aEvent, nsIDOMNode aNode)
{
var e = new ContextMenuEventArgs((ContextMenuContext)aContextFlags, aEvent, aNode);
Events.Raise(EventKey.ShowContextMenu, e);
}
public void SetEnd(nsIDOMNode refNode, uint offset)
{
this.CallVoidMethod("setEnd", refNode, offset);
}
public void SetEndBefore(nsIDOMNode refNode)
{
this.CallVoidMethod("setEndBefore", refNode);
}
internal ProvideTooltipTextEventArgs(nsIDOMNode domNode)
{
m_DomNode = DomNode.Create(domNode);
}
