Reviewed by Chris Blumenberg.
authordarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 May 2005 16:48:51 +0000 (16:48 +0000)
committerdarin <darin@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 May 2005 16:48:51 +0000 (16:48 +0000)
        - more "getting off the C++ DOM wrappers" changes
          This pass involves replacing uses of DOM::Range with use of DOM::RangeImpl
          plus some more use of DOM::DocumentImpl instead of DOM::Document.

        * khtml/dom/dom2_range.cpp:
        * khtml/dom/dom2_range.h:
        * khtml/ecma/kjs_window.cpp:
        (KJS::Window::get):
        (KJS::WindowFunc::tryCall):
        (KJS::Window::updateLayout):
        (KJS::ScheduledAction::execute):
        (KJS::Selection::toString):
        * khtml/ecma/xmlhttprequest.cpp:
        (KJS::XMLHttpRequestProtoFunc::tryCall):
        * khtml/editing/htmlediting.cpp:
        (khtml::InsertLineBreakCommand::doApply):
        * khtml/editing/selection.cpp:
        (khtml::Selection::Selection):
        (khtml::Selection::moveTo):
        (khtml::Selection::toRange):
        * khtml/editing/selection.h:
        * khtml/editing/visible_position.cpp:
        (khtml::makeRange):
        (khtml::startVisiblePosition):
        (khtml::endVisiblePosition):
        (khtml::setStart):
        (khtml::setEnd):
        * khtml/editing/visible_position.h:
        * khtml/editing/visible_range.h:
        * khtml/editing/visible_text.cpp:
        (khtml::TextIterator::TextIterator):
        (khtml::TextIterator::range):
        (khtml::SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator):
        (khtml::SimplifiedBackwardsTextIterator::range):
        (khtml::CharacterIterator::CharacterIterator):
        (khtml::CharacterIterator::range):
        (khtml::WordAwareIterator::WordAwareIterator):
        (khtml::WordAwareIterator::advance):
        (khtml::TextIterator::rangeLength):
        (khtml::TextIterator::rangeFromLocationAndLength):
        (khtml::plainText):
        (khtml::findPlainText):
        * khtml/editing/visible_text.h:
        (khtml::WordAwareIterator::range):
        * khtml/editing/visible_units.cpp:
        (khtml::previousBoundary):
        (khtml::nextBoundary):
        * khtml/html/html_elementimpl.cpp:
        (HTMLElementImpl::innerText):
        * khtml/html/htmltokenizer.cpp:
        (khtml::HTMLTokenizer::scriptExecution):
        * khtml/khtml_part.cpp:
        (KHTMLPart::text):
        (KHTMLPart::selectedText):
        (KHTMLPart::shouldBeginEditing):
        (KHTMLPart::shouldEndEditing):
        (KHTMLPart::selectionComputedStyle):
        * khtml/khtml_part.h:
        * khtml/khtmlview.h:
        * khtml/rendering/render_text.cpp:
        (InlineTextBox::paint):
        * khtml/xml/dom2_rangeimpl.cpp:
        (DOM::operator==):
        (DOM::rangeOfContents):
        * khtml/xml/dom2_rangeimpl.h:
        (DOM::operator!=):
        * khtml/xml/dom_docimpl.cpp:
        (DocumentImpl::relinquishesEditingFocus):
        (DocumentImpl::acceptsEditingFocus):
        (DocumentImpl::addMarker):
        (DocumentImpl::removeMarker):
        * khtml/xml/dom_docimpl.h:
        * khtml/xml/dom_position.cpp:
        (DOM::startPosition):
        * khtml/xml/dom_position.h:
        * kwq/DOMHTML.mm:
        (-[DOMHTMLLinkElement href]):
        (-[DOMHTMLBaseElement href]):
        (-[DOMHTMLInputElement src]):
        (-[DOMHTMLAnchorElement href]):
        (-[DOMHTMLImageElement src]):
        (-[DOMHTMLAreaElement href]):
        * kwq/KWQAccObject.mm:
        (-[KWQAccObject textUnderElement]):
        (-[KWQAccObject value]):
        (-[KWQAccObject doAXStringForTextMarkerRange:]):
        (-[KWQAccObject doAXAttributedStringForTextMarkerRange:]):
        * kwq/KWQKHTMLPart.h:
        (KWQKHTMLPart::markedTextRange):
        * kwq/KWQKHTMLPart.mm:
        (KWQKHTMLPart::findString):
        (KWQKHTMLPart::advanceToNextMisspelling):
        (KWQKHTMLPart::fontForSelection):
        (KWQKHTMLPart::markMisspellings):
        (KWQKHTMLPart::respondToChangedSelection):
        (KWQKHTMLPart::shouldBeginEditing):
        (KWQKHTMLPart::shouldEndEditing):
        (convertAttributesToUnderlines):
        (KWQKHTMLPart::setMarkedTextRange):
        * kwq/WebCoreBridge.mm:
        (-[WebCoreBridge elementAtPoint:]):
        (-[WebCoreBridge rangeByExpandingSelectionWithGranularity:]):
        (-[WebCoreBridge rangeByAlteringCurrentSelection:direction:granularity:]):
        (-[WebCoreBridge rangeByAlteringCurrentSelection:verticalDistance:]):
        (-[WebCoreBridge selectedDOMRange]):
        (-[WebCoreBridge convertToNSRange:DOM::]):
        (-[WebCoreBridge convertToDOMRange:]):
        (-[WebCoreBridge convertToObjCDOMRange:]):
        (-[WebCoreBridge selectNSRange:]):
        (-[WebCoreBridge selectedNSRange]):
        (-[WebCoreBridge markDOMRange]):
        (-[WebCoreBridge markedTextDOMRange]):
        (-[WebCoreBridge markedTextNSRange]):
        (-[WebCoreBridge replaceMarkedTextWithText:]):
        (-[WebCoreBridge smartDeleteRangeForProposedRange:]):
        (-[WebCoreBridge dragCaretDOMRange]):
        (-[WebCoreBridge editableDOMRangeForPoint:]):
        (-[WebCoreBridge rangeOfCharactersAroundCaret]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@9169 268f45cc-cd09-0410-ab3c-d52691b4dbfc

33 files changed:
WebCore/ChangeLog-2005-08-23
WebCore/khtml/dom/dom2_range.cpp
WebCore/khtml/dom/dom2_range.h
WebCore/khtml/ecma/kjs_window.cpp
WebCore/khtml/ecma/xmlhttprequest.cpp
WebCore/khtml/editing/SelectionController.cpp
WebCore/khtml/editing/SelectionController.h
WebCore/khtml/editing/htmlediting.cpp
WebCore/khtml/editing/selection.cpp
WebCore/khtml/editing/selection.h
WebCore/khtml/editing/visible_position.cpp
WebCore/khtml/editing/visible_position.h
WebCore/khtml/editing/visible_range.h
WebCore/khtml/editing/visible_text.cpp
WebCore/khtml/editing/visible_text.h
WebCore/khtml/editing/visible_units.cpp
WebCore/khtml/html/html_elementimpl.cpp
WebCore/khtml/html/htmltokenizer.cpp
WebCore/khtml/khtml_part.cpp
WebCore/khtml/khtml_part.h
WebCore/khtml/khtmlview.h
WebCore/khtml/rendering/render_text.cpp
WebCore/khtml/xml/dom2_rangeimpl.cpp
WebCore/khtml/xml/dom2_rangeimpl.h
WebCore/khtml/xml/dom_docimpl.cpp
WebCore/khtml/xml/dom_docimpl.h
WebCore/khtml/xml/dom_position.cpp
WebCore/khtml/xml/dom_position.h
WebCore/kwq/DOMHTML.mm
WebCore/kwq/KWQAccObject.mm
WebCore/kwq/KWQKHTMLPart.h
WebCore/kwq/KWQKHTMLPart.mm
WebCore/kwq/WebCoreBridge.mm

index 8ec43a3aaa959bdff0383a4e79ae280785473afd..e73add9aac59958183acccf4cfb574da1bb07cca 100644 (file)
@@ -1,3 +1,126 @@
+2005-05-12  Darin Adler  <darin@apple.com>
+
+        Reviewed by Chris Blumenberg.
+
+        - more "getting off the C++ DOM wrappers" changes
+          This pass involves replacing uses of DOM::Range with use of DOM::RangeImpl
+          plus some more use of DOM::DocumentImpl instead of DOM::Document.
+
+        * khtml/dom/dom2_range.cpp:
+        * khtml/dom/dom2_range.h:
+        * khtml/ecma/kjs_window.cpp:
+        (KJS::Window::get):
+        (KJS::WindowFunc::tryCall):
+        (KJS::Window::updateLayout):
+        (KJS::ScheduledAction::execute):
+        (KJS::Selection::toString):
+        * khtml/ecma/xmlhttprequest.cpp:
+        (KJS::XMLHttpRequestProtoFunc::tryCall):
+        * khtml/editing/htmlediting.cpp:
+        (khtml::InsertLineBreakCommand::doApply):
+        * khtml/editing/selection.cpp:
+        (khtml::Selection::Selection):
+        (khtml::Selection::moveTo):
+        (khtml::Selection::toRange):
+        * khtml/editing/selection.h:
+        * khtml/editing/visible_position.cpp:
+        (khtml::makeRange):
+        (khtml::startVisiblePosition):
+        (khtml::endVisiblePosition):
+        (khtml::setStart):
+        (khtml::setEnd):
+        * khtml/editing/visible_position.h:
+        * khtml/editing/visible_range.h:
+        * khtml/editing/visible_text.cpp:
+        (khtml::TextIterator::TextIterator):
+        (khtml::TextIterator::range):
+        (khtml::SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator):
+        (khtml::SimplifiedBackwardsTextIterator::range):
+        (khtml::CharacterIterator::CharacterIterator):
+        (khtml::CharacterIterator::range):
+        (khtml::WordAwareIterator::WordAwareIterator):
+        (khtml::WordAwareIterator::advance):
+        (khtml::TextIterator::rangeLength):
+        (khtml::TextIterator::rangeFromLocationAndLength):
+        (khtml::plainText):
+        (khtml::findPlainText):
+        * khtml/editing/visible_text.h:
+        (khtml::WordAwareIterator::range):
+        * khtml/editing/visible_units.cpp:
+        (khtml::previousBoundary):
+        (khtml::nextBoundary):
+        * khtml/html/html_elementimpl.cpp:
+        (HTMLElementImpl::innerText):
+        * khtml/html/htmltokenizer.cpp:
+        (khtml::HTMLTokenizer::scriptExecution):
+        * khtml/khtml_part.cpp:
+        (KHTMLPart::text):
+        (KHTMLPart::selectedText):
+        (KHTMLPart::shouldBeginEditing):
+        (KHTMLPart::shouldEndEditing):
+        (KHTMLPart::selectionComputedStyle):
+        * khtml/khtml_part.h:
+        * khtml/khtmlview.h:
+        * khtml/rendering/render_text.cpp:
+        (InlineTextBox::paint):
+        * khtml/xml/dom2_rangeimpl.cpp:
+        (DOM::operator==):
+        (DOM::rangeOfContents):
+        * khtml/xml/dom2_rangeimpl.h:
+        (DOM::operator!=):
+        * khtml/xml/dom_docimpl.cpp:
+        (DocumentImpl::relinquishesEditingFocus):
+        (DocumentImpl::acceptsEditingFocus):
+        (DocumentImpl::addMarker):
+        (DocumentImpl::removeMarker):
+        * khtml/xml/dom_docimpl.h:
+        * khtml/xml/dom_position.cpp:
+        (DOM::startPosition):
+        * khtml/xml/dom_position.h:
+        * kwq/DOMHTML.mm:
+        (-[DOMHTMLLinkElement href]):
+        (-[DOMHTMLBaseElement href]):
+        (-[DOMHTMLInputElement src]):
+        (-[DOMHTMLAnchorElement href]):
+        (-[DOMHTMLImageElement src]):
+        (-[DOMHTMLAreaElement href]):
+        * kwq/KWQAccObject.mm:
+        (-[KWQAccObject textUnderElement]):
+        (-[KWQAccObject value]):
+        (-[KWQAccObject doAXStringForTextMarkerRange:]):
+        (-[KWQAccObject doAXAttributedStringForTextMarkerRange:]):
+        * kwq/KWQKHTMLPart.h:
+        (KWQKHTMLPart::markedTextRange):
+        * kwq/KWQKHTMLPart.mm:
+        (KWQKHTMLPart::findString):
+        (KWQKHTMLPart::advanceToNextMisspelling):
+        (KWQKHTMLPart::fontForSelection):
+        (KWQKHTMLPart::markMisspellings):
+        (KWQKHTMLPart::respondToChangedSelection):
+        (KWQKHTMLPart::shouldBeginEditing):
+        (KWQKHTMLPart::shouldEndEditing):
+        (convertAttributesToUnderlines):
+        (KWQKHTMLPart::setMarkedTextRange):
+        * kwq/WebCoreBridge.mm:
+        (-[WebCoreBridge elementAtPoint:]):
+        (-[WebCoreBridge rangeByExpandingSelectionWithGranularity:]):
+        (-[WebCoreBridge rangeByAlteringCurrentSelection:direction:granularity:]):
+        (-[WebCoreBridge rangeByAlteringCurrentSelection:verticalDistance:]):
+        (-[WebCoreBridge selectedDOMRange]):
+        (-[WebCoreBridge convertToNSRange:DOM::]):
+        (-[WebCoreBridge convertToDOMRange:]):
+        (-[WebCoreBridge convertToObjCDOMRange:]):
+        (-[WebCoreBridge selectNSRange:]):
+        (-[WebCoreBridge selectedNSRange]):
+        (-[WebCoreBridge markDOMRange]):
+        (-[WebCoreBridge markedTextDOMRange]):
+        (-[WebCoreBridge markedTextNSRange]):
+        (-[WebCoreBridge replaceMarkedTextWithText:]):
+        (-[WebCoreBridge smartDeleteRangeForProposedRange:]):
+        (-[WebCoreBridge dragCaretDOMRange]):
+        (-[WebCoreBridge editableDOMRangeForPoint:]):
+        (-[WebCoreBridge rangeOfCharactersAroundCaret]):
+
 2005-05-13  Maciej Stachowiak  <mjs@apple.com>
 
         Reviewed by Dave.
index 9c68711e7042dcdbf48993000e9ffebebb38f12d..5a798916c1007dc00e177d06a4f511c61eb89d30 100644 (file)
@@ -402,24 +402,4 @@ void Range::throwException(int exceptioncode) const
         throw DOMException(exceptioncode);
 }
 
