516 lines
14 KiB
C#
Executable File
516 lines
14 KiB
C#
Executable File
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
// Copyright (c) 2007, 2008 Novell, Inc.
|
|
//
|
|
// Authors:
|
|
// Andreia Gaita (avidigal@novell.com)
|
|
//
|
|
|
|
using System;
|
|
using System.Text;
|
|
using System.ComponentModel;
|
|
using System.Runtime.InteropServices;
|
|
using System.Collections;
|
|
using Mono.WebBrowser;
|
|
using Mono.WebBrowser.DOM;
|
|
|
|
namespace Mono.Mozilla.DOM
|
|
{
|
|
internal class Node: DOMObject, INode
|
|
{
|
|
internal nsIDOMNode nodeNoProxy;
|
|
private nsIDOMNode _node;
|
|
internal nsIDOMNode node {
|
|
get { return _node; }
|
|
set {
|
|
hashcode = value.GetHashCode ();
|
|
nodeNoProxy = _node;
|
|
if (!(value is nsIDOMHTMLDocument) && control.platform != control.enginePlatform)
|
|
_node = nsDOMNode.GetProxy (control, value);
|
|
else
|
|
_node = value;
|
|
}
|
|
}
|
|
|
|
protected int hashcode;
|
|
private EventListener eventListener;
|
|
private WebBrowser control;
|
|
|
|
public Node (WebBrowser control, nsIDOMNode domNode) : base (control)
|
|
{
|
|
this.control = control;
|
|
this.node = domNode;
|
|
}
|
|
|
|
#region IDisposable Members
|
|
protected override void Dispose (bool disposing)
|
|
{
|
|
if (!disposed) {
|
|
if (disposing) {
|
|
this.resources.Clear ();
|
|
this.node = null;
|
|
}
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Internal
|
|
internal virtual nsIDOMNode XPComObject
|
|
{
|
|
get { return node; }
|
|
}
|
|
#endregion
|
|
|
|
#region INode Members
|
|
public virtual IAttributeCollection Attributes
|
|
{
|
|
get
|
|
{
|
|
if (!resources.Contains ("Attributes")) {
|
|
nsIDOMNamedNodeMap attributes;
|
|
this.node.getAttributes (out attributes);
|
|
if (attributes == null)
|
|
return new AttributeCollection (control);
|
|
resources.Add ("Attributes", new AttributeCollection (control, attributes));
|
|
}
|
|
return resources["Attributes"] as IAttributeCollection;
|
|
}
|
|
}
|
|
|
|
public virtual INodeList ChildNodes {
|
|
get {
|
|
if (!resources.Contains ("ChildNodes")) {
|
|
nsIDOMNodeList children;
|
|
this.node.getChildNodes (out children);
|
|
resources.Add ("ChildNodes", new NodeList (control, children));
|
|
}
|
|
return resources["ChildNodes"] as INodeList;
|
|
}
|
|
}
|
|
|
|
|
|
public virtual INode FirstChild {
|
|
get {
|
|
if (!resources.Contains ("FirstChild")) {
|
|
nsIDOMNode child;
|
|
node.getFirstChild (out child);
|
|
resources.Add ("FirstChild", GetTypedNode (child));
|
|
}
|
|
return resources["FirstChild"] as INode;
|
|
}
|
|
}
|
|
|
|
public virtual INode LastChild {
|
|
get {
|
|
if (!resources.Contains ("LastChild")) {
|
|
nsIDOMNode child;
|
|
this.node.getLastChild (out child);
|
|
resources.Add ("LastChild", GetTypedNode (child));
|
|
}
|
|
return resources["LastChild"] as INode;
|
|
}
|
|
}
|
|
|
|
public virtual INode Parent {
|
|
get {
|
|
if (!resources.Contains ("Parent")) {
|
|
nsIDOMNode parent;
|
|
this.node.getParentNode (out parent);
|
|
resources.Add ("Parent", GetTypedNode (parent));
|
|
}
|
|
return resources["Parent"] as INode;
|
|
}
|
|
}
|
|
|
|
public virtual INode Previous {
|
|
get {
|
|
if (!resources.Contains ("Previous")) {
|
|
nsIDOMNode child;
|
|
this.node.getPreviousSibling (out child);
|
|
resources.Add ("Previous", GetTypedNode (child));
|
|
}
|
|
return resources["Previous"] as INode;
|
|
}
|
|
}
|
|
|
|
public virtual INode Next {
|
|
get {
|
|
if (!resources.Contains ("Next")) {
|
|
nsIDOMNode child;
|
|
this.node.getNextSibling (out child);
|
|
resources.Add ("Next", GetTypedNode (child));
|
|
}
|
|
return resources["Next"] as INode;
|
|
}
|
|
}
|
|
|
|
|
|
public virtual string LocalName {
|
|
get {
|
|
this.node.getLocalName (storage);
|
|
return Base.StringGet (storage);
|
|
}
|
|
}
|
|
|
|
public IDocument Owner {
|
|
get {
|
|
nsIDOMDocument doc;
|
|
this.node.getOwnerDocument (out doc);
|
|
if (!control.documents.ContainsKey (doc.GetHashCode ()))
|
|
control.documents.Add (doc.GetHashCode (), new Document (control, doc as Mono.Mozilla.nsIDOMHTMLDocument));
|
|
return control.documents[doc.GetHashCode ()] as IDocument;
|
|
}
|
|
}
|
|
|
|
public string Style {
|
|
get {
|
|
nsIDOMDocument doc;
|
|
this.node.getOwnerDocument (out doc);
|
|
nsIDOMDocumentView docView = (nsIDOMDocumentView) doc;
|
|
nsIDOMAbstractView abstractView;
|
|
docView.getDefaultView (out abstractView);
|
|
nsIDOMViewCSS viewCss = (nsIDOMViewCSS)abstractView;
|
|
Base.StringSet (storage, String.Empty);
|
|
nsIDOMCSSStyleDeclaration styleDecl;
|
|
AsciiString s = new Mono.Mozilla.AsciiString(String.Empty);
|
|
viewCss.getComputedStyle (this.node as Mono.Mozilla.nsIDOMElement, s.Handle, out styleDecl);
|
|
if (styleDecl == null)
|
|
return "";
|
|
styleDecl.getCssText (storage);
|
|
return Base.StringGet (storage);
|
|
}
|
|
set {
|
|
nsIDOMDocument doc;
|
|
this.node.getOwnerDocument (out doc);
|
|
nsIDOMDocumentView docView = (nsIDOMDocumentView) doc;
|
|
nsIDOMAbstractView abstractView;
|
|
docView.getDefaultView (out abstractView);
|
|
nsIDOMViewCSS viewCss = (nsIDOMViewCSS)abstractView;
|
|
Base.StringSet (storage, String.Empty);
|
|
nsIDOMCSSStyleDeclaration styleDecl;
|
|
viewCss.getComputedStyle (this.node as Mono.Mozilla.nsIDOMElement, storage, out styleDecl);
|
|
Base.StringSet (storage, value);
|
|
styleDecl.setCssText (storage);
|
|
}
|
|
}
|
|
|
|
public virtual Mono.WebBrowser.DOM.NodeType Type {
|
|
get {
|
|
ushort type;
|
|
this.node.getNodeType (out type);
|
|
return (Mono.WebBrowser.DOM.NodeType) Enum.ToObject (typeof (Mono.WebBrowser.DOM.NodeType), type);
|
|
}
|
|
}
|
|
|
|
public virtual string Value {
|
|
get
|
|
{
|
|
this.node.getNodeValue (storage);
|
|
return Base.StringGet (storage);
|
|
}
|
|
set {
|
|
Base.StringSet (storage, value);
|
|
node.setNodeValue (storage);
|
|
}
|
|
}
|
|
|
|
public virtual IntPtr AccessibleObject {
|
|
get {
|
|
nsIAccessible access = null;
|
|
try {
|
|
nsIAccessibilityService serv = control.AccessibilityService;
|
|
nsIDOMDocument doc;
|
|
this.node.getOwnerDocument (out doc);
|
|
serv.getAccessibleFor (doc, out access);
|
|
} catch (Mono.WebBrowser.Exception ex) {
|
|
Console.Error.WriteLine (ex.Message);
|
|
goto no_accessibility;
|
|
} catch (System.Exception ex) {
|
|
Console.Error.WriteLine (ex.Message);
|
|
goto no_accessibility;
|
|
}
|
|
|
|
if (access == null) {
|
|
goto no_accessibility;
|
|
}
|
|
IntPtr ptr = IntPtr.Zero;
|
|
if (access.getNativeInterface (out ptr) != 0) {
|
|
goto no_accessibility;
|
|
}
|
|
return ptr;
|
|
|
|
no_accessibility: {
|
|
Console.Error.WriteLine ("Accessibility not available");
|
|
return IntPtr.Zero;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
public virtual void FireEvent (string eventName)
|
|
{
|
|
nsIDOMDocument doc;
|
|
this.node.getOwnerDocument (out doc);
|
|
|
|
nsIDOMDocumentEvent docEvent = (nsIDOMDocumentEvent) doc;
|
|
nsIDOMDocumentView docView = (nsIDOMDocumentView) doc;
|
|
nsIDOMAbstractView abstractView;
|
|
docView.getDefaultView (out abstractView);
|
|
nsIDOMEventTarget target = (nsIDOMEventTarget) this.node;
|
|
bool ret = false;
|
|
|
|
string eventType;
|
|
switch (eventName) {
|
|
case "mousedown":
|
|
case "mouseup":
|
|
case "click":
|
|
case "dblclick":
|
|
case "mouseover":
|
|
case "mouseout":
|
|
case "mousemove":
|
|
case "contextmenu":
|
|
eventType = "mouseevents";
|
|
nsIDOMEvent evtMouse;
|
|
Base.StringSet (storage, eventType);
|
|
docEvent.createEvent (storage, out evtMouse);
|
|
nsIDOMMouseEvent domEventMouse = evtMouse as nsIDOMMouseEvent;
|
|
Base.StringSet (storage, eventName);
|
|
domEventMouse.initMouseEvent (storage, true, true, abstractView, 1, 0, 0, 0, 0, false, false, false, false, 0, target);
|
|
target.dispatchEvent (domEventMouse, out ret);
|
|
break;
|
|
case "keydown":
|
|
case "keyup":
|
|
case "keypress":
|
|
eventType = "keyevents";
|
|
nsIDOMEvent evtKey;
|
|
Base.StringSet (storage, eventType);
|
|
docEvent.createEvent (storage, out evtKey);
|
|
Base.StringSet (storage, eventName);
|
|
nsIDOMKeyEvent domEventKey = evtKey as nsIDOMKeyEvent;
|
|
domEventKey.initKeyEvent (storage, true, true, abstractView, false, false, false, false, 0, 0);
|
|
target.dispatchEvent (domEventKey, out ret);
|
|
break;
|
|
case "DOMActivate":
|
|
case "DOMFocusIn":
|
|
case "DOMFocusOut":
|
|
case "input":
|
|
eventType = "uievents";
|
|
nsIDOMEvent evtUI;
|
|
Base.StringSet (storage, eventType);
|
|
docEvent.createEvent (storage, out evtUI);
|
|
Base.StringSet (storage, eventName);
|
|
nsIDOMUIEvent domEventUI = evtUI as nsIDOMUIEvent;
|
|
domEventUI.initUIEvent (storage, true, true, abstractView, 1);
|
|
target.dispatchEvent (domEventUI, out ret);
|
|
break;
|
|
case "focus":
|
|
case "blur":
|
|
case "submit":
|
|
case "reset":
|
|
case "change":
|
|
case "select":
|
|
case "load":
|
|
case "beforeunload":
|
|
case "unload":
|
|
case "abort":
|
|
case "error":
|
|
default:
|
|
eventType = "events";
|
|
nsIDOMEvent domEvent;
|
|
Base.StringSet (storage, eventType);
|
|
docEvent.createEvent (storage, out domEvent);
|
|
Base.StringSet (storage, eventName);
|
|
domEvent.initEvent (storage, true, true);
|
|
target.dispatchEvent (domEvent, out ret);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
public virtual INode InsertBefore (INode child, INode refChild) {
|
|
nsIDOMNode newChild;
|
|
node.insertBefore (((Node) child).node, ((Node) refChild).node, out newChild);
|
|
return child;
|
|
}
|
|
|
|
public virtual INode ReplaceChild (INode child, INode oldChild) {
|
|
nsIDOMNode replaced;
|
|
node.replaceChild (((Node)child).node, ((Node)oldChild).node, out replaced);
|
|
return oldChild;
|
|
}
|
|
|
|
public virtual INode RemoveChild (INode child) {
|
|
nsIDOMNode removedChild;
|
|
node.removeChild (((Node)child).node, out removedChild);
|
|
return child;
|
|
}
|
|
|
|
public virtual INode AppendChild (INode child) {
|
|
nsIDOMNode newChild;
|
|
int ret = node.appendChild (((Node)child).node, out newChild);
|
|
Console.Error.WriteLine (ret);
|
|
return child;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public override bool Equals (object obj)
|
|
{
|
|
return this == obj as Node;
|
|
}
|
|
|
|
public static bool operator == (Node left, Node right)
|
|
{
|
|
if ((object)left == (object)right)
|
|
return true;
|
|
|
|
if ((object)left == null || (object)right == null)
|
|
return false;
|
|
|
|
return left.hashcode == right.hashcode;
|
|
}
|
|
|
|
public static bool operator != (Node left, Node right)
|
|
{
|
|
return !(left == right);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return this.hashcode;
|
|
}
|
|
|
|
#region Events
|
|
|
|
private EventListener EventListener {
|
|
get {
|
|
if (eventListener == null)
|
|
eventListener = new EventListener (this.node as nsIDOMEventTarget, this);
|
|
return eventListener;
|
|
}
|
|
}
|
|
|
|
public void AttachEventHandler (string eventName, EventHandler handler)
|
|
{
|
|
EventListener.AddHandler (handler, eventName);
|
|
}
|
|
|
|
public void DetachEventHandler (string eventName, EventHandler handler)
|
|
{
|
|
EventListener.RemoveHandler (handler, eventName);
|
|
}
|
|
|
|
private EventHandlerList events;
|
|
public EventHandlerList Events {
|
|
get {
|
|
if (events == null)
|
|
events = new EventHandlerList ();
|
|
return events;
|
|
}
|
|
}
|
|
|
|
public void AttachEventHandler (string eventName, System.Delegate handler)
|
|
{
|
|
string key = String.Intern (node.GetHashCode() + ":" + eventName);
|
|
Events.AddHandler (key, handler);
|
|
}
|
|
|
|
public void DetachEventHandler (string eventName, System.Delegate handler)
|
|
{
|
|
string key = String.Intern (node.GetHashCode() + ":" + eventName);
|
|
Events.RemoveHandler (key, handler);
|
|
}
|
|
|
|
public event NodeEventHandler Click
|
|
{
|
|
add { EventListener.AddHandler (value, "click"); }
|
|
remove { EventListener.RemoveHandler (value, "click"); }
|
|
}
|
|
|
|
public event NodeEventHandler DoubleClick
|
|
{
|
|
add { EventListener.AddHandler (value, "dblclick"); }
|
|
remove { EventListener.RemoveHandler (value, "dblclick"); }
|
|
}
|
|
public event NodeEventHandler KeyDown
|
|
{
|
|
add { EventListener.AddHandler (value, "keydown"); }
|
|
remove { EventListener.RemoveHandler (value, "keydown"); }
|
|
}
|
|
public event NodeEventHandler KeyPress
|
|
{
|
|
add { EventListener.AddHandler (value, "keypress"); }
|
|
remove { EventListener.RemoveHandler (value, "keypress"); }
|
|
}
|
|
public event NodeEventHandler KeyUp
|
|
{
|
|
add { EventListener.AddHandler (value, "keyup"); }
|
|
remove { EventListener.RemoveHandler (value, "keyup"); }
|
|
}
|
|
public event NodeEventHandler MouseDown
|
|
{
|
|
add { EventListener.AddHandler (value, "mousedown"); }
|
|
remove { EventListener.RemoveHandler (value, "mousedown"); }
|
|
}
|
|
public event NodeEventHandler MouseEnter
|
|
{
|
|
add { EventListener.AddHandler (value, "mouseenter"); }
|
|
remove { EventListener.RemoveHandler (value, "mouseenter"); }
|
|
}
|
|
public event NodeEventHandler MouseLeave
|
|
{
|
|
add { EventListener.AddHandler (value, "mouseout"); }
|
|
remove { EventListener.RemoveHandler (value, "mouseout"); }
|
|
}
|
|
public event NodeEventHandler MouseMove
|
|
{
|
|
add { EventListener.AddHandler (value, "mousemove"); }
|
|
remove { EventListener.RemoveHandler (value, "mousemove"); }
|
|
}
|
|
public event NodeEventHandler MouseOver
|
|
{
|
|
add { EventListener.AddHandler (value, "mouseover"); }
|
|
remove { EventListener.RemoveHandler (value, "mouseover"); }
|
|
}
|
|
public event NodeEventHandler MouseUp
|
|
{
|
|
add { EventListener.AddHandler (value, "mouseup"); }
|
|
remove { EventListener.RemoveHandler (value, "mouseup"); }
|
|
}
|
|
public event NodeEventHandler OnFocus
|
|
{
|
|
add { EventListener.AddHandler (value, "focus"); }
|
|
remove { EventListener.RemoveHandler (value, "focus"); }
|
|
}
|
|
public event NodeEventHandler OnBlur
|
|
{
|
|
add { EventListener.AddHandler (value, "blur"); }
|
|
remove { EventListener.RemoveHandler (value, "blur"); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|