1 /* 2 * Copyright (C) 2009 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #ifndef WebNode_h 32 #define WebNode_h 33 34 #include "../platform/WebCommon.h" 35 #include "../platform/WebPrivatePtr.h" 36 #include "../platform/WebString.h" 37 #include "WebExceptionCode.h" 38 39 namespace WebCore { class Node; } 40 41 namespace blink { 42 class WebDOMEvent; 43 class WebDOMEventListener; 44 class WebDOMEventListenerPrivate; 45 class WebDocument; 46 class WebElement; 47 class WebFrame; 48 class WebNodeList; 49 class WebPluginContainer; 50 51 // Provides access to some properties of a DOM node. 52 // Note that the class design requires that neither this class nor any of its subclasses have any virtual 53 // methods (other than the destructor), so that it is possible to safely static_cast an instance of one 54 // class to the appropriate subclass based on the actual type of the wrapped WebCore::Node. For the same 55 // reason, subclasses must not add any additional data members. 56 class WebNode { 57 public: ~WebNode()58 virtual ~WebNode() { reset(); } 59 WebNode()60 WebNode() { } WebNode(const WebNode & n)61 WebNode(const WebNode& n) { assign(n); } 62 WebNode& operator=(const WebNode& n) 63 { 64 assign(n); 65 return *this; 66 } 67 68 BLINK_EXPORT void reset(); 69 BLINK_EXPORT void assign(const WebNode&); 70 71 BLINK_EXPORT bool equals(const WebNode&) const; 72 // Required for using WebNodes in std maps. Note the order used is 73 // arbitrary and should not be expected to have any specific meaning. 74 BLINK_EXPORT bool lessThan(const WebNode&) const; 75 isNull()76 bool isNull() const { return m_private.isNull(); } 77 78 enum NodeType { 79 ElementNode = 1, 80 AttributeNode = 2, 81 TextNode = 3, 82 CDataSectionNode = 4, 83 // EntityReferenceNodes are deprecated and impossible to create in WebKit. 84 EntityNode = 6, 85 ProcessingInstructionsNode = 7, 86 CommentNode = 8, 87 DocumentNode = 9, 88 DocumentTypeNode = 10, 89 DocumentFragmentNode = 11, 90 NotationNode = 12, 91 XPathNamespaceNode = 13, 92 ShadowRootNode = 14 93 }; 94 95 BLINK_EXPORT NodeType nodeType() const; 96 BLINK_EXPORT WebNode parentNode() const; 97 BLINK_EXPORT WebString nodeName() const; 98 BLINK_EXPORT WebString nodeValue() const; 99 BLINK_EXPORT WebDocument document() const; 100 BLINK_EXPORT WebNode firstChild() const; 101 BLINK_EXPORT WebNode lastChild() const; 102 BLINK_EXPORT WebNode previousSibling() const; 103 BLINK_EXPORT WebNode nextSibling() const; 104 BLINK_EXPORT bool hasChildNodes() const; 105 BLINK_EXPORT WebNodeList childNodes(); 106 BLINK_EXPORT WebString createMarkup() const; 107 BLINK_EXPORT bool isLink() const; 108 BLINK_EXPORT bool isTextNode() const; 109 BLINK_EXPORT bool isFocusable() const; 110 BLINK_EXPORT bool isContentEditable() const; 111 BLINK_EXPORT bool isElementNode() const; 112 // addEventListener only works with a small set of eventTypes. 113 BLINK_EXPORT void addEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture); 114 BLINK_EXPORT bool dispatchEvent(const WebDOMEvent&); 115 BLINK_EXPORT void simulateClick(); 116 BLINK_EXPORT WebNodeList getElementsByTagName(const WebString&) const; 117 BLINK_EXPORT WebElement querySelector(const WebString&, WebExceptionCode&) const; 118 BLINK_EXPORT WebElement rootEditableElement() const; 119 BLINK_EXPORT bool focused() const; 120 BLINK_EXPORT bool remove(); 121 122 // Returns true if the node has a non-empty bounding box in layout. 123 // This does not 100% guarantee the user can see it, but is pretty close. 124 // Note: This method only works properly after layout has occurred. 125 BLINK_EXPORT bool hasNonEmptyBoundingBox() const; 126 BLINK_EXPORT WebPluginContainer* pluginContainer() const; 127 BLINK_EXPORT WebElement shadowHost() const; 128 to()129 template<typename T> T to() 130 { 131 T res; 132 res.WebNode::assign(*this); 133 return res; 134 } 135 toConst()136 template<typename T> const T toConst() const 137 { 138 T res; 139 res.WebNode::assign(*this); 140 return res; 141 } 142 143 #if BLINK_IMPLEMENTATION 144 WebNode(const WTF::PassRefPtr<WebCore::Node>&); 145 WebNode& operator=(const WTF::PassRefPtr<WebCore::Node>&); 146 operator WTF::PassRefPtr<WebCore::Node>() const; 147 #endif 148 149 #if BLINK_IMPLEMENTATION unwrap()150 template<typename T> T* unwrap() 151 { 152 return static_cast<T*>(m_private.get()); 153 } 154 constUnwrap()155 template<typename T> const T* constUnwrap() const 156 { 157 return static_cast<const T*>(m_private.get()); 158 } 159 #endif 160 161 protected: 162 WebPrivatePtr<WebCore::Node> m_private; 163 }; 164 165 inline bool operator==(const WebNode& a, const WebNode& b) 166 { 167 return a.equals(b); 168 } 169 170 inline bool operator!=(const WebNode& a, const WebNode& b) 171 { 172 return !(a == b); 173 } 174 175 inline bool operator<(const WebNode& a, const WebNode& b) 176 { 177 return a.lessThan(b); 178 } 179 180 } // namespace blink 181 182 #endif 183