-bool operator==(const Range &a, const Range &b)
-{
-    RangeImpl *ai = a.handle();
-    RangeImpl *bi = b.handle();
-    if (ai == bi)
-        return true;
-    if (!ai || !bi)
-        return false;
-    bool ad = ai->isDetached();
-    bool bd = bi->isDetached();
-    if (ad && bd)
-        return true;
-    if (ad || bd)
-        return false;
-    return a.startContainer() == b.startContainer()
-        && a.endContainer() == b.endContainer()
-        && a.startOffset() == b.startOffset()
-        && a.endOffset() == b.endOffset();
-}
-
 }
index 435d6519cabf07d0dae895e52fe76dd2883595c2..81279aee19ad5b0bf79624f598d21b4a3f0a8cf0 100644 (file)
@@ -474,9 +474,6 @@ private:
     void throwException(int exceptioncode) const;
 };
 
-bool operator==(const Range &, const Range &);
-inline bool operator!=(const Range &a, const Range &b) { return !(a == b); }
-
 // Used determine how to interpret the offsets used in DOM Ranges.
 inline bool offsetInCharacters(unsigned short type)
 {
index e2d4bfb5eae12aee1d2e394a8cf45d94a9d463ea..66ade6d06f923d22333ed27ad717120729140dc4 100644 (file)
@@ -59,6 +59,7 @@
 #include "editing/htmlediting.h"
 #include "editing/selection.h"
 #include "xml/dom2_eventsimpl.h"
+#include "xml/dom2_rangeimpl.h"
 #include "xml/dom_docimpl.h"
 #include "xml/dom_elementimpl.h"
 #include "xml/dom_position.h"
@@ -508,7 +509,7 @@ Value Window::get(ExecState *exec, const Identifier &p) const
     case Document:
       if (isSafeScript(exec))
       {
-        if (m_part->document().isNull()) {
+        if (!m_part->xmlDocImpl()) {
 #if APPLE_CHANGES
           KWQ(m_part)->createEmptyDocument();
 #endif
@@ -1610,7 +1611,7 @@ Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
         khtmlpart->setOpener(part);
         khtmlpart->setOpenedByJS(true);
         
-        if (khtmlpart->document().isNull()) {
+        if (!khtmlpart->xmlDocImpl()) {
             DocumentImpl *oldDoc = part->xmlDocImpl();
             if (oldDoc && oldDoc->baseURL() != 0)
                 khtmlpart->begin(oldDoc->baseURL());
@@ -1833,7 +1834,7 @@ Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
            return Undefined();
         JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
         if (listener) {
-           DOM::DocumentImpl* docimpl = static_cast<DOM::DocumentImpl *>(part->document().handle());
+           DocumentImpl* docimpl = part->xmlDocImpl();
             if (docimpl)
                 docimpl->addWindowEventListener(DOM::EventImpl::typeToId(args[0].toString(exec).string()),listener,args[2].toBoolean(exec));
         }
@@ -1844,7 +1845,7 @@ Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
            return Undefined();
         JSEventListener *listener = Window::retrieveActive(exec)->getJSEventListener(args[1]);
         if (listener) {
-           DOM::DocumentImpl* docimpl = static_cast<DOM::DocumentImpl *>(part->document().handle());
+           DocumentImpl* docimpl = part->xmlDocImpl();
             if (docimpl)
                 docimpl->removeWindowEventListener(DOM::EventImpl::typeToId(args[0].toString(exec).string()),listener,args[2].toBoolean(exec));
         }
@@ -1857,7 +1858,7 @@ Value WindowFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
 
 void Window::updateLayout() const
 {
-  DOM::DocumentImpl* docimpl = static_cast<DOM::DocumentImpl *>(m_part->document().handle());
+  DOM::DocumentImpl* docimpl = m_part->xmlDocImpl();
   if (docimpl)
     docimpl->updateLayoutIgnorePendingStylesheets();
 }
@@ -1926,8 +1927,8 @@ void ScheduledAction::execute(Window *window)
   }
 
   // Update our document's rendering following the execution of the timeout callback.
-  DOM::DocumentImpl *doc = static_cast<DOM::DocumentImpl*>(window->m_part->document().handle());
-  doc->updateRendering();
+  if (DocumentImpl *doc = window->m_part->xmlDocImpl())
+    doc->updateRendering();
   
   interpreter->setProcessingTimerCallback(false);
 }
@@ -2450,7 +2451,8 @@ UString Selection::toString(ExecState *) const
 {
     if (!m_part->selection().isRange())
         return UString("");
-    return UString(m_part->selection().toRange().toString());
+    int exception = 0;
+    return UString(m_part->selection().toRange()->toString(exception));
 }
 
 Value SelectionFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
index 3d6f7bdfcc6ce70f9331521cf656743848d36179..d115cd432263bb950d75d17b0d3318fa2f684151 100644 (file)
@@ -630,7 +630,7 @@ Value XMLHttpRequestProtoFunc::tryCall(ExecState *exec, Object &thisObj, const L
       }
     
       QString method = args[0].toString(exec).qstring();
-      KURL url = KURL(Window::retrieveActive(exec)->part()->document().completeURL(args[1].toString(exec).qstring()).string());
+      KURL url = KURL(Window::retrieveActive(exec)->part()->xmlDocImpl()->completeURL(args[1].toString(exec).qstring()));
 
       bool async = true;
       if (args.size() >= 3) {
index cc8266267cd5aef5ae3133bd975335c51c4abd82..5a3eec88a0e252942c0438c56c9e62ebc96c6267 100644 (file)
@@ -74,7 +74,7 @@ Selection::Selection(const Position &pos, EAffinity affinity)
     validate();
 }
 
-Selection::Selection(const Range &r, EAffinity baseAffinity, EAffinity extentAffinity)
+Selection::Selection(const RangeImpl *r, EAffinity baseAffinity, EAffinity extentAffinity)
     : m_base(startPosition(r)), m_extent(endPosition(r))
 {
     init(baseAffinity);
@@ -194,7 +194,7 @@ void Selection::moveTo(const Position &pos, EAffinity affinity)
     validate();
 }
 
-void Selection::moveTo(const Range &r, EAffinity baseAffinity, EAffinity extentAffinity)
+void Selection::moveTo(const RangeImpl *r, EAffinity baseAffinity, EAffinity extentAffinity)
 {
     // FIXME: use extentAffinity
     m_affinity = baseAffinity;
@@ -605,10 +605,10 @@ void Selection::setNeedsLayout(bool flag)
     m_needsLayout = flag;
 }
 
-Range Selection::toRange() const
+SharedPtr<RangeImpl> Selection::toRange() const
 {
     if (isNone())
-        return Range();
+        return SharedPtr<RangeImpl>();
 
     // Make sure we have an updated layout since this function is called
     // in the course of running edit commands which modify the DOM.
@@ -650,21 +650,17 @@ Range Selection::toRange() const
         e = e.equivalentRangeCompliantPosition();
     }
 
-    // Use this roundabout way of creating the Range in order to have defined behavior
-    // when there is a DOM exception.
     int exceptionCode = 0;
-    Range result(s.node()->getDocument());
-    RangeImpl *handle = result.handle();
-    ASSERT(handle);
-    handle->setStart(s.node(), s.offset(), exceptionCode);
+    SharedPtr<RangeImpl> result(new RangeImpl(s.node()->docPtr()));
+    result->setStart(s.node(), s.offset(), exceptionCode);
     if (exceptionCode) {
         ERROR("Exception setting Range start from Selection: %d", exceptionCode);
-        return Range();
+        return SharedPtr<RangeImpl>();
     }
-    handle->setEnd(e.node(), e.offset(), exceptionCode);
+    result->setEnd(e.node(), e.offset(), exceptionCode);
     if (exceptionCode) {
         ERROR("Exception setting Range end from Selection: %d", exceptionCode);
-        return Range();
+        return SharedPtr<RangeImpl>();
     }
     return result;
 }
index e14de864c3e809bf93feb7b6cdfabf71179dbad5..72c5e764f963b8264831b6ce0d246ad3c917327c 100644 (file)
@@ -29,6 +29,7 @@
 #include <qrect.h>
 #include "xml/dom_position.h"
 #include "text_granularity.h"
+#include "misc/shared.h"
 
 class KHTMLPart;
 class QPainter;
@@ -50,11 +51,11 @@ public:
 // but that would be the desired affinity"
 #define SEL_PREFER_UPSTREAM_AFFINITY DOWNSTREAM
 
-    typedef DOM::Range Range;
     typedef DOM::Position Position;
+    typedef DOM::RangeImpl RangeImpl;
 
     Selection();
-    Selection(const Range &, EAffinity baseAffinity, EAffinity extentAffinity);
+    Selection(const RangeImpl *, EAffinity baseAffinity, EAffinity extentAffinity);
     Selection(const VisiblePosition &);
     Selection(const VisiblePosition &, const VisiblePosition &);
     Selection(const Position &, EAffinity affinity);
@@ -64,7 +65,7 @@ public:
     Selection &operator=(const Selection &o);
     Selection &operator=(const VisiblePosition &r) { moveTo(r); return *this; }
 
-    void moveTo(const Range &, EAffinity baseAffinity, EAffinity extentAffinity);
+    void moveTo(const RangeImpl *, EAffinity baseAffinity, EAffinity extentAffinity);
     void moveTo(const VisiblePosition &);
     void moveTo(const VisiblePosition &, const VisiblePosition &);
     void moveTo(const Position &, EAffinity);
@@ -109,7 +110,7 @@ public:
     bool isRange() const { return state() == RANGE; }
     bool isCaretOrRange() const { return state() != NONE; }
 
-    Range toRange() const;
+    SharedPtr<DOM::RangeImpl> toRange() const;
 
     void debugPosition() const;
     void debugRenderer(khtml::RenderObject *r, bool selected) const;
index 9e3759bf63bde760fce032fb2547fa0b3654630d..c0118055b7730f387fda48f5573bc02bf145696b 100644 (file)
@@ -78,7 +78,6 @@ using DOM::NamedAttrMapImpl;
 using DOM::NodeImpl;
 using DOM::NodeListImpl;
 using DOM::Position;
-using DOM::Range;
 using DOM::RangeImpl;
 using DOM::TextImpl;
 using DOM::TreeWalkerImpl;
@@ -423,7 +422,7 @@ void InsertLineBreakCommand::doApply()
         Selection selectionBeforeStyle = endingSelection();
 
         DOM::RangeImpl *rangeAroundNode = document()->createRange();
-        int exception;
+        int exception = 0;
         rangeAroundNode->selectNode(nodeToInsert, exception);
 
         // affinity is not really important since this is a temp selection
index cc8266267cd5aef5ae3133bd975335c51c4abd82..5a3eec88a0e252942c0438c56c9e62ebc96c6267 100644 (file)
@@ -74,7 +74,7 @@ Selection::Selection(const Position &pos, EAffinity affinity)
     validate();
 }
 
-Selection::Selection(const Range &r, EAffinity baseAffinity, EAffinity extentAffinity)
+Selection::Selection(const RangeImpl *r, EAffinity baseAffinity, EAffinity extentAffinity)
     : m_base(startPosition(r)), m_extent(endPosition(r))
 {
     init(baseAffinity);
@@ -194,7 +194,7 @@ void Selection::moveTo(const Position &pos, EAffinity affinity)
     validate();
 }
 
-void Selection::moveTo(const Range &r, EAffinity baseAffinity, EAffinity extentAffinity)
+void Selection::moveTo(const RangeImpl *r, EAffinity baseAffinity, EAffinity extentAffinity)
 {
     // FIXME: use extentAffinity
     m_affinity = baseAffinity;
@@ -605,10 +605,10 @@ void Selection::setNeedsLayout(bool flag)
     m_needsLayout = flag;
 }
 
-Range Selection::toRange() const
+SharedPtr<RangeImpl> Selection::toRange() const
 {
     if (isNone())
-        return Range();
+        return SharedPtr<RangeImpl>();
 
     // Make sure we have an updated layout since this function is called
     // in the course of running edit commands which modify the DOM.
@@ -650,21 +650,17 @@ Range Selection::toRange() const
         e = e.equivalentRangeCompliantPosition();
     }
 
-    // Use this roundabout way of creating the Range in order to have defined behavior
-    // when there is a DOM exception.
     int exceptionCode = 0;
-    Range result(s.node()->getDocument());
-    RangeImpl *handle = result.handle();
-    ASSERT(handle);
-    handle->setStart(s.node(), s.offset(), exceptionCode);
+    SharedPtr<RangeImpl> result(new RangeImpl(s.node()->docPtr()));
+    result->setStart(s.node(), s.offset(), exceptionCode);
     if (exceptionCode) {
         ERROR("Exception setting Range start from Selection: %d", exceptionCode);
-        return Range();
+        return SharedPtr<RangeImpl>();
     }
-    handle->setEnd(e.node(), e.offset(), exceptionCode);
+    result->setEnd(e.node(), e.offset(), exceptionCode);
     if (exceptionCode) {
         ERROR("Exception setting Range end from Selection: %d", exceptionCode);
-        return Range();
+        return SharedPtr<RangeImpl>();
     }
     return result;
 }
index e14de864c3e809bf93feb7b6cdfabf71179dbad5..72c5e764f963b8264831b6ce0d246ad3c917327c 100644 (file)
@@ -29,6 +29,7 @@
 #include <qrect.h>
 #include "xml/dom_position.h"
 #include "text_granularity.h"
+#include "misc/shared.h"
 
 class KHTMLPart;
 class QPainter;
@@ -50,11 +51,11 @@ public:
 // but that would be the desired affinity"
 #define SEL_PREFER_UPSTREAM_AFFINITY DOWNSTREAM
 
-    typedef DOM::Range Range;
     typedef DOM::Position Position;
+    typedef DOM::RangeImpl RangeImpl;
 
     Selection();
-    Selection(const Range &, EAffinity baseAffinity, EAffinity extentAffinity);
+    Selection(const RangeImpl *, EAffinity baseAffinity, EAffinity extentAffinity);
     Selection(const VisiblePosition &);
     Selection(const VisiblePosition &, const VisiblePosition &);
     Selection(const Position &, EAffinity affinity);
@@ -64,7 +65,7 @@ public:
     Selection &operator=(const Selection &o);
     Selection &operator=(const VisiblePosition &r) { moveTo(r); return *this; }
 
-    void moveTo(const Range &, EAffinity baseAffinity, EAffinity extentAffinity);
+    void moveTo(const RangeImpl *, EAffinity baseAffinity, EAffinity extentAffinity);
     void moveTo(const VisiblePosition &);
     void moveTo(const VisiblePosition &, const VisiblePosition &);
     void moveTo(const Position &, EAffinity);
@@ -109,7 +110,7 @@ public:
     bool isRange() const { return state() == RANGE; }
     bool isCaretOrRange() const { return state() != NONE; }
 
-    Range toRange() const;
+    SharedPtr<DOM::RangeImpl> toRange() const;
 
     void debugPosition() const;
     void debugRenderer(khtml::RenderObject *r, bool selected) const;
index 5b2c9e85128a85459ddc49e2b5c4900734de6b98..d1beb3ad624eea1bc8f3722b2d1f00c40250341d 100644 (file)
@@ -388,42 +388,42 @@ void VisiblePosition::formatForDebugger(char *buffer, unsigned length) const
 }
 #endif
 
-Range makeRange(const VisiblePosition &start, const VisiblePosition &end)
+SharedPtr<RangeImpl> makeRange(const VisiblePosition &start, const VisiblePosition &end)
 {
     Position s = start.position();
     Position e = end.position();
-    return Range(s.node(), s.offset(), e.node(), e.offset());
+    return SharedPtr<RangeImpl>(new RangeImpl(s.node()->docPtr(), s.node(), s.offset(), e.node(), e.offset()));
 }
 
-VisiblePosition startVisiblePosition(const Range &r, EAffinity affinity)
+VisiblePosition startVisiblePosition(const RangeImpl *r, EAffinity affinity)
 {
-    return VisiblePosition(r.startContainer().handle(), r.startOffset(), affinity);
+    int exception = 0;
+    return VisiblePosition(r->startContainer(exception), r->startOffset(exception), affinity);
 }
 
-VisiblePosition endVisiblePosition(const Range &r, EAffinity affinity)
+VisiblePosition endVisiblePosition(const RangeImpl *r, EAffinity affinity)
 {
-    return VisiblePosition(r.endContainer().handle(), r.endOffset(), affinity);
+    int exception = 0;
+    return VisiblePosition(r->endContainer(exception), r->endOffset(exception), affinity);
 }
 
-bool setStart(Range &r, const VisiblePosition &c)
+bool setStart(RangeImpl *r, const VisiblePosition &c)
 {
-    RangeImpl *ri = r.handle();
-    if (!ri)
+    if (!r)
         return false;
     Position p = c.position();
     int code = 0;
-    ri->setStart(p.node(), p.offset(), code);
+    r->setStart(p.node(), p.offset(), code);
     return code == 0;
 }
 
-bool setEnd(Range &r, const VisiblePosition &c)
+bool setEnd(RangeImpl *r, const VisiblePosition &c)
 {
-    RangeImpl *ri = r.handle();
-    if (!ri)
+    if (!r)
         return false;
     Position p = c.position();
     int code = 0;
-    ri->setEnd(p.node(), p.offset(), code);
+    r->setEnd(p.node(), p.offset(), code);
     return code == 0;
 }
 
index 00ff159f3464efc268e2497bf2c33df89fca4de8..a47a212e27d992edd5adb5505afcefbb8ea5ac2e 100644 (file)
 
 #include "xml/dom_position.h"
 #include "text_affinity.h"
+#include "misc/shared.h"
 
 namespace DOM {
     class NodeImpl;
-    class Range;
     class RangeImpl;
 }
 
@@ -114,14 +114,10 @@ inline bool operator!=(const VisiblePosition &a, const VisiblePosition &b)
     return !(a == b);
 }
 
-DOM::Range makeRange(const VisiblePosition &start, const VisiblePosition &end);
-bool setStart(DOM::Range &, const VisiblePosition &start);
+khtml::SharedPtr<DOM::RangeImpl> makeRange(const VisiblePosition &start, const VisiblePosition &end);
 bool setStart(DOM::RangeImpl *, const VisiblePosition &start);
-bool setEnd(DOM::Range &, const VisiblePosition &start);
 bool setEnd(DOM::RangeImpl *, const VisiblePosition &start);
-VisiblePosition startVisiblePosition(const DOM::Range &, EAffinity);
 VisiblePosition startVisiblePosition(const DOM::RangeImpl *, EAffinity);
-VisiblePosition endVisiblePosition(const DOM::Range &, EAffinity);
 VisiblePosition endVisiblePosition(const DOM::RangeImpl *, EAffinity);
 
 void setAffinityUsingLinePosition(VisiblePosition &);
index f5956678384b56413dc3fd83649399de4d02bab6..8158ea8029e3a5ca850962ec03970e0f4c54da36 100644 (file)
@@ -35,24 +35,24 @@ class VisibleRange
 public:
     typedef DOM::NodeImpl NodeImpl;
     typedef DOM::Position Position;
-    typedef DOM::Range Range;
+    typedef DOM::RangeImpl RangeImpl;
 
     VisibleRange() { }
     VisibleRange(NodeImpl *startContainer, long startOffset, NodeImpl *endContainer, long endOffset);
     VisibleRange(const VisiblePosition &);
     VisibleRange(const VisiblePosition &, const VisiblePosition &);
-    VisibleRange(const Range &);
+    VisibleRange(const RangeImpl *);
     VisibleRange(const Position &);
     VisibleRange(const Position &, const Position &);
 
     VisibleRange &operator=(const VisiblePosition &);
-    VisibleRange &operator=(const Range &);
+    VisibleRange &operator=(const RangeImpl *);
     VisibleRange &operator=(const Position &);
 
     VisiblePosition start() const { return m_start; }
     VisiblePosition end() const { return m_end; }
 
-    Range range() const;
+    SharedPtr<RangeImpl> range() const;
 
     void clear() { m_start.clear(); m_end.clear(); }
 
index be8a1a6bad28be6314c532824b8d78c77da42046..03c561865a4b865738d15a2ac6dda767d8f8deac 100644 (file)
 #include "xml/dom_position.h"
 #include "xml/dom2_rangeimpl.h"
 
+using DOM::DocumentImpl;
 using DOM::DOMString;
 using DOM::Node;
 using DOM::NodeImpl;
 using DOM::offsetInCharacters;
-using DOM::Range;
 using DOM::RangeImpl;
 
 // FIXME: These classes should probably use the render tree and not the DOM tree, since elements could
@@ -79,19 +79,18 @@ TextIterator::TextIterator() : m_endContainer(0), m_endOffset(0), m_positionNode
 {
 }
 
-TextIterator::TextIterator(const Range &r, IteratorKind kind) : m_endContainer(0), m_endOffset(0), m_positionNode(0)
+TextIterator::TextIterator(const RangeImpl *r, IteratorKind kind) : m_endContainer(0), m_endOffset(0), m_positionNode(0)
 {
-    const RangeImpl *ri = r.handle();
-    if (!ri)
+    if (!r)
         return;
 
     int exceptionCode = 0;
 
     // get and validate the range endpoints
-    NodeImpl *startContainer = ri->startContainer(exceptionCode);
-    long startOffset = ri->startOffset(exceptionCode);
-    NodeImpl *endContainer = ri->endContainer(exceptionCode);
-    long endOffset = ri->endOffset(exceptionCode);
+    NodeImpl *startContainer = r->startContainer(exceptionCode);
+    long startOffset = r->startOffset(exceptionCode);
+    NodeImpl *endContainer = r->endContainer(exceptionCode);
+    long endOffset = r->endOffset(exceptionCode);
     if (exceptionCode != 0)
         return;
 
@@ -100,7 +99,7 @@ TextIterator::TextIterator(const Range &r, IteratorKind kind) : m_endContainer(0
     m_endOffset = endOffset;
 
     // set up the current node for processing
-    m_node = ri->startNode();
+    m_node = r->startNode();
     if (m_node == 0)
         return;
     m_offset = m_node == startContainer ? startOffset : 0;
@@ -108,7 +107,7 @@ TextIterator::TextIterator(const Range &r, IteratorKind kind) : m_endContainer(0
     m_handledChildren = false;
 
     // calculate first out of bounds node
-    m_pastEndNode = ri->pastEndNode();
+    m_pastEndNode = r->pastEndNode();
 
     // initialize node processing state
     m_needAnotherNewline = false;
@@ -463,7 +462,7 @@ void TextIterator::emitCharacter(QChar c, NodeImpl *textNode, NodeImpl *offsetBa
     m_lastCharacter = c;
 }
 
-Range TextIterator::range() const
+SharedPtr<RangeImpl> TextIterator::range() const
 {
     // use the current run information, if we have it
     if (m_positionNode) {
@@ -473,31 +472,42 @@ Range TextIterator::range() const
             m_positionEndOffset += index;
             m_positionOffsetBaseNode = 0;
         }
-        return Range(m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset);
+        return SharedPtr<RangeImpl>(new RangeImpl(m_positionNode->docPtr(),
+            m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset));
     }
 
     // otherwise, return the end of the overall range we were given
     if (m_endContainer)
-        return Range(m_endContainer, m_endOffset, m_endContainer, m_endOffset);
+        return SharedPtr<RangeImpl>(new RangeImpl(m_endContainer->docPtr(), 
+            m_endContainer, m_endOffset, m_endContainer, m_endOffset));
         
-    return Range();
+    return SharedPtr<RangeImpl>();
 }
 
 SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator() : m_positionNode(0)
 {
 }
 
-SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const Range &r)
+SimplifiedBackwardsTextIterator::SimplifiedBackwardsTextIterator(const RangeImpl *r)
 {
-    if (r.isNull()) {
-        m_positionNode = 0;
+    m_positionNode = 0;
+
+    if (!r)
         return;
-    }
 
-    NodeImpl *startNode = r.startContainer().handle();
-    NodeImpl *endNode = r.endContainer().handle();
-    long startOffset = r.startOffset();
-    long endOffset = r.endOffset();
+    int exception = 0;
+    NodeImpl *startNode = r->startContainer(exception);
+    if (exception)
+        return;
+    NodeImpl *endNode = r->endContainer(exception);
+    if (exception)
+        return;
+    long startOffset = r->startOffset(exception);
+    if (exception)
+        return;
+    long endOffset = r->endOffset(exception);
+    if (exception)
+        return;
 
     if (!offsetInCharacters(startNode->nodeType())) {
         if (startOffset >= 0 && startOffset < static_cast<long>(startNode->childNodeCount())) {
@@ -717,12 +727,12 @@ void SimplifiedBackwardsTextIterator::emitNewlineForBROrText()
     }
 }
 
-Range SimplifiedBackwardsTextIterator::range() const
+SharedPtr<RangeImpl> SimplifiedBackwardsTextIterator::range() const
 {
     if (m_positionNode) {
-        return Range(m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset);
+        return SharedPtr<RangeImpl>(new RangeImpl(m_positionNode->docPtr(), m_positionNode, m_positionStartOffset, m_positionNode, m_positionEndOffset));
     } else {
-        return Range(m_startNode, m_startOffset, m_startNode, m_startOffset);
+        return SharedPtr<RangeImpl>(new RangeImpl(m_startNode->docPtr(), m_startNode, m_startOffset, m_startNode, m_startOffset));
     }
 }
 
@@ -731,7 +741,7 @@ CharacterIterator::CharacterIterator()
 {
 }
 
-CharacterIterator::CharacterIterator(const Range &r)
+CharacterIterator::CharacterIterator(const RangeImpl *r)
     : m_offset(0), m_runOffset(0), m_atBreak(true), m_textIterator(r, RUNFINDER)
 {
     while (!atEnd() && m_textIterator.length() == 0) {
@@ -739,18 +749,19 @@ CharacterIterator::CharacterIterator(const Range &r)
     }
 }
 
-Range CharacterIterator::range() const
+SharedPtr<RangeImpl> CharacterIterator::range() const
 {
-    Range r = m_textIterator.range();
+    SharedPtr<RangeImpl> r = m_textIterator.range();
     if (!m_textIterator.atEnd()) {
         if (m_textIterator.length() <= 1) {
             assert(m_runOffset == 0);
         } else {
-            Node n = r.startContainer();
-            assert(n == r.endContainer());
-            long offset = r.startOffset() + m_runOffset;
-            r.setStart(n, offset);
-            r.setEnd(n, offset + 1);
+            int exception = 0;
+            NodeImpl *n = r->startContainer(exception);
+            assert(n == r->endContainer(exception));
+            long offset = r->startOffset(exception) + m_runOffset;
+            r->setStart(n, offset, exception);
+            r->setEnd(n, offset + 1, exception);
         }
     }
     return r;
@@ -816,7 +827,7 @@ WordAwareIterator::WordAwareIterator()
 {
 }
 
-WordAwareIterator::WordAwareIterator(const Range &r)
+WordAwareIterator::WordAwareIterator(const RangeImpl *r)
 : m_previousText(0), m_didLookAhead(false), m_textIterator(r)
 {
     m_didLookAhead = true;  // so we consider the first chunk from the text iterator
@@ -879,7 +890,9 @@ void WordAwareIterator::advance()
             m_previousText = 0;
         }
         m_buffer.append(m_textIterator.characters(), m_textIterator.length());
-        m_range.setEnd(m_textIterator.range().endContainer(), m_textIterator.range().endOffset());
+        int exception = 0;
+        m_range->setEnd(m_textIterator.range()->endContainer(exception),
+            m_textIterator.range()->endOffset(exception), exception);
     }
 }
 
@@ -978,7 +991,7 @@ bool CircularSearchBuffer::isMatch() const
         && memcmp(m_buffer, m_target.unicode() + tailSpace, headSpace * sizeof(QChar)) == 0;
 }
 
-long TextIterator::rangeLength(const Range &r)
+long TextIterator::rangeLength(const RangeImpl *r)
 {
     // Allocate string at the right size, rather than building it up by successive append calls.
     long length = 0;
@@ -988,36 +1001,40 @@ long TextIterator::rangeLength(const Range &r)
     return length;
 }
 
-void TextIterator::setRangeFromLocationAndLength (const Range &range, Range &resultRange, long rangeLocation, long rangeLength)
+RangeImpl *TextIterator::rangeFromLocationAndLength(DocumentImpl *doc, long rangeLocation, long rangeLength)
 {
+    RangeImpl *resultRange = doc->createRange();
+
     long docTextPosition = 0;
     long rangeEnd = rangeLocation + rangeLength;
 
-    for (TextIterator it(range); !it.atEnd(); it.advance()) {
+    for (TextIterator it(rangeOfContents(doc).get()); !it.atEnd(); it.advance()) {
         long len = it.length();
         if (rangeLocation >= docTextPosition && rangeLocation <= docTextPosition + len) {
-            Range textRunRange = it.range();
-            if (textRunRange.startContainer().handle()->isTextNode()) {
+            SharedPtr<RangeImpl> textRunRange = it.range();
+            int exception = 0;
+            if (textRunRange->startContainer(exception)->isTextNode()) {
                 long offset = rangeLocation - docTextPosition;
-                resultRange.setStart(textRunRange.startContainer(), offset + textRunRange.startOffset());
+                resultRange->setStart(textRunRange->startContainer(exception), offset + textRunRange->startOffset(exception), exception);
             } else {
                 if (rangeLocation == docTextPosition) {
-                    resultRange.setStart(textRunRange.startContainer(), textRunRange.startOffset());
+                    resultRange->setStart(textRunRange->startContainer(exception), textRunRange->startOffset(exception), exception);
                 } else {
-                    resultRange.setStart(textRunRange.endContainer(), textRunRange.endOffset());
+                    resultRange->setStart(textRunRange->endContainer(exception), textRunRange->endOffset(exception), exception);
                 }
             }
         }
         if (rangeEnd >= docTextPosition && rangeEnd <= docTextPosition + len) {
-            Range textRunRange = it.range();
-            if (textRunRange.startContainer().handle()->isTextNode()) {
+            SharedPtr<RangeImpl> textRunRange = it.range();
+            int exception = 0;
+            if (textRunRange->startContainer(exception)->isTextNode()) {
                 long offset = rangeEnd - docTextPosition;
-                resultRange.setEnd(textRunRange.startContainer(), offset + textRunRange.startOffset());
+                resultRange->setEnd(textRunRange->startContainer(exception), offset + textRunRange->startOffset(exception), exception);
             } else {
                 if (rangeEnd == docTextPosition) {
-                    resultRange.setEnd(textRunRange.startContainer(), textRunRange.startOffset());
+                    resultRange->setEnd(textRunRange->startContainer(exception), textRunRange->startOffset(exception), exception);
                 } else {
-                    resultRange.setEnd(textRunRange.endContainer(), textRunRange.endOffset());
+                    resultRange->setEnd(textRunRange->endContainer(exception), textRunRange->endOffset(exception), exception);
                 }
             }
             if ( !(rangeLength == 0 && rangeEnd == docTextPosition + len) ) {
@@ -1026,9 +1043,11 @@ void TextIterator::setRangeFromLocationAndLength (const Range &range, Range &res
         }
         docTextPosition += it.length();
     }
+
+    return resultRange;
 }
 
-QString plainText(const Range &r)
+QString plainText(const RangeImpl *r)
 {
     // Allocate string at the right size, rather than building it up by successive append calls.
     long length = 0;
@@ -1043,16 +1062,17 @@ QString plainText(const Range &r)
     return result;
 }
 
-Range findPlainText(const Range &r, const QString &s, bool forward, bool caseSensitive)
+SharedPtr<RangeImpl> findPlainText(const RangeImpl *r, const QString &s, bool forward, bool caseSensitive)
 {
     // FIXME: Can we do Boyer-Moore or equivalent instead for speed?
 
     // FIXME: This code does not allow \n at the moment because of issues with <br>.
     // Once we fix those, we can remove this check.
     if (s.isEmpty() || s.find('\n') != -1) {
-        Range result = r;
-        result.collapse(forward);
-        return result;
+        int exception = 0;
+        RangeImpl *result = r->cloneRange(exception);
+        result->collapse(forward, exception);
+        return SharedPtr<RangeImpl>(result);
     }
 
     CircularSearchBuffer buffer(s, caseSensitive);
@@ -1099,17 +1119,18 @@ Range findPlainText(const Range &r, const QString &s, bool forward, bool caseSen
     }
 
 done:
-    Range result = r;
+    int exception = 0;
+    RangeImpl *result = r->cloneRange(exception);
     if (!found) {
-        result.collapse(!forward);
+        result->collapse(!forward, exception);
     } else {
         CharacterIterator it(r);
         it.advance(rangeEnd.characterOffset() - buffer.length());
-        result.setStart(it.range().startContainer(), it.range().startOffset());
+        result->setStart(it.range()->startContainer(exception), it.range()->startOffset(exception), exception);
         it.advance(buffer.length() - 1);
-        result.setEnd(it.range().endContainer(), it.range().endOffset());
+        result->setEnd(it.range()->endContainer(exception), it.range()->endOffset(exception), exception);
     }
-    return result;
+    return SharedPtr<RangeImpl>(result);
 }
 
 }
index 28d3fb6479cc909be731e48b1e14f0f748c89c2e..762b89c5a5b9f6b63021321e896b71bbe16b5b5f 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef KHTML_EDITING_VISIBLE_TEXT_H
 #define KHTML_EDITING_VISIBLE_TEXT_H
 
-#include "dom/dom2_range.h"
+#include "xml/dom2_rangeimpl.h"
 
 namespace khtml {
 
@@ -46,8 +46,8 @@ inline bool isCollapsibleWhitespace(const QChar &c)
     }
 }
 
-QString plainText(const DOM::Range &);
-DOM::Range findPlainText(const DOM::Range &, const QString &, bool forward, bool caseSensitive);
+QString plainText(const DOM::RangeImpl *);
+SharedPtr<DOM::RangeImpl> findPlainText(const DOM::RangeImpl *, const QString &, bool forward, bool caseSensitive);
 
 // Iterates through the DOM range, returning all the text, and 0-length boundaries
 // at points where replaced elements break up the text flow.  The text comes back in
@@ -59,7 +59,7 @@ class TextIterator
 {
 public:
     TextIterator();
-    explicit TextIterator(const DOM::Range &, IteratorKind kind = CONTENT );
+    explicit TextIterator(const DOM::RangeImpl *, IteratorKind kind = CONTENT );
     
     bool atEnd() const { return !m_positionNode; }
     void advance();
@@ -67,10 +67,10 @@ public:
     long length() const { return m_textLength; }
     const QChar *characters() const { return m_textCharacters; }
     
-    DOM::Range range() const;
+    SharedPtr<DOM::RangeImpl> range() const;
      
-    static long TextIterator::rangeLength(const DOM::Range &r);
-    static void TextIterator::setRangeFromLocationAndLength (const DOM::Range &range, DOM::Range &resultRange, long rangeLocation, long rangeLength);
+    static long TextIterator::rangeLength(const DOM::RangeImpl *r);
+    static DOM::RangeImpl *TextIterator::rangeFromLocationAndLength(DOM::DocumentImpl *doc, long rangeLocation, long rangeLength);
     
 private:
     void exitNode();
@@ -121,7 +121,7 @@ class SimplifiedBackwardsTextIterator
 {
 public:
     SimplifiedBackwardsTextIterator();
-    explicit SimplifiedBackwardsTextIterator(const DOM::Range &);
+    explicit SimplifiedBackwardsTextIterator(const DOM::RangeImpl *);
     
     bool atEnd() const { return !m_positionNode; }
     void advance();
@@ -129,7 +129,7 @@ public:
     long length() const { return m_textLength; }
     const QChar *characters() const { return m_textCharacters; }
     
-    DOM::Range range() const;
+    SharedPtr<DOM::RangeImpl> range() const;
         
 private:
     void exitNode();
@@ -170,7 +170,7 @@ private:
 class CharacterIterator {
 public:
     CharacterIterator();
-    explicit CharacterIterator(const DOM::Range &r);
+    explicit CharacterIterator(const DOM::RangeImpl *r);
     
     void advance(long numCharacters);
     
@@ -182,7 +182,7 @@ public:
     QString string(long numChars);
     
     long characterOffset() const { return m_offset; }
-    DOM::Range range() const;
+    SharedPtr<DOM::RangeImpl> range() const;
         
 private:
     long m_offset;
@@ -197,7 +197,7 @@ private:
 class WordAwareIterator {
 public:
     WordAwareIterator();
-    explicit WordAwareIterator(const DOM::Range &r);
+    explicit WordAwareIterator(const DOM::RangeImpl *r);
 
     bool atEnd() const { return !m_didLookAhead && m_textIterator.atEnd(); }
     void advance();
@@ -206,7 +206,7 @@ public:
     const QChar *characters() const;
     
     // Range of the text we're currently returning
-    DOM::Range range() const { return m_range; }
+    SharedPtr<DOM::RangeImpl> range() const { return m_range; }
 
 private:
     // text from the previous chunk from the textIterator
@@ -219,7 +219,7 @@ private:
     // Did we have to look ahead in the textIterator to confirm the current chunk?
     bool m_didLookAhead;
 
-    DOM::Range m_range;
+    SharedPtr<DOM::RangeImpl> m_range;
 
     TextIterator m_textIterator;
 };
index a5db8eafec1230a817475cc6219a58021210c8fc..c08fac741c4168f6172b2c016afdbfb611bea764 100644 (file)
@@ -40,7 +40,7 @@ using DOM::DocumentImpl;
 using DOM::ElementImpl;
 using DOM::NodeImpl;
 using DOM::Position;
-using DOM::Range;
+using DOM::RangeImpl;
 
 namespace khtml {
 
@@ -64,11 +64,12 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
         boundary = boundary->parentNode();
     }
 
-    Range searchRange(d);
-    searchRange.setStartBefore(boundary);
+    SharedPtr<RangeImpl> searchRange(d->createRange());
+    int exception = 0;
+    searchRange->setStartBefore(boundary, exception);
     Position end(pos.equivalentRangeCompliantPosition());
-    searchRange.setEnd(end.node(), end.offset());
-    SimplifiedBackwardsTextIterator it(searchRange);
+    searchRange->setEnd(end.node(), end.offset(), exception);
+    SimplifiedBackwardsTextIterator it(searchRange.get());
     QString string;
     unsigned next = 0;
     while (!it.atEnd() && it.length() > 0) {
@@ -81,8 +82,8 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
     }
     
     if (it.atEnd() && next == 0) {
-        Range range(it.range());
-        pos = Position(range.startContainer().handle(), range.startOffset());
+        SharedPtr<RangeImpl> range(it.range());
+        pos = Position(range->startContainer(exception), range->startOffset(exception));
     }
     else if (!it.atEnd() && it.length() == 0) {
         // Got a zero-length chunk.
@@ -95,17 +96,17 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
         chars[1] = ' ';
         string.prepend(chars, 2);
         unsigned pastImage = searchFunction(string.unicode(), string.length());
-        Range range(it.range());
+        SharedPtr<RangeImpl> range(it.range());
         if (pastImage == 0)
-            pos = Position(range.startContainer().handle(), range.startOffset());
+            pos = Position(range->startContainer(exception), range->startOffset(exception));
         else
-            pos = Position(range.endContainer().handle(), range.endOffset());
+            pos = Position(range->endContainer(exception), range->endOffset(exception));
     }
     else if (next != 0) {
         // The simpler iterator used in this function, as compared to the one used in 
         // nextWordPosition(), gives us results we can use directly without having to 
         // iterate again to translate the next value into a DOM position. 
-        NodeImpl *node = it.range().startContainer().handle();
+        NodeImpl *node = it.range()->startContainer(exception);
         if (node->isTextNode() || (node->renderer() && node->renderer()->isBR())) {
             // The next variable contains a usable index into a text node
             pos = Position(node, next);
@@ -113,7 +114,7 @@ static VisiblePosition previousBoundary(const VisiblePosition &c, unsigned (*sea
         else {
             // If we are not in a text node, we ended on a node boundary, so the
             // range start offset should be used.
-            pos = Position(node, it.range().startOffset());
+            pos = Position(node, it.range()->startOffset(exception));
         }
     }
 
@@ -140,11 +141,12 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
         boundary = boundary->parentNode();
     }
 
-    Range searchRange(d);
+    SharedPtr<RangeImpl> searchRange(d->createRange());
     Position start(pos.equivalentRangeCompliantPosition());
-    searchRange.setStart(start.node(), start.offset());
-    searchRange.setEndAfter(boundary);
-    TextIterator it(searchRange, RUNFINDER);
+    int exception = 0;
+    searchRange->setStart(start.node(), start.offset(), exception);
+    searchRange->setEndAfter(boundary, exception);
+    TextIterator it(searchRange.get(), RUNFINDER);
     QString string;
     unsigned next = 0;
     while (!it.atEnd() && it.length() > 0) {
@@ -158,8 +160,9 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
     }
     
     if (it.atEnd() && next == string.length()) {
-        Range range(it.range());
-        pos = Position(range.startContainer().handle(), range.startOffset());
+        SharedPtr<RangeImpl> range(it.range());
+        int exception = 0;
+        pos = Position(range->startContainer(exception), range->startOffset(exception));
     }
     else if (!it.atEnd() && it.length() == 0) {
         // Got a zero-length chunk.
@@ -172,17 +175,18 @@ static VisiblePosition nextBoundary(const VisiblePosition &c, unsigned (*searchF
         chars[1] = 'X';
         string.append(chars, 2);
         unsigned pastImage = searchFunction(string.unicode(), string.length());
-        Range range(it.range());
+        SharedPtr<RangeImpl> range(it.range());
+        int exception = 0;
         if (next != pastImage)
-            pos = Position(range.endContainer().handle(), range.endOffset());
+            pos = Position(range->endContainer(exception), range->endOffset(exception));
         else
-            pos = Position(range.startContainer().handle(), range.startOffset());
+            pos = Position(range->startContainer(exception), range->startOffset(exception));
     }
     else if (next != 0) {
         // Use the character iterator to translate the next value into a DOM position.
-        CharacterIterator charIt(searchRange);
+        CharacterIterator charIt(searchRange.get());
         charIt.advance(next - 1);
-        pos = Position(charIt.range().endContainer().handle(), charIt.range().endOffset());
+        pos = Position(charIt.range()->endContainer(exception), charIt.range()->endOffset(exception));
     }
     return VisiblePosition(pos, UPSTREAM);
 }
index 4f5887ccb683dd4675fc2eba3662da0509530988..cc8c546454362f0eec1fb7b3bd5f5a8f47aac632 100644 (file)
@@ -309,8 +309,7 @@ DOMString HTMLElementImpl::innerText() const
 {
     // We need to update layout, since plainText uses line boxes in the render tree.
     getDocument()->updateLayout();
-    return plainText(Range(const_cast<HTMLElementImpl *>(this), 0,
-        const_cast<HTMLElementImpl *>(this), childNodeCount()));
+    return plainText(rangeOfContents(const_cast<HTMLElementImpl *>(this)).get());
 }
 
 DOMString HTMLElementImpl::outerText() const
index 74fd79c69cc919ddd01ba397deb0f8aa640bdc71..7c674d3e14d02adb304a0f998c28960ce9a127b7 100644 (file)
@@ -603,7 +603,7 @@ void HTMLTokenizer::scriptExecution( const QString& str, QString scriptURL,
     script = false;
     QString url;    
     if (scriptURL.isNull())
-      url = static_cast<DocumentImpl*>(view->part()->document().handle())->URL();
+      url = view->part()->xmlDocImpl()->URL();
     else
       url = scriptURL;
 
index 39c4f4d1f5404c8b97704c60110c5aab5d51e054..de2f5964150a74df54b2b70b14c83f3f35e2d1c5 100644 (file)
@@ -2392,14 +2392,18 @@ bool KHTMLPart::findTextNext( const QString &str, bool forward, bool caseSensiti
 
 #endif // APPLE_CHANGES
 
+#if !KHTML_NO_CPLUSPLUS_DOM
+
 QString KHTMLPart::text(const DOM::Range &r) const
 {
-    return plainText(r);
+    return plainText(r.handle());
 }
 
+#endif
+
 QString KHTMLPart::selectedText() const
 {
-    return text(selection().toRange());
+    return plainText(selection().toRange().get());
 }
 
 bool KHTMLPart::hasSelection() const
@@ -5095,12 +5099,12 @@ void KHTMLPart::selectAll()
     selectFrameElementInParentIfFullySelected();
 }
 
-bool KHTMLPart::shouldBeginEditing(const Range &range) const
+bool KHTMLPart::shouldBeginEditing(const RangeImpl *range) const
 {
     return true;
 }
 
-bool KHTMLPart::shouldEndEditing(const Range &range) const
+bool KHTMLPart::shouldEndEditing(const RangeImpl *range) const
 {
     return true;
 }
@@ -5672,8 +5676,8 @@ CSSComputedStyleDeclarationImpl *KHTMLPart::selectionComputedStyle(NodeImpl *&no
     if (d->m_selection.isNone())
         return 0;
 
-    Range range(d->m_selection.toRange());
-    Position pos = range.handle()->editingStartPosition();
+    SharedPtr<RangeImpl> range(d->m_selection.toRange());
+    Position pos = range->editingStartPosition();
 
     ElementImpl *elem = pos.element();
     if (!elem)
index 034220201c8061fadabdb75dfbbcf27c8aca063e..eee64bfb0bab8245197bc63e8a340faf821bacf7 100644 (file)
@@ -64,6 +64,7 @@ namespace DOM
   class Node;
   class NodeImpl;
   class Range;
+  class RangeImpl;
 }
 
 namespace khtml
@@ -668,10 +669,12 @@ public:
    */
   int xPosForVerticalArrowNavigation() const;
 
+#if !KHTML_NO_CPLUSPLUS_DOM
   /**
    * Returns the text for a part of the document.
    */
   QString text(const DOM::Range &) const;
+#endif
 
   /**
    * Has the user selected anything?
@@ -691,12 +694,12 @@ public:
   /**
    * Returns whether editing should end in the given range
    */
-  virtual bool shouldBeginEditing(const DOM::Range &) const;
+  virtual bool shouldBeginEditing(const DOM::RangeImpl *) const;
 
   /**
    * Returns whether editing should end in the given range
    */
-  virtual bool shouldEndEditing(const DOM::Range &) const;
+  virtual bool shouldEndEditing(const DOM::RangeImpl *) const;
 
   /**
    * Returns the contentEditable "override" value for the part
index 7f3344c0e513a5c822f6ed1acf3b5cad2cf66e3f..9f6542473bee013f6bb54303f17a912271584372 100644 (file)
@@ -42,7 +42,6 @@ namespace DOM {
     class HTMLGenericFormElementImpl;
     class HTMLFormElementImpl;
     class HTMLAnchorElementImpl;
-    class Range;
     class NodeImpl;
     class CSSProperty;
 };
index b5b04fd05b005f319a4ec6bfbf2673c3a5b3441a..e9bd8c60b0cd87cfae9587d3035af9c258a5ebee 100644 (file)
 //#define DEBUG_LAYOUT
 //#define BIDI_DEBUG
 
+#include "rendering/render_text.h"
+
 #include "rendering/render_canvas.h"
 #include "rendering/render_object.h"
-#include "rendering/render_text.h"
 #include "rendering/break_lines.h"
-#include "dom/dom2_range.h"
+#include "xml/dom2_rangeimpl.h"
 #include "xml/dom_nodeimpl.h"
 #include "xml/dom_docimpl.h"
 #include "xml/dom_position.h"
@@ -309,11 +310,11 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
         return;
 
     // Determine whether or not we have marked text.
-    Range markedTextRange = KWQ(object()->document()->part())->markedTextRange();
-    bool haveMarkedText = markedTextRange.handle() != 0 && markedTextRange.startContainer() == object()->node();
+    RangeImpl *markedTextRange = KWQ(object()->document()->part())->markedTextRange();
+    int exception = 0;
+    bool haveMarkedText = markedTextRange && markedTextRange->startContainer(exception) == object()->node();
     bool markedTextUsesUnderlines = KWQ(object()->document()->part())->markedTextUsesUnderlines();
 
-
     // Set our font.
     RenderStyle* styleToUse = object()->style(m_firstLine);
     int d = styleToUse->textDecorationsInEffect();
@@ -325,7 +326,7 @@ void InlineTextBox::paint(RenderObject::PaintInfo& i, int tx, int ty)
     // and marked text.
     if ((haveSelection || haveMarkedText) && !markedTextUsesUnderlines && i.phase != PaintActionSelection && !isPrinting) {
         if (haveMarkedText)
-            paintMarkedTextBackground(i.p, tx, ty, styleToUse, font, markedTextRange.startOffset(), markedTextRange.endOffset());
+            paintMarkedTextBackground(i.p, tx, ty, styleToUse, font, markedTextRange->startOffset(exception), markedTextRange->endOffset(exception));
 
         if (haveSelection)
             paintSelection(i.p, tx, ty, styleToUse, font);
index 053e3bdbde1327abbf37f595f00708d317fc09fa..f3fb0f9212c5e608a649ce52a895f7b3c65b9905 100644 (file)
@@ -1369,4 +1369,32 @@ void RangeImpl::formatForDebugger(char *buffer, unsigned length) const
 #undef FormatBufferSize
 #endif
 
+bool operator==(const RangeImpl &a, const RangeImpl &b)
+{
+    if (&a == &b)
+        return true;
+    // Not strictly legal C++, but in practice this can happen, and works fine with GCC.
+    if (!&a || !&b)
+        return false;
+    bool ad = a.isDetached();
+    bool bd = b.isDetached();
+    if (ad && bd)
+        return true;
+    if (ad || bd)
+        return false;
+    int exception = 0;
+    return a.startContainer(exception) == b.startContainer(exception)
+        && a.endContainer(exception) == b.endContainer(exception)
+        && a.startOffset(exception) == b.startOffset(exception)
+        && a.endOffset(exception) == b.endOffset(exception);
+}
+
+SharedPtr<RangeImpl> rangeOfContents(NodeImpl *node)
+{
+    RangeImpl *range = new RangeImpl(node->docPtr());
+    int exception = 0;
+    range->selectNodeContents(node, exception);
+    return SharedPtr<RangeImpl>(range);
+}
+
 }
index b046d69b4a1e28c24d23ea7a322524b0b12ab1ce..570dcc8fbf673e1e2b2a94ccd65542a3d69b91c3 100644 (file)
@@ -124,6 +124,11 @@ private:
     bool containedByReadOnly() const;
 };
 
+khtml::SharedPtr<RangeImpl> rangeOfContents(NodeImpl *node);
+
+bool operator==(const RangeImpl &, const RangeImpl &);
+inline bool operator!=(const RangeImpl &a, const RangeImpl &b) { return !(a == b); }
+
 } // namespace
 
 #endif
index ade77ae0ac65e5050345beb556dfbf8713c6f6fd..55b0539e1aab8813c81cc6f6e466a4a747a59221 100644 (file)
@@ -2466,13 +2466,11 @@ bool DocumentImpl::relinquishesEditingFocus(NodeImpl *node)
     assert(node);
     assert(node->isContentEditable());
 
-    NodeImpl *rootImpl = node->rootEditableElement();
-    if (!part() || !rootImpl)
+    NodeImpl *root = node->rootEditableElement();
+    if (!part() || !root)
         return false;
 
-    Node root(rootImpl);
-    Range range(root, 0, root, rootImpl->childNodeCount());
-    return part()->shouldEndEditing(range);
+    return part()->shouldEndEditing(rangeOfContents(root).get());
 }
 
 bool DocumentImpl::acceptsEditingFocus(NodeImpl *node)
@@ -2480,13 +2478,11 @@ bool DocumentImpl::acceptsEditingFocus(NodeImpl *node)
     assert(node);
     assert(node->isContentEditable());
 
-    NodeImpl *rootImpl = node->rootEditableElement();
-    if (!part() || !rootImpl)
+    NodeImpl *root = node->rootEditableElement();
+    if (!part() || !root)
         return false;
 
-    Node root(rootImpl);
-    Range range(root, 0, root, rootImpl->childNodeCount());
-    return part()->shouldBeginEditing(range);
+    return part()->shouldBeginEditing(rangeOfContents(root).get());
 }
 
 const QValueList<DashboardRegionValue> & DocumentImpl::dashboardRegions() const
@@ -3100,23 +3096,25 @@ DOMString DocumentImpl::queryCommandValue(const DOMString &command)
 
 // ----------------------------------------------------------------------------
 
-void DocumentImpl::addMarker(Range range, DocumentMarker::MarkerType type)
+void DocumentImpl::addMarker(RangeImpl *range, DocumentMarker::MarkerType type)
 {
     // Use a TextIterator to visit the potentially multiple nodes the range covers.
     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
-        Range textPiece = markedText.range();
-        DocumentMarker marker = {type, textPiece.startOffset(), textPiece.endOffset()};
-        addMarker(textPiece.startContainer().handle(), marker);
+        SharedPtr<RangeImpl> textPiece = markedText.range();
+        int exception = 0;
+        DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception)};
+        addMarker(textPiece->startContainer(exception), marker);
     }
 }
 
-void DocumentImpl::removeMarker(Range range, DocumentMarker::MarkerType type)
+void DocumentImpl::removeMarker(RangeImpl *range, DocumentMarker::MarkerType type)
 {
     // Use a TextIterator to visit the potentially multiple nodes the range covers.
     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
-        Range textPiece = markedText.range();
-        DocumentMarker marker = {type, textPiece.startOffset(), textPiece.endOffset()};
-        removeMarker(textPiece.startContainer().handle(), marker);
+        SharedPtr<RangeImpl> textPiece = markedText.range();
+        int exception = 0;
+        DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception)};
+        removeMarker(textPiece->startContainer(exception), marker);
     }
 }
 
index c577eb57a0babc1acf7b386820ef8c65a8480199..e1860656b9ff7da5dc87d909ba1c5eb1113217e2 100644 (file)
@@ -97,7 +97,6 @@ namespace DOM {
     class NodeIteratorImpl;
     class NodeListImpl;
     class ProcessingInstructionImpl;
-    class Range;
     class RangeImpl;
     class RegisteredEventListener;
     class StyleSheetImpl;
@@ -548,8 +547,8 @@ public:
     bool queryCommandSupported(const DOMString &command);
     DOMString queryCommandValue(const DOMString &command);
     
-    void addMarker(Range range, DocumentMarker::MarkerType type);
-    void removeMarker(Range range, DocumentMarker::MarkerType type);
+    void addMarker(RangeImpl *range, DocumentMarker::MarkerType type);
+    void removeMarker(RangeImpl *range, DocumentMarker::MarkerType type);
     void addMarker(NodeImpl *node, DocumentMarker marker);
     void removeMarker(NodeImpl *node, DocumentMarker marker);
     void removeAllMarkers(NodeImpl *node, ulong startOffset, long length);
index d4fefa2791fe801752e0bdfeaae9eb0152fe83bd..0c1a1884414ed8bed7fb220d5072a8c32fa009ac 100644 (file)
@@ -841,13 +841,6 @@ void Position::formatForDebugger(char *buffer, unsigned length) const
 #endif
 
 
-Position startPosition(const Range &r)
-{
-    if (r.isNull() || r.isDetached())
-        return Position();
-    return Position(r.startContainer().handle(), r.startOffset());
-}
-
 Position startPosition(const RangeImpl *r)
 {
     if (!r || r->isDetached())
@@ -856,13 +849,6 @@ Position startPosition(const RangeImpl *r)
     return Position(r->startContainer(exceptionCode), r->startOffset(exceptionCode));
 }
 
-Position endPosition(const Range &r)
-{
-    if (r.isNull() || r.isDetached())
-        return Position();
-    return Position(r.endContainer().handle(), r.endOffset());
-}
-
 Position endPosition(const RangeImpl *r)
 {
     if (!r || r->isDetached())
index 8fc84f8bdbe4d9d59fa85b94e791fc4f404c787d..17fcc432a601c3d16a985db258dd86f8a0aa8fea 100644 (file)
@@ -33,7 +33,6 @@ namespace DOM {
 class CSSComputedStyleDeclarationImpl;
 class ElementImpl;
 class NodeImpl;
-class Range;
 class RangeImpl;
 
 enum EUsingComposedCharacters { NotUsingComposedCharacters = false, UsingComposedCharacters = true };
@@ -117,9 +116,7 @@ inline bool operator!=(const Position &a, const Position &b)
     return !(a == b);
 }
 
-Position startPosition(const Range &);
 Position startPosition(const RangeImpl *);
-Position endPosition(const Range &);
 Position endPosition(const RangeImpl *);
 
 } // namespace DOM
index e42095763a620768ac62dbb4e83cbe90fd9d62aa..bb70574b96a5ee8ca11a7bd7d8ca3d5dc978233c 100644 (file)
@@ -627,12 +627,7 @@ using DOM::NodeImpl;
 
 - (NSString *)href
 {
-    DOMString s = [self _linkElementImpl]->getAttribute(ATTR_HREF);
-    if (!s.isNull()) {
-        Document doc([self _linkElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _linkElementImpl]->href();
 }
 
 - (void)setHref:(NSString *)href
@@ -779,12 +774,7 @@ using DOM::NodeImpl;
 
 - (NSString *)href
 {
-    DOMString s = [self _baseElementImpl]->getAttribute(ATTR_HREF);
-    if (!s.isNull()) {
-        Document doc([self _baseElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _baseElementImpl]->href();
 }
 
 - (void)setHref:(NSString *)href
@@ -1402,12 +1392,7 @@ using DOM::NodeImpl;
 
 - (NSString *)src
 {
-    DOMString s = [self _inputElementImpl]->getAttribute(ATTR_SRC);
-    if (!s.isNull()) {
-        Document doc([self _inputElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _inputElementImpl]->src();
 }
 
 - (void)setSrc:(NSString *)src
@@ -2228,12 +2213,7 @@ using DOM::NodeImpl;
 
 - (NSString *)href
 {
-    DOMString s = [self _anchorElementImpl]->getAttribute(ATTR_HREF);
-    if (!s.isNull()) {
-        Document doc([self _anchorElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _anchorElementImpl]->href();
 }
 
 - (void)setHref:(NSString *)href
@@ -2428,12 +2408,7 @@ using DOM::NodeImpl;
 
 - (NSString *)src
 {
-    DOMString s = [self _imageElementImpl]->getAttribute(ATTR_SRC);
-    if (!s.isNull()) {
-        Document doc([self _imageElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _imageElementImpl]->src();
 }
 
 - (void)setSrc:(NSString *)src
@@ -2901,12 +2876,7 @@ using DOM::NodeImpl;
 
 - (NSString *)href
 {
-    DOMString s = [self _areaElementImpl]->getAttribute(ATTR_HREF);
-    if (!s.isNull()) {
-        Document doc([self _areaElementImpl]->getDocument());
-        s = doc.completeURL(s);
-    }
-    return s;
+    return [self _areaElementImpl]->href();
 }
 
 - (void)setHref:(NSString *)href
index 3b8df8fd47c7d3103246160d3b306949199eeaaf..e99161d66022c62fd5231efba0cc27dcd24e76fc 100644 (file)
@@ -86,7 +86,6 @@ using DOM::HTMLMapElementImpl;
 using DOM::Node;
 using DOM::NodeImpl;
 using DOM::Position;
-using DOM::Range;
 
 using khtml::EAffinity;
 using khtml::EVerticalAlign;
@@ -489,20 +488,9 @@ extern "C" void NSAccessibilityUnregisterUniqueIdForUIElement(id element);
         KHTMLPart* p = d->part();
         if (p) {
             // catch stale KWQAccObject (see <rdar://problem/3960196>)
-            if (p->document().handle() != d)
+            if (p->xmlDocImpl() != d)
                 return nil;
-                
-            Range r(p->document());
-            if (m_renderer->isText()) {
-                r.setStartBefore(e);
-                r.setEndAfter(e);
-                return p->text(r).getNSString();
-            }
-            if (e->firstChild()) {
-                r.setStartBefore(e->firstChild());
-                r.setEndAfter(e->lastChild());
-                return p->text(r).getNSString();
-            }
+            return plainText(rangeOfContents(e).get()).getNSString();
         }
     }
 
@@ -531,7 +519,7 @@ extern "C" void NSAccessibilityUnregisterUniqueIdForUIElement(id element);
         if (startVisiblePosition.isNull() || endVisiblePosition.isNull())
             return nil;
             
-        QString qString   = plainText(makeRange(startVisiblePosition, endVisiblePosition));
+        QString qString = plainText(makeRange(startVisiblePosition, endVisiblePosition).get());
         
         // transform it to a CFString and return that
         return (id)qString.getCFString();
@@ -1114,7 +1102,7 @@ static QRect boundingBoxRect(RenderObject* obj)
         return nil;
     
     // get the visible text in the range
-    QString qString = plainText(makeRange(startVisiblePosition, endVisiblePosition));
+    QString qString = plainText(makeRange(startVisiblePosition, endVisiblePosition).get());
     
     // transform it to a CFString and return that
     return (id)qString.getCFString();
@@ -1430,18 +1418,18 @@ static void AXAttributedStringAppendReplaced (NSMutableAttributedString *attrStr
     
     // iterate over the range to build the AX attributed string
     NSMutableAttributedString *attrString = [[NSMutableAttributedString alloc] init];
-    TextIterator it(makeRange(startVisiblePosition, endVisiblePosition));
+    TextIterator it(makeRange(startVisiblePosition, endVisiblePosition).get());
     while (!it.atEnd()) {
         // locate the node for this range
-        Node node = it.range().startContainer();
-        ASSERT(node == it.range().endContainer());
-        NodeImpl *nodeImpl = node.handle();
+        int exception = 0;
+        NodeImpl *nodeImpl = it.range()->startContainer(exception);
+        ASSERT(nodeImpl == it.range()->endContainer(exception));
         
         // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX)
         if (it.length() != 0) {
             AXAttributedStringAppendText (attrString, nodeImpl, it.characters(), it.length());
         } else {
-            AXAttributedStringAppendReplaced (attrString, nodeImpl->childNode(it.range().startOffset()));
+            AXAttributedStringAppendReplaced (attrString, nodeImpl->childNode(it.range()->startOffset(exception)));
         }
         
         it.advance();
index 72f83e7630d526c3ed1a963c028759790aa25e78..569f2e8ed2b24deeaff2aea1c4f3a73e9c79ef78 100644 (file)
@@ -29,7 +29,6 @@
 #import "khtml_part.h"
 
 #import "dom_nodeimpl.h"
-#import "dom2_range.h"
 
 #import "WebCoreKeyboardAccess.h"
 
@@ -343,8 +342,8 @@ public:
     void respondToChangedSelection(const khtml::Selection &oldSelection, bool closeTyping);
     void respondToChangedContents();
     virtual bool isContentEditable() const;
-    virtual bool shouldBeginEditing(const DOM::Range &) const;
-    virtual bool shouldEndEditing(const DOM::Range &) const;
+    virtual bool shouldBeginEditing(const DOM::RangeImpl *) const;
+    virtual bool shouldEndEditing(const DOM::RangeImpl *) const;
 
     KJS::Bindings::RootObject *executionContextForDOM();
     KJS::Bindings::RootObject *bindingRootObject();
@@ -370,8 +369,8 @@ public:
         bool thick;
     };
     
-    void setMarkedTextRange(const DOM::Range &, NSArray *attributes, NSArray *ranges);
-    DOM::Range markedTextRange() const;
+    void setMarkedTextRange(const DOM::RangeImpl *, NSArray *attributes, NSArray *ranges);
+    DOM::RangeImpl *markedTextRange() const { return m_markedTextRange.get(); }
     bool markedTextUsesUnderlines() const;
     QValueList<MarkedTextUnderline> markedTextUnderlines() const;
 
@@ -473,7 +472,7 @@ private:
     
     mutable khtml::SharedPtr<DOM::NodeImpl> _elementToDraw;
 
-    DOM::Range m_markedTextRange;
+    khtml::SharedPtr<DOM::RangeImpl> m_markedTextRange;
     bool m_markedTextUsesUnderlines;
     QValueList<MarkedTextUnderline> m_markedTextUnderlines;
 
index ac7d4db4c85d7f6640ab4e07e116ea5f2a4f4aa5..7a45310469f18b5753c9793b314e3b36fa6cce5f 100644 (file)
@@ -139,6 +139,7 @@ using khtml::Selection;
 using khtml::setEnd;
 using khtml::setStart;
 using khtml::ShadowData;
+using khtml::SharedPtr;
 using khtml::startOfWord;
 using khtml::startVisiblePosition;
 using khtml::StyleDashboardRegion;
@@ -609,33 +610,33 @@ bool KWQKHTMLPart::findString(NSString *string, bool forward, bool caseFlag, boo
     }
 
     // Start on the correct edge of the selection, search to edge of document.
-    Range searchRange(xmlDocImpl());
-    searchRange.selectNodeContents(xmlDocImpl());
+    SharedPtr<RangeImpl> searchRange(rangeOfContents(xmlDocImpl()));
     if (selectionStart()) {
         if (forward) {
-            setStart(searchRange, VisiblePosition(findInSelection ? selection().start() : selection().end(), selection().endAffinity()));
+            setStart(searchRange.get(), VisiblePosition(findInSelection ? selection().start() : selection().end(), selection().endAffinity()));
         } else {
-            setEnd(searchRange, VisiblePosition(findInSelection ? selection().end() : selection().start(), selection().startAffinity()));
+            setEnd(searchRange.get(), VisiblePosition(findInSelection ? selection().end() : selection().start(), selection().startAffinity()));
         }
     }
 
     // Do the search once, then do it a second time to handle wrapped search.
     // Searches some or all of document twice in the failure case, but that's probably OK.
-    Range resultRange = findPlainText(searchRange, target, forward, caseFlag);
-    if (resultRange.collapsed() && wrapFlag) {
-        searchRange.selectNodeContents(xmlDocImpl());
-        resultRange = findPlainText(searchRange, target, forward, caseFlag);
+    SharedPtr<RangeImpl> resultRange(findPlainText(searchRange.get(), target, forward, caseFlag));
+    int exception = 0;
+    if (resultRange->collapsed(exception) && wrapFlag) {
+        searchRange = rangeOfContents(xmlDocImpl());
+        resultRange = findPlainText(searchRange.get(), target, forward, caseFlag);
         // If we got back to the same place we started, that doesn't count as success.
-        if (resultRange == selection().toRange()) {
+        if (*resultRange == *selection().toRange()) {
             return false;
         }
     }
 
-    if (resultRange.collapsed()) {
+    if (resultRange->collapsed(exception)) {
         return false;
     }
 
-    setSelection(Selection(resultRange, DOWNSTREAM, khtml::SEL_PREFER_UPSTREAM_AFFINITY));
+    setSelection(Selection(resultRange.get(), DOWNSTREAM, khtml::SEL_PREFER_UPSTREAM_AFFINITY));
     jumpToSelection();
     return true;
 }
@@ -921,13 +922,14 @@ void KWQKHTMLPart::jumpToSelection()
 
 QString KWQKHTMLPart::advanceToNextMisspelling(bool startBeforeSelection)
 {
+    int exception = 0;
+
     // The basic approach is to search in two phases - from the selection end to the end of the doc, and
     // then we wrap and search from the doc start to (approximately) where we started.
     
     // Start at the end of the selection, search to edge of document.  Starting at the selection end makes
     // repeated "check spelling" commands work.
-    Range searchRange(xmlDocImpl());
-    searchRange.selectNodeContents(xmlDocImpl());
+    SharedPtr<RangeImpl> searchRange(rangeOfContents(xmlDocImpl()));
     bool startedWithSelection = false;
     if (selectionStart()) {
         startedWithSelection = true;
@@ -935,49 +937,49 @@ QString KWQKHTMLPart::advanceToNextMisspelling(bool startBeforeSelection)
             VisiblePosition start(selection().start(), selection().startAffinity());
             // We match AppKit's rule: Start 1 character before the selection.
             VisiblePosition oneBeforeStart = start.previous();
-            setStart(searchRange, oneBeforeStart.isNotNull() ? oneBeforeStart : start);
+            setStart(searchRange.get(), oneBeforeStart.isNotNull() ? oneBeforeStart : start);
         } else {
-            setStart(searchRange, VisiblePosition(selection().end(), selection().endAffinity()));
+            setStart(searchRange.get(), VisiblePosition(selection().end(), selection().endAffinity()));
         }
     }
 
     // If we're not in an editable node, try to find one, make that our range to work in
-    NodeImpl *editableNodeImpl = searchRange.startContainer().handle();
+    NodeImpl *editableNodeImpl = searchRange->startContainer(exception);
     if (!editableNodeImpl->isContentEditable()) {
         editableNodeImpl = editableNodeImpl->nextEditable();
         if (!editableNodeImpl) {
             return QString();
         }
-        searchRange.setStartBefore(editableNodeImpl);
+        searchRange->setStartBefore(editableNodeImpl, exception);
         startedWithSelection = false;   // won't need to wrap
     }
     
     // topNode defines the whole range we want to operate on 
     NodeImpl *topNode = editableNodeImpl->rootEditableElement();
-    searchRange.setEndAfter(topNode);
+    searchRange->setEndAfter(topNode, exception);
 
     // Make sure start of searchRange is not in the middle of a word.  Jumping back a char and then
     // forward by a word happens to do the trick.
     if (startedWithSelection) {
-        VisiblePosition oneBeforeStart = startVisiblePosition(searchRange, DOWNSTREAM).previous();
+        VisiblePosition oneBeforeStart = startVisiblePosition(searchRange.get(), DOWNSTREAM).previous();
         if (oneBeforeStart.isNotNull()) {
-            setStart(searchRange, endOfWord(oneBeforeStart));
+            setStart(searchRange.get(), endOfWord(oneBeforeStart));
         } // else we were already at the start of the editable node
     }
     
-    if (searchRange.collapsed()) {
+    if (searchRange->collapsed(exception)) {
         return QString();       // nothing to search in
     }
     
     NSSpellChecker *checker = [NSSpellChecker sharedSpellChecker];
-    WordAwareIterator it(searchRange);
+    WordAwareIterator it(searchRange.get());
     bool wrapped = false;
     
     // We go to the end of our first range instead of the start of it, just to be sure
     // we don't get foiled by any word boundary problems at the start.  It means we might
     // do a tiny bit more searching.
-    NodeImpl *searchEndAfterWrapNode = it.range().endContainer().handle();
-    long searchEndAfterWrapOffset = it.range().endOffset();
+    NodeImpl *searchEndAfterWrapNode = it.range()->endContainer(exception);
+    long searchEndAfterWrapOffset = it.range()->endOffset(exception);
 
     while (1) {
         if (!it.atEnd()) {      // we may be starting at the end of the doc, and already by atEnd
@@ -990,17 +992,17 @@ QString KWQKHTMLPart::advanceToNextMisspelling(bool startBeforeSelection)
                 if (misspelling.length > 0) {
                     // Build up result range and string.  Note the misspelling may span many text nodes,
                     // but the CharIterator insulates us from this complexity
-                    Range misspellingRange(xmlDocImpl());
-                    CharacterIterator chars(it.range());
+                    SharedPtr<RangeImpl> misspellingRange(rangeOfContents(xmlDocImpl()));
+                    CharacterIterator chars(it.range().get());
                     chars.advance(misspelling.location);
-                    misspellingRange.setStart(chars.range().startContainer(), chars.range().startOffset());
+                    misspellingRange->setStart(chars.range()->startContainer(exception), chars.range()->startOffset(exception), exception);
                     QString result = chars.string(misspelling.length);
-                    misspellingRange.setEnd(chars.range().startContainer(), chars.range().startOffset());
+                    misspellingRange->setEnd(chars.range()->startContainer(exception), chars.range()->startOffset(exception), exception);
 
-                    setSelection(Selection(misspellingRange, DOWNSTREAM, khtml::SEL_PREFER_UPSTREAM_AFFINITY));
+                    setSelection(Selection(misspellingRange.get(), DOWNSTREAM, khtml::SEL_PREFER_UPSTREAM_AFFINITY));
                     jumpToSelection();
                     // Mark misspelling in document.
-                    xmlDocImpl()->addMarker(misspellingRange, DocumentMarker::Spelling);
+                    xmlDocImpl()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
                     return result;
                 }
             }
@@ -1013,10 +1015,10 @@ QString KWQKHTMLPart::advanceToNextMisspelling(bool startBeforeSelection)
             } else {
                 // we've gone from the selection to the end of doc, now wrap around
                 wrapped = YES;
-                searchRange.setStartBefore(topNode);
+                searchRange->setStartBefore(topNode, exception);
                 // going until the end of the very first chunk we tested is far enough
-                searchRange.setEnd(searchEndAfterWrapNode, searchEndAfterWrapOffset);
-                it = WordAwareIterator(searchRange);
+                searchRange->setEnd(searchEndAfterWrapNode, searchEndAfterWrapOffset, exception);
+                it = WordAwareIterator(searchRange.get());
             }
         }   
     }
@@ -3520,8 +3522,7 @@ NSFont *KWQKHTMLPart::fontForSelection(bool *hasMultipleFonts) const
 
     NSFont *font = nil;
 
-    Range r = d->m_selection.toRange();
-    RangeImpl *range = r.handle();
+    SharedPtr<RangeImpl> range = d->m_selection.toRange();
     NodeImpl *startNode = range->editingStartPosition().node();
     if (startNode != nil) {
         NodeImpl *pastEnd = range->pastEndNode();
@@ -3999,17 +4000,18 @@ void KWQKHTMLPart::markMisspellings(const Selection &selection)
     if (![_bridge isContinuousSpellCheckingEnabled])
         return;
 
-    Range searchRange(selection.toRange());
-    if (searchRange.isNull() || searchRange.isDetached())
+    SharedPtr<RangeImpl> searchRange(selection.toRange());
+    if (searchRange.get() || searchRange->isDetached())
         return;
     
     // If we're not in an editable node, bail.
-    NodeImpl *editableNodeImpl = searchRange.startContainer().handle();
+    int exception = 0;
+    NodeImpl *editableNodeImpl = searchRange->startContainer(exception);
     if (!editableNodeImpl->isContentEditable())
         return;
     
     NSSpellChecker *checker = [NSSpellChecker sharedSpellChecker];
-    WordAwareIterator it(searchRange);
+    WordAwareIterator it(searchRange.get());
     
     while (!it.atEnd()) {      // we may be starting at the end of the doc, and already by atEnd
         const QChar *chars = it.characters();
@@ -4026,14 +4028,14 @@ void KWQKHTMLPart::markMisspellings(const Selection &selection)
                 else {
                     // Build up result range and string.  Note the misspelling may span many text nodes,
                     // but the CharIterator insulates us from this complexity
-                    Range misspellingRange(xmlDocImpl());
-                    CharacterIterator chars(it.range());
+                    SharedPtr<RangeImpl> misspellingRange(rangeOfContents(xmlDocImpl()));
+                    CharacterIterator chars(it.range().get());
                     chars.advance(misspelling.location);
-                    misspellingRange.setStart(chars.range().startContainer(), chars.range().startOffset());
+                    misspellingRange->setStart(chars.range()->startContainer(exception), chars.range()->startOffset(exception), exception);
                     chars.advance(misspelling.length);
-                    misspellingRange.setEnd(chars.range().startContainer(), chars.range().startOffset());
+                    misspellingRange->setEnd(chars.range()->startContainer(exception), chars.range()->startOffset(exception), exception);
                     // Mark misspelling in document.
-                    xmlDocImpl()->addMarker(misspellingRange, DocumentMarker::Spelling);
+                    xmlDocImpl()->addMarker(misspellingRange.get(), DocumentMarker::Spelling);
                     startIndex = misspelling.location + misspelling.length;
                 }
             }
@@ -4069,7 +4071,7 @@ void KWQKHTMLPart::respondToChangedSelection(const Selection &oldSelection, bool
 
                 // This only erases a marker in the first word of the selection.
                 // Perhaps peculiar, but it matches AppKit.
-                xmlDocImpl()->removeMarker(newAdjacentWords.toRange(), DocumentMarker::Spelling);
+                xmlDocImpl()->removeMarker(newAdjacentWords.toRange().get(), DocumentMarker::Spelling);
             }
         } else {
             // When continuous spell checking is off, no markers appear after the selection changes.
@@ -4095,28 +4097,24 @@ bool KWQKHTMLPart::isContentEditable() const
     return KHTMLPart::isContentEditable() || [_bridge isEditable];
 }
 
-bool KWQKHTMLPart::shouldBeginEditing(const Range &range) const
+bool KWQKHTMLPart::shouldBeginEditing(const RangeImpl *range) const
 {
-    ASSERT(!range.isNull());
-    return [_bridge shouldBeginEditing:[DOMRange _rangeWithImpl:range.handle()]];
+    ASSERT(range);
+    return [_bridge shouldBeginEditing:[DOMRange _rangeWithImpl:const_cast<RangeImpl *>(range)]];
 }
 
-bool KWQKHTMLPart::shouldEndEditing(const Range &range) const
+bool KWQKHTMLPart::shouldEndEditing(const RangeImpl *range) const
 {
-    ASSERT(!range.isNull());
-    return [_bridge shouldEndEditing:[DOMRange _rangeWithImpl:range.handle()]];
+    ASSERT(range);
+    return [_bridge shouldEndEditing:[DOMRange _rangeWithImpl:const_cast<RangeImpl *>(range)]];
 }
 
-DOM::Range KWQKHTMLPart::markedTextRange() const
-{
-    return m_markedTextRange;
-}
-
-static QValueList<KWQKHTMLPart::MarkedTextUnderline> convertAttributesToUnderlines(const DOM::Range &markedTextRange, NSArray *attributes, NSArray *ranges)
+static QValueList<KWQKHTMLPart::MarkedTextUnderline> convertAttributesToUnderlines(const DOM::RangeImpl *markedTextRange, NSArray *attributes, NSArray *ranges)
 {
     QValueList<KWQKHTMLPart::MarkedTextUnderline> result;
 
-    int baseOffset = markedTextRange.startOffset();
+    int exception = 0;
+    int baseOffset = markedTextRange->startOffset(exception);
 
     unsigned length = [attributes count];
     ASSERT([ranges count] == length);
@@ -4145,10 +4143,12 @@ static QValueList<KWQKHTMLPart::MarkedTextUnderline> convertAttributesToUnderlin
     return result;
 }
 
-void KWQKHTMLPart::setMarkedTextRange(const DOM::Range &range, NSArray *attributes, NSArray *ranges)
+void KWQKHTMLPart::setMarkedTextRange(const DOM::RangeImpl *range, NSArray *attributes, NSArray *ranges)
 {
-    ASSERT(!range.handle() || range.startContainer() == range.endContainer());
-    ASSERT(!range.handle() || range.collapsed() || range.startContainer().nodeType() == Node::TEXT_NODE);
+    int exception = 0;
+
+    ASSERT(!range || range->startContainer(exception) == range->endContainer(exception));
+    ASSERT(!range || range->collapsed(exception) || range->startContainer(exception)->nodeType() == Node::TEXT_NODE);
 
     if (attributes == nil) {
         m_markedTextUsesUnderlines = false;
@@ -4158,20 +4158,18 @@ void KWQKHTMLPart::setMarkedTextRange(const DOM::Range &range, NSArray *attribut
         m_markedTextUnderlines = convertAttributesToUnderlines(range, attributes, ranges);
     }
 
-    if (m_markedTextRange.handle() && xmlDocImpl() 
-       && m_markedTextRange.startContainer().handle()->renderer()) {
-       m_markedTextRange.startContainer().handle()->renderer()->repaint();
+    if (m_markedTextRange.get() && xmlDocImpl() && m_markedTextRange->startContainer(exception)->renderer()) {
+       m_markedTextRange->startContainer(exception)->renderer()->repaint();
     }
 
-    if ( range.handle() && range.collapsed() ) {
-        m_markedTextRange = DOM::Range(0);
+    if ( range && range->collapsed(exception) ) {
+        m_markedTextRange.reset();
     } else {
-        m_markedTextRange = range;
+        m_markedTextRange.reset(const_cast<RangeImpl *>(range));
     }
 
-    if (m_markedTextRange.handle() && xmlDocImpl() 
-       && m_markedTextRange.startContainer().handle()->renderer()) {
-       m_markedTextRange.startContainer().handle()->renderer()->repaint();
+    if (m_markedTextRange.get() && xmlDocImpl() && m_markedTextRange->startContainer(exception)->renderer()) {
+       m_markedTextRange->startContainer(exception)->renderer()->repaint();
     }
 }
 
index d44da82bcc0b830d8d6a71b5063da7b67b059d60..4bd41fe199137aecf6839aef704308e78e0a44dd 100644 (file)
@@ -105,7 +105,7 @@ using DOM::HTMLImageElementImpl;
 using DOM::HTMLInputElementImpl;
 using DOM::NodeImpl;
 using DOM::Position;
-using DOM::Range;
+using DOM::RangeImpl;
 
 using khtml::ChildrenOnly;
 using khtml::createMarkup;
@@ -127,6 +127,7 @@ using khtml::RenderStyle;
 using khtml::RenderWidget;
 using khtml::ReplaceSelectionCommand;
 using khtml::Selection;
+using khtml::SharedPtr;
 using khtml::setAffinityUsingLinePosition;
 using khtml::Tokenizer;
 using khtml::TextIterator;
@@ -1054,14 +1055,9 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
         
         const AtomicString& link = e->getAttribute(ATTR_HREF);
         if (!link.isNull()) {
-            if (e->firstChild()) {
-                Range r(doc);
-                r.setStartBefore(e->firstChild());
-                r.setEndAfter(e->lastChild());
-                QString t = _part->text(r);
-                if (!t.isEmpty()) {
-                    [element setObject:t.getNSString() forKey:WebCoreElementLinkLabelKey];
-                }
+            QString t = plainText(rangeOfContents(e).get());
+            if (!t.isEmpty()) {
+                [element setObject:t.getNSString() forKey:WebCoreElementLinkLabelKey];
             }
             QString URLString = parseURL(link).string();
             [element setObject:doc->completeURL(URLString).getNSString() forKey:WebCoreElementLinkURLKey];
@@ -1490,7 +1486,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     // NOTE: The enums *must* match the very similar ones declared in ktml_selection.h
     Selection selection(_part->selection());
     selection.expandUsingGranularity(static_cast<ETextGranularity>(granularity));
-    return [DOMRange _rangeWithImpl:selection.toRange().handle()];
+    return [DOMRange _rangeWithImpl:selection.toRange().get()];
 }
 
 - (DOMRange *)rangeByAlteringCurrentSelection:(WebSelectionAlteration)alteration direction:(WebSelectionDirection)direction granularity:(WebSelectionGranularity)granularity
@@ -1503,7 +1499,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     selection.modify(static_cast<Selection::EAlter>(alteration), 
                      static_cast<Selection::EDirection>(direction), 
                      static_cast<ETextGranularity>(granularity));
-    return [DOMRange _rangeWithImpl:selection.toRange().handle()];
+    return [DOMRange _rangeWithImpl:selection.toRange().get()];
 }
 
 - (void)alterCurrentSelection:(WebSelectionAlteration)alteration direction:(WebSelectionDirection)direction granularity:(WebSelectionGranularity)granularity
@@ -1560,7 +1556,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
         
     Selection selection(_part->selection());
     selection.modify(static_cast<Selection::EAlter>(alteration), static_cast<int>(verticalDistance));
-    return [DOMRange _rangeWithImpl:selection.toRange().handle()];
+    return [DOMRange _rangeWithImpl:selection.toRange().get()];
 }
 
 - (void)alterCurrentSelection:(WebSelectionAlteration)alteration verticalDistance:(float)verticalDistance
@@ -1624,57 +1620,45 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
 
 - (DOMRange *)selectedDOMRange
 {
-    return [DOMRange _rangeWithImpl:_part->selection().toRange().handle()];
+    return [DOMRange _rangeWithImpl:_part->selection().toRange().get()];
 }
 
-- (NSRange)convertToNSRange:(DOM::RangeImpl *)drange
+- (NSRange)convertToNSRange:(DOM::RangeImpl *)range
 {
-    if (!drange) {
+    if (!range || range->isDetached()) {
         return NSMakeRange(NSNotFound, 0);
     }
 
-    Range toStartRange, toEndRange;
-    Range actualRange = Range(drange);
-    long startPosition, endPosition;
+    SharedPtr<RangeImpl> fromStartRange(_part->xmlDocImpl()->createRange());
+    int exception = 0;
+
+    fromStartRange->setEnd(range->startContainer(exception), range->startOffset(exception), exception);
+    long startPosition = TextIterator::rangeLength(fromStartRange.get());
+
+    fromStartRange->setEnd(range->endContainer(exception), range->endOffset(exception), exception);
+    long endPosition = TextIterator::rangeLength(fromStartRange.get());
 
-    toStartRange = Range (_part->xmlDocImpl()->createRange());
-    toStartRange.setEnd (actualRange.startContainer(), actualRange.startOffset());
-    toEndRange = Range (_part->xmlDocImpl()->createRange());
-    toEndRange.setEnd (actualRange.endContainer(), actualRange.endOffset());
-    
-    startPosition = TextIterator::rangeLength (toStartRange);
-    endPosition = TextIterator::rangeLength (toEndRange);
-    
     return NSMakeRange(startPosition, endPosition - startPosition);
 }
 
-- (DOM::Range)convertToDOMRange:(NSRange)nsrange
+- (RangeImpl *)convertToDOMRange:(NSRange)nsrange
 {
-    // Set the range to cover the entire document.  This assumes that the start
-    // and end node of the range are the document node.
-    DOM::Range docRange = Range (_part->xmlDocImpl()->createRange());
-    docRange.setEnd (docRange.endContainer(), docRange.endContainer().handle()->childNodeCount());
-
-    DOM::Range resultRange = Range (_part->xmlDocImpl()->createRange());
-    TextIterator::setRangeFromLocationAndLength (docRange, resultRange, nsrange.location, nsrange.length);
-    
-    return resultRange;
+    return TextIterator::rangeFromLocationAndLength(_part->xmlDocImpl(), nsrange.location, nsrange.length);
 }
 
 - (DOMRange *)convertToObjCDOMRange:(NSRange)nsrange
 {
-    return [DOMRange _rangeWithImpl:[self convertToDOMRange:nsrange].handle()];
+    return [DOMRange _rangeWithImpl:[self convertToDOMRange:nsrange]];
 }
 
 - (void)selectNSRange:(NSRange)range
 {
-    DOM::Range replaceRange = [self convertToDOMRange:range];
-    _part->setSelection(Selection(replaceRange.handle(), khtml::SEL_DEFAULT_AFFINITY, khtml::SEL_DEFAULT_AFFINITY));
+    _part->setSelection(Selection([self convertToDOMRange:range], khtml::SEL_DEFAULT_AFFINITY, khtml::SEL_DEFAULT_AFFINITY));
 }
 
 - (NSRange)selectedNSRange
 {
-    return [self convertToNSRange:_part->selection().toRange().handle()];
+    return [self convertToNSRange:_part->selection().toRange().get()];
 }
 
 - (NSSelectionAffinity)selectionAffinity
@@ -1689,7 +1673,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
 
 - (DOMRange *)markDOMRange
 {
-    return [DOMRange _rangeWithImpl:_part->mark().toRange().handle()];
+    return [DOMRange _rangeWithImpl:_part->mark().toRange().get()];
 }
 
 - (void)setMarkedTextDOMRange:(DOMRange *)range customAttributes:(NSArray *)attributes ranges:(NSArray *)ranges
@@ -1699,12 +1683,12 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
 
 - (DOMRange *)markedTextDOMRange
 {
-    return [DOMRange _rangeWithImpl:_part->markedTextRange().handle()];
+    return [DOMRange _rangeWithImpl:_part->markedTextRange()];
 }
 
 - (NSRange)markedTextNSRange
 {
-    return [self convertToNSRange:_part->markedTextRange().handle()];
+    return [self convertToNSRange:_part->markedTextRange()];
 }
 
 - (void)replaceMarkedTextWithText:(NSString *)text
@@ -1712,8 +1696,10 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     if (!partHasSelection(self))
         return;
     
-    Range markedTextRange = _part->markedTextRange();
-    if (!markedTextRange.isNull() && !markedTextRange.collapsed())
+    int exception = 0;
+
+    RangeImpl *markedTextRange = _part->markedTextRange();
+    if (markedTextRange && !markedTextRange->collapsed(exception))
         TypingCommand::deleteKeyPressed(_part->xmlDocImpl(), NO);
     
     if ([text length] > 0)
@@ -1765,7 +1751,11 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     if (newEnd.isNull())
         newEnd = end;
 
-    return [DOMRange _rangeWithImpl:Range(newStart.node(), newStart.offset(), newEnd.node(), newEnd.offset()).handle()];
+    RangeImpl *range = _part->xmlDocImpl()->createRange();
+    int exception = 0;
+    range->setStart(newStart.node(), newStart.offset(), exception);
+    range->setEnd(newStart.node(), newStart.offset(), exception);
+    return [DOMRange _rangeWithImpl:range];
 }
 
 // Determines whether whitespace needs to be added around aString to preserve proper spacing and
@@ -1952,13 +1942,13 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
 
 - (DOMRange *)dragCaretDOMRange
 {
-    return [DOMRange _rangeWithImpl:_part->dragCaret().toRange().handle()];
+    return [DOMRange _rangeWithImpl:_part->dragCaret().toRange().get()];
 }
 
 - (DOMRange *)editableDOMRangeForPoint:(NSPoint)point
 {
     VisiblePosition position = [self _visiblePositionForPoint:point];
-    return position.isNull() ? nil : [DOMRange _rangeWithImpl:Selection(position).toRange().handle()];
+    return position.isNull() ? nil : [DOMRange _rangeWithImpl:Selection(position).toRange().get()];
 }
 
 - (void)deleteSelectionWithSmartDelete:(BOOL)smartDelete
@@ -2270,7 +2260,7 @@ static HTMLFormElementImpl *formElementFromDOMElement(DOMElement *element)
     if (caret == next || caret == previous)
         return nil;
 
-    return [DOMRange _rangeWithImpl:makeRange(previous, next).handle()];
+    return [DOMRange _rangeWithImpl:makeRange(previous, next).get()];
 }
 
 - (NSMutableDictionary *)dashboardRegions