+2004-09-22 Darin Adler <darin@apple.com>
+
+ - renamed
+
+ DOM::CaretPosition -> khtml::VisibleRange
+ DOM::Selection -> khtml::Selection
+
+ - moved all the functions in visible_units.h from DOM to khtml namespace
+ - moved the one thing from Selection that KHTMLPart uses into its own header
+
+ * WebCore.pbproj/project.pbxproj: Added text_granularity.h.
+
+ * ForwardingHeaders/editing/selection.h: Added.
+ * WebCore-combined.exp: Regenerated.
+ * WebCore-tests.exp: Updated symbol for DOM::Selection debugging.
+
+ * khtml/ecma/kjs_window.cpp: Update names and namespaces.
+ * khtml/editing/htmlediting.cpp: Ditto.
+ * khtml/editing/htmlediting.h: Ditto.
+ * khtml/editing/htmlediting_impl.cpp: Ditto.
+ * khtml/editing/htmlediting_impl.h: Ditto.
+ * khtml/editing/jsediting.cpp: Ditto.
+ * khtml/editing/selection.cpp: Ditto.
+ * khtml/editing/selection.h: Ditto.
+ * khtml/editing/visible_position.cpp: Ditto.
+ * khtml/editing/visible_position.h: Ditto.
+ * khtml/editing/visible_text.h: Ditto.
+ * khtml/editing/visible_units.cpp: Ditto.
+ * khtml/editing/visible_units.h: Ditto.
+ * khtml/khtml_part.cpp: Ditto.
+ * khtml/khtml_part.h: Ditto.
+ * khtml/khtmlpart_p.h: Ditto.
+ * khtml/rendering/render_block.cpp: Ditto.
+ * khtml/xml/dom_docimpl.h: Ditto.
+ * khtml/xml/dom_nodeimpl.cpp: Ditto.
+ * kwq/KWQKHTMLPart.h: Ditto.
+ * kwq/KWQKHTMLPart.mm: Ditto.
+ * kwq/KWQRenderTreeDebug.cpp: Ditto.
+ * kwq/WebCoreBridge.mm: Ditto.
+
2004-09-22 Darin Adler <darin@apple.com>
* ForwardingHeaders/*: Use import instead of include.
--- /dev/null
+#import <selection.h>
__ZNK3DOM8Position17formatForDebuggerEPcj
__ZNK3DOM8TextImpl17formatForDebuggerEPcj
__ZNK3DOM9RangeImpl17formatForDebuggerEPcj
-__ZNK3DOM9Selection17formatForDebuggerEPcj
__ZNK4KURL3refEv
__ZNK4KURL3urlEv
__ZNK4KURL4hostEv
__ZNK5QSize7isValidEv
__ZNK5QTime4msecEv
__ZNK5QTime7elapsedEv
+__ZNK5khtml9Selection17formatForDebuggerEPcj
__ZNK7QRegExp5matchERK7QStringiPi
__ZNK7QRegExp7patternEv
__ZNK7QString10startsWithEPKc
__ZNK3DOM8Position17formatForDebuggerEPcj
__ZNK3DOM8TextImpl17formatForDebuggerEPcj
__ZNK3DOM9RangeImpl17formatForDebuggerEPcj
-__ZNK3DOM9Selection17formatForDebuggerEPcj
__ZNK4KURL3refEv
__ZNK4KURL3urlEv
__ZNK4KURL4hostEv
__ZNK5QSize7isValidEv
__ZNK5QTime4msecEv
__ZNK5QTime7elapsedEv
+__ZNK5khtml9Selection17formatForDebuggerEPcj
__ZNK7QRegExp5matchERK7QStringiPi
__ZNK7QRegExp7patternEv
__ZNK7QString10startsWithEPKc
93ABE071070285F600BD91F9,
93ABE073070285F600BD91F9,
93ABE075070285F600BD91F9,
+ 932B9835070297DC0032804F,
);
isa = PBXHeadersBuildPhase;
runOnlyForDeploymentPostprocessing = 0;
settings = {
};
};
+ 932B9834070297DC0032804F = {
+ fileEncoding = 30;
+ isa = PBXFileReference;
+ lastKnownFileType = sourcecode.c.h;
+ name = text_granularity.h;
+ path = editing/text_granularity.h;
+ refType = 4;
+ sourceTree = "<group>";
+ };
+ 932B9835070297DC0032804F = {
+ fileRef = 932B9834070297DC0032804F;
+ isa = PBXBuildFile;
+ settings = {
+ };
+ };
93386B90037045B3008635CE = {
fileEncoding = 4;
isa = PBXFileReference;
};
BEB1DD0805C197DF00DD1F43 = {
children = (
- BE9185E005EE59B80081354D,
BE9185DD05EE59B80081354D,
+ BE9185E005EE59B80081354D,
BE9185DE05EE59B80081354D,
BE9185DF05EE59B80081354D,
BE02D4E6066F908A0076809F,
BE02D4E7066F908A0076809F,
93ABE067070285F600BD91F9,
93ABE066070285F600BD91F9,
+ 932B9834070297DC0032804F,
93ABE069070285F600BD91F9,
93ABE068070285F600BD91F9,
93ABE06B070285F600BD91F9,
#include "dom/dom_string.h"
#include "dom/dom_node.h"
#include "editing/htmlediting.h"
+#include "editing/selection.h"
#include "xml/dom2_eventsimpl.h"
#include "xml/dom_docimpl.h"
#include "xml/dom_position.h"
return Boolean(!m_part->selection().isRange());
case _Type: {
switch (m_part->selection().state()) {
- case DOM::Selection::NONE:
+ case khtml::Selection::NONE:
return String("None");
- case DOM::Selection::CARET:
+ case khtml::Selection::CARET:
return String("Caret");
- case DOM::Selection::RANGE:
+ case khtml::Selection::RANGE:
return String("Range");
}
}
switch (id) {
case Selection::Collapse:
TypingCommand::closeTyping(part->lastEditCommand());
- part->setSelection(DOM::Selection(Position(KJS::toNode(args[0]).handle(), args[1].toInt32(exec))));
+ part->setSelection(khtml::Selection(Position(KJS::toNode(args[0]).handle(), args[1].toInt32(exec))));
break;
case Selection::CollapseToEnd:
TypingCommand::closeTyping(part->lastEditCommand());
- part->setSelection(DOM::Selection(part->selection().end()));
+ part->setSelection(khtml::Selection(part->selection().end()));
break;
case Selection::CollapseToStart:
TypingCommand::closeTyping(part->lastEditCommand());
- part->setSelection(DOM::Selection(part->selection().start()));
+ part->setSelection(khtml::Selection(part->selection().start()));
break;
case Selection::Empty:
TypingCommand::closeTyping(part->lastEditCommand());
TypingCommand::closeTyping(part->lastEditCommand());
Position base(KJS::toNode(args[0]).handle(), args[1].toInt32(exec));
Position extent(KJS::toNode(args[2]).handle(), args[3].toInt32(exec));
- part->setSelection(DOM::Selection(base, extent));
+ part->setSelection(khtml::Selection(base, extent));
break;
}
case Selection::SetPosition:
TypingCommand::closeTyping(part->lastEditCommand());
- part->setSelection(DOM::Selection(Position(KJS::toNode(args[0]).handle(), args[1].toInt32(exec))));
+ part->setSelection(khtml::Selection(Position(KJS::toNode(args[0]).handle(), args[1].toInt32(exec))));
break;
case Selection::Modify: {
TypingCommand::closeTyping(part->lastEditCommand());
- DOM::Selection s(part->selection());
- DOM::Selection::EAlter alter = DOM::Selection::MOVE;
+ khtml::Selection s(part->selection());
+ khtml::Selection::EAlter alter = khtml::Selection::MOVE;
if (args[0].toString(exec).string().lower() == "extend")
- alter = DOM::Selection::EXTEND;
+ alter = khtml::Selection::EXTEND;
DOMString directionString = args[1].toString(exec).string().lower();
- DOM::Selection::EDirection direction = DOM::Selection::FORWARD;
+ khtml::Selection::EDirection direction = khtml::Selection::FORWARD;
if (directionString == "backward")
- direction = DOM::Selection::BACKWARD;
+ direction = khtml::Selection::BACKWARD;
else if (directionString == "left")
- direction = DOM::Selection::LEFT;
+ direction = khtml::Selection::LEFT;
if (directionString == "right")
- direction = DOM::Selection::RIGHT;
- DOM::Selection::ETextGranularity granularity = DOM::Selection::CHARACTER;
+ direction = khtml::Selection::RIGHT;
+ khtml::ETextGranularity granularity = khtml::CHARACTER;
DOMString granularityString = args[2].toString(exec).string().lower();
if (granularityString == "word")
- granularity = DOM::Selection::WORD;
+ granularity = khtml::WORD;
else if (granularityString == "line")
- granularity = DOM::Selection::LINE;
+ granularity = khtml::LINE;
+ else if (granularityString == "pargraph")
+ granularity = khtml::PARAGRAPH;
s.modify(alter, direction, granularity);
part->setSelection(s);
}
#define EDIT_DEBUG 0
-using khtml::findWordBoundary;
-using khtml::InlineTextBox;
-using khtml::RenderObject;
-using khtml::RenderText;
-
-namespace DOM {
+using DOM::DOMString;
+using DOM::DOWNSTREAM;
+using DOM::ElementImpl;
+using DOM::Node;
+using DOM::NodeImpl;
+using DOM::Position;
+using DOM::Range;
+using DOM::RangeImpl;
+using DOM::StayInBlock;
+
+namespace khtml {
static Selection selectionForLine(const Position &position);
validate();
}
-Selection::Selection(const CaretPosition &base, const CaretPosition &extent)
+Selection::Selection(const VisiblePosition &base, const VisiblePosition &extent)
: m_base(base.position()), m_extent(extent.position())
{
init();
}
}
-CaretPosition Selection::modifyExtendingRightForward(ETextGranularity granularity)
+VisiblePosition Selection::modifyExtendingRightForward(ETextGranularity granularity)
{
- CaretPosition pos = m_extent;
+ VisiblePosition pos = m_extent;
switch (granularity) {
case CHARACTER:
pos = pos.next();
return pos;
}
-CaretPosition Selection::modifyMovingRightForward(ETextGranularity granularity)
+VisiblePosition Selection::modifyMovingRightForward(ETextGranularity granularity)
{
- CaretPosition pos;
+ VisiblePosition pos;
switch (granularity) {
case CHARACTER:
if (isRange())
pos = m_end;
else
- pos = CaretPosition(m_extent).next();
+ pos = VisiblePosition(m_extent).next();
break;
case WORD:
pos = nextWordPosition(m_extent);
return pos;
}
-CaretPosition Selection::modifyExtendingLeftBackward(ETextGranularity granularity)
+VisiblePosition Selection::modifyExtendingLeftBackward(ETextGranularity granularity)
{
- CaretPosition pos = m_extent;
+ VisiblePosition pos = m_extent;
switch (granularity) {
case CHARACTER:
pos = pos.previous();
pos = startOfParagraph(m_start);
break;
case DOCUMENT_BOUNDARY:
- pos = CaretPosition(m_start.node()->getDocument()->documentElement(), 0);
+ pos = VisiblePosition(m_start.node()->getDocument()->documentElement(), 0);
break;
}
return pos;
}
-CaretPosition Selection::modifyMovingLeftBackward(ETextGranularity granularity)
+VisiblePosition Selection::modifyMovingLeftBackward(ETextGranularity granularity)
{
- CaretPosition pos;
+ VisiblePosition pos;
switch (granularity) {
case CHARACTER:
if (isRange())
pos = m_start;
else
- pos = CaretPosition(m_extent).previous();
+ pos = VisiblePosition(m_extent).previous();
break;
case WORD:
pos = previousWordPosition(m_extent);
pos = startOfParagraph(m_start).deepEquivalent();
break;
case DOCUMENT_BOUNDARY:
- pos = CaretPosition(m_start.node()->getDocument()->documentElement(), 0);
+ pos = VisiblePosition(m_start.node()->getDocument()->documentElement(), 0);
break;
}
return pos;
{
setModifyBias(alter, dir);
- CaretPosition pos;
+ VisiblePosition pos;
switch (dir) {
// EDIT FIXME: These need to handle bidi
}
// FIXME: Maybe baseline would be better?
-static bool caretY(const CaretPosition &c, int &y)
+static bool caretY(const VisiblePosition &c, int &y)
{
Position p = c.deepEquivalent();
NodeImpl *n = p.node();
setModifyBias(alter, verticalDistance > 0 ? FORWARD : BACKWARD);
- CaretPosition pos;
+ VisiblePosition pos;
int xPos = 0; /* initialized only to make compiler happy */
switch (alter) {
startY = -startY;
int lastY = startY;
- CaretPosition result;
+ VisiblePosition result;
- CaretPosition next;
- for (CaretPosition p = pos; ; p = next) {
+ VisiblePosition next;
+ for (VisiblePosition p = pos; ; p = next) {
next = verticalDistance > 0
? nextLinePosition(p, xPos)
: previousLinePosition(p, xPos);
break;
case DOCUMENT_BOUNDARY: {
NodeImpl *de = m_start.node()->getDocument()->documentElement();
- m_start = CaretPosition(de, 0).deepEquivalent();
- m_end = CaretPosition(de, de ? de->childNodeCount() : 0).deepEquivalent();
+ m_start = VisiblePosition(de, 0).deepEquivalent();
+ m_end = VisiblePosition(de, de ? de->childNodeCount() : 0).deepEquivalent();
break;
}
case PARAGRAPH_BOUNDARY:
#include <qrect.h>
#include "xml/dom_position.h"
+#include "text_granularity.h"
class KHTMLPart;
class QPainter;
namespace khtml {
- class RenderObject;
-}
-
-namespace DOM {
-class CaretPosition;
+class RenderObject;
+class VisiblePosition;
class Selection
{
enum EState { NONE, CARET, RANGE };
enum EAlter { MOVE, EXTEND };
enum EDirection { FORWARD, BACKWARD, RIGHT, LEFT };
- enum ETextGranularity { CHARACTER, WORD, LINE, PARAGRAPH, LINE_BOUNDARY, PARAGRAPH_BOUNDARY, DOCUMENT_BOUNDARY };
+
+ typedef DOM::EAffinity EAffinity;
+ typedef DOM::Range Range;
+ typedef DOM::Position Position;
Selection();
Selection(const Range &);
- Selection(const CaretPosition &);
- Selection(const CaretPosition &, const CaretPosition &);
+ Selection(const VisiblePosition &);
+ Selection(const VisiblePosition &, const VisiblePosition &);
Selection(const Position &);
Selection(const Position &, const Position &);
Selection(const Selection &);
Selection &operator=(const Selection &o);
Selection &operator=(const Range &r) { moveTo(r); return *this; }
- Selection &operator=(const CaretPosition &r) { moveTo(r); return *this; }
+ Selection &operator=(const VisiblePosition &r) { moveTo(r); return *this; }
Selection &operator=(const Position &r) { moveTo(r); return *this; }
void moveTo(const Range &);
- void moveTo(const CaretPosition &);
- void moveTo(const CaretPosition &, const CaretPosition &);
+ void moveTo(const VisiblePosition &);
+ void moveTo(const VisiblePosition &, const VisiblePosition &);
void moveTo(const Position &);
void moveTo(const Position &, const Position &);
void moveTo(const Selection &);
bool expandUsingGranularity(ETextGranularity);
void clear();
- void setBase(const CaretPosition &);
- void setExtent(const CaretPosition &);
- void setBaseAndExtent(const CaretPosition &base, const CaretPosition &extent);
+ void setBase(const VisiblePosition &);
+ void setExtent(const VisiblePosition &);
+ void setBaseAndExtent(const VisiblePosition &base, const VisiblePosition &extent);
void setBase(const Position &pos);
void setExtent(const Position &pos);
void init();
void validate(ETextGranularity granularity = CHARACTER);
- CaretPosition modifyExtendingRightForward(ETextGranularity);
- CaretPosition modifyMovingRightForward(ETextGranularity);
- CaretPosition modifyExtendingLeftBackward(ETextGranularity);
- CaretPosition modifyMovingLeftBackward(ETextGranularity);
+ VisiblePosition modifyExtendingRightForward(ETextGranularity);
+ VisiblePosition modifyMovingRightForward(ETextGranularity);
+ VisiblePosition modifyExtendingLeftBackward(ETextGranularity);
+ VisiblePosition modifyMovingLeftBackward(ETextGranularity);
void layoutCaret();
void needsCaretRepaint();
using DOM::DOMString;
using DOM::NodeImpl;
using DOM::NodeListImpl;
-using DOM::Selection;
using DOM::TextImpl;
#if !APPLE_CHANGES
namespace DOM {
class DocumentFragmentImpl;
- class Selection;
class TextImpl;
}
class CompositeEditCommandImpl;
class DeleteSelectionCommandImpl;
class DeleteTextCommandImpl;
-class EditCommand;
class EditCommandImpl;
class InputNewlineCommandImpl;
class InputTextCommandImpl;
class RemoveNodeAttributeCommandImpl;
class RemoveNodeCommandImpl;
class RemoveNodePreservingChildrenCommandImpl;
+class Selection;
class SetNodeAttributeCommandImpl;
class SplitTextNodeCommandImpl;
class TypingCommandImpl;
DOM::DocumentImpl * const document() const;
- DOM::Selection startingSelection() const;
- DOM::Selection endingSelection() const;
+ khtml::Selection startingSelection() const;
+ khtml::Selection endingSelection() const;
- void setStartingSelection(const DOM::Selection &s) const;
- void setEndingSelection(const DOM::Selection &s) const;
+ void setStartingSelection(const khtml::Selection &s) const;
+ void setEndingSelection(const khtml::Selection &s) const;
DOM::CSSStyleDeclarationImpl *typingStyle() const;
void setTypingStyle(DOM::CSSStyleDeclarationImpl *) const;
{
public:
DeleteSelectionCommand(DOM::DocumentImpl *document, bool smartDelete=false);
- DeleteSelectionCommand(DOM::DocumentImpl *document, const DOM::Selection &selection, bool smartDelete=false);
+ DeleteSelectionCommand(DOM::DocumentImpl *document, const khtml::Selection &selection, bool smartDelete=false);
private:
DeleteSelectionCommandImpl *impl() const;
#endif
using DOM::AttrImpl;
-using DOM::CaretPosition;
using DOM::CSSComputedStyleDeclarationImpl;
using DOM::CSSPrimitiveValue;
using DOM::CSSPrimitiveValueImpl;
using DOM::ElementImpl;
using DOM::HTMLElementImpl;
using DOM::HTMLImageElementImpl;
-using DOM::LeftWordIfOnBoundary;
using DOM::NamedAttrMapImpl;
using DOM::Node;
using DOM::NodeImpl;
using DOM::PositionIterator;
using DOM::Range;
using DOM::RangeImpl;
-using DOM::Selection;
using DOM::StayInBlock;
using DOM::TextImpl;
using DOM::TreeWalkerImpl;
namespace khtml {
-
static inline bool isNBSP(const QChar &c)
{
return c == QChar(0xa0);
cmd->m_endingSelection = s;
}
-void EditCommandImpl::assignTypingStyle(DOM::CSSStyleDeclarationImpl *style)
+void EditCommandImpl::assignTypingStyle(CSSStyleDeclarationImpl *style)
{
CSSStyleDeclarationImpl *old = m_typingStyle;
m_typingStyle = style;
if (m_smartDelete) {
if (!m_selectionToDelete.start().leadingWhitespacePosition().isNull()) {
- m_selectionToDelete.modify(DOM::Selection::EXTEND, DOM::Selection::LEFT, DOM::Selection::CHARACTER);
+ m_selectionToDelete.modify(Selection::EXTEND, Selection::LEFT, CHARACTER);
} else if (!m_selectionToDelete.end().trailingWhitespacePosition().isNull()) {
- m_selectionToDelete.modify(DOM::Selection::EXTEND, DOM::Selection::RIGHT, DOM::Selection::CHARACTER);
+ m_selectionToDelete.modify(Selection::EXTEND, Selection::RIGHT, CHARACTER);
}
}
Position pos(selection.start().upstream(StayInBlock));
bool atStart = pos.offset() <= pos.node()->caretMinOffset();
bool atEnd = pos.offset() >= pos.node()->caretMaxOffset();
- bool atEndOfBlock = CaretPosition(pos).isLastInBlock();
+ bool atEndOfBlock = VisiblePosition(pos).isLastInBlock();
if (atEndOfBlock) {
LOG(Editing, "input newline case 1");
//------------------------------------------------------------------------------------------
// ReplaceSelectionCommandImpl
-ReplaceSelectionCommandImpl::ReplaceSelectionCommandImpl(DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, bool selectReplacement, bool smartReplace)
+ReplaceSelectionCommandImpl::ReplaceSelectionCommandImpl(DocumentImpl *document, DocumentFragmentImpl *fragment, bool selectReplacement, bool smartReplace)
: CompositeEditCommandImpl(document), m_fragment(fragment), m_selectReplacement(selectReplacement), m_smartReplace(smartReplace)
{
ASSERT(m_fragment);
//------------------------------------------------------------------------------------------
// MoveSelectionCommandImpl
-MoveSelectionCommandImpl::MoveSelectionCommandImpl(DocumentImpl *document, DOM::DocumentFragmentImpl *fragment, DOM::Position &position, bool smartMove)
+MoveSelectionCommandImpl::MoveSelectionCommandImpl(DocumentImpl *document, DocumentFragmentImpl *fragment, Position &position, bool smartMove)
: CompositeEditCommandImpl(document), m_fragment(fragment), m_position(position), m_smartMove(smartMove)
{
ASSERT(m_fragment);
//------------------------------------------------------------------------------------------
// TypingCommandImpl
-TypingCommandImpl::TypingCommandImpl(DocumentImpl *document, TypingCommand::ETypingCommand commandType, const DOM::DOMString &textToInsert, bool selectInsertedText)
+TypingCommandImpl::TypingCommandImpl(DocumentImpl *document, TypingCommand::ETypingCommand commandType, const DOMString &textToInsert, bool selectInsertedText)
: CompositeEditCommandImpl(document), m_commandType(commandType), m_textToInsert(textToInsert), m_openForMoreTyping(true), m_applyEditing(false), m_selectInsertedText(selectInsertedText)
{
}
// Since the word containing the current selection is never marked, this does a check to
// see if typing made a new word that is not in the current selection. Basically, you
// get this by being at the end of a word and typing a space.
- CaretPosition start(endingSelection().start());
- CaretPosition previous = start.previous();
+ VisiblePosition start(endingSelection().start());
+ VisiblePosition previous = start.previous();
if (previous.isNotNull()) {
- CaretPosition p1 = startOfWord(previous, LeftWordIfOnBoundary);
- CaretPosition p2 = startOfWord(start, LeftWordIfOnBoundary);
+ VisiblePosition p1 = startOfWord(previous, LeftWordIfOnBoundary);
+ VisiblePosition p2 = startOfWord(start, LeftWordIfOnBoundary);
if (p1 != p2)
markMisspellingsInSelection(Selection(p1, start));
}
// Do nothing in the case that the caret is at the start of a
// root editable element or at the start of a document.
Position pos(endingSelection().start());
- Position start = CaretPosition(pos).previous().deepEquivalent();
- Position end = CaretPosition(pos).deepEquivalent();
+ Position start = VisiblePosition(pos).previous().deepEquivalent();
+ Position end = VisiblePosition(pos).deepEquivalent();
if (start.isNotNull() && end.isNotNull() && start.node()->rootEditableElement() == end.node()->rootEditableElement())
selectionToDelete = Selection(start, end);
break;
virtual DOM::DocumentImpl * const document() const { return m_document; }
- DOM::Selection startingSelection() const { return m_startingSelection; }
- DOM::Selection endingSelection() const { return m_endingSelection; }
+ khtml::Selection startingSelection() const { return m_startingSelection; }
+ khtml::Selection endingSelection() const { return m_endingSelection; }
ECommandState state() const { return m_state; }
void setState(ECommandState state) { m_state = state; }
- void setStartingSelection(const DOM::Selection &s);
- void setEndingSelection(const DOM::Selection &s);
+ void setStartingSelection(const khtml::Selection &s);
+ void setEndingSelection(const khtml::Selection &s);
DOM::CSSStyleDeclarationImpl *typingStyle() const { return m_typingStyle; };
void setTypingStyle(DOM::CSSStyleDeclarationImpl *);
- void markMisspellingsInSelection(const DOM::Selection &s);
+ void markMisspellingsInSelection(const khtml::Selection &s);
virtual bool isInputTextCommand() const;
virtual bool isTypingCommand() const;
DOM::DocumentImpl *m_document;
ECommandState m_state;
- DOM::Selection m_startingSelection;
- DOM::Selection m_endingSelection;
+ khtml::Selection m_startingSelection;
+ khtml::Selection m_endingSelection;
DOM::CSSStyleDeclarationImpl *m_typingStyle;
EditCommand m_parent;
};
void applyCommandToComposite(EditCommand &);
void deleteKeyPressed();
void deleteSelection(bool smartDelete=false);
- void deleteSelection(const DOM::Selection &selection, bool smartDelete=false);
+ void deleteSelection(const khtml::Selection &selection, bool smartDelete=false);
void deleteText(DOM::TextImpl *node, long offset, long count);
void inputText(const DOM::DOMString &text, bool selectInsertedText = false);
void insertNodeAfter(DOM::NodeImpl *insertChild, DOM::NodeImpl *refChild);
{
public:
DeleteSelectionCommandImpl(DOM::DocumentImpl *document, bool smartDelete=false);
- DeleteSelectionCommandImpl(DOM::DocumentImpl *document, const DOM::Selection &selection, bool smartDelete=false);
+ DeleteSelectionCommandImpl(DOM::DocumentImpl *document, const khtml::Selection &selection, bool smartDelete=false);
virtual void doApply();
bool containsOnlyWhitespace(const DOM::Position &start, const DOM::Position &end);
void moveNodesAfterNode(DOM::NodeImpl *startNode, DOM::NodeImpl *dstNode);
- DOM::Selection m_selectionToDelete;
+ khtml::Selection m_selectionToDelete;
bool m_hasSelectionToDelete;
bool m_smartDelete;
};
#include <qstring.h>
#include "htmlediting.h"
+#include "selection.h"
#include "khtml_part.h"
#include "css/cssproperties.h"
#define EDIT_DEBUG 0
-using khtml::findWordBoundary;
-using khtml::InlineTextBox;
-using khtml::RenderObject;
-using khtml::RenderText;
-
-namespace DOM {
+using DOM::DOMString;
+using DOM::DOWNSTREAM;
+using DOM::ElementImpl;
+using DOM::Node;
+using DOM::NodeImpl;
+using DOM::Position;
+using DOM::Range;
+using DOM::RangeImpl;
+using DOM::StayInBlock;
+
+namespace khtml {
static Selection selectionForLine(const Position &position);
validate();
}
-Selection::Selection(const CaretPosition &base, const CaretPosition &extent)
+Selection::Selection(const VisiblePosition &base, const VisiblePosition &extent)
: m_base(base.position()), m_extent(extent.position())
{
init();
}
}
-CaretPosition Selection::modifyExtendingRightForward(ETextGranularity granularity)
+VisiblePosition Selection::modifyExtendingRightForward(ETextGranularity granularity)
{
- CaretPosition pos = m_extent;
+ VisiblePosition pos = m_extent;
switch (granularity) {
case CHARACTER:
pos = pos.next();
return pos;
}
-CaretPosition Selection::modifyMovingRightForward(ETextGranularity granularity)
+VisiblePosition Selection::modifyMovingRightForward(ETextGranularity granularity)
{
- CaretPosition pos;
+ VisiblePosition pos;
switch (granularity) {
case CHARACTER:
if (isRange())
pos = m_end;
else
- pos = CaretPosition(m_extent).next();
+ pos = VisiblePosition(m_extent).next();
break;
case WORD:
pos = nextWordPosition(m_extent);
return pos;
}
-CaretPosition Selection::modifyExtendingLeftBackward(ETextGranularity granularity)
+VisiblePosition Selection::modifyExtendingLeftBackward(ETextGranularity granularity)
{
- CaretPosition pos = m_extent;
+ VisiblePosition pos = m_extent;
switch (granularity) {
case CHARACTER:
pos = pos.previous();
pos = startOfParagraph(m_start);
break;
case DOCUMENT_BOUNDARY:
- pos = CaretPosition(m_start.node()->getDocument()->documentElement(), 0);
+ pos = VisiblePosition(m_start.node()->getDocument()->documentElement(), 0);
break;
}
return pos;
}
-CaretPosition Selection::modifyMovingLeftBackward(ETextGranularity granularity)
+VisiblePosition Selection::modifyMovingLeftBackward(ETextGranularity granularity)
{
- CaretPosition pos;
+ VisiblePosition pos;
switch (granularity) {
case CHARACTER:
if (isRange())
pos = m_start;
else
- pos = CaretPosition(m_extent).previous();
+ pos = VisiblePosition(m_extent).previous();
break;
case WORD:
pos = previousWordPosition(m_extent);
pos = startOfParagraph(m_start).deepEquivalent();
break;
case DOCUMENT_BOUNDARY:
- pos = CaretPosition(m_start.node()->getDocument()->documentElement(), 0);
+ pos = VisiblePosition(m_start.node()->getDocument()->documentElement(), 0);
break;
}
return pos;
{
setModifyBias(alter, dir);
- CaretPosition pos;
+ VisiblePosition pos;
switch (dir) {
// EDIT FIXME: These need to handle bidi
}
// FIXME: Maybe baseline would be better?
-static bool caretY(const CaretPosition &c, int &y)
+static bool caretY(const VisiblePosition &c, int &y)
{
Position p = c.deepEquivalent();
NodeImpl *n = p.node();
setModifyBias(alter, verticalDistance > 0 ? FORWARD : BACKWARD);
- CaretPosition pos;
+ VisiblePosition pos;
int xPos = 0; /* initialized only to make compiler happy */
switch (alter) {
startY = -startY;
int lastY = startY;
- CaretPosition result;
+ VisiblePosition result;
- CaretPosition next;
- for (CaretPosition p = pos; ; p = next) {
+ VisiblePosition next;
+ for (VisiblePosition p = pos; ; p = next) {
next = verticalDistance > 0
? nextLinePosition(p, xPos)
: previousLinePosition(p, xPos);
break;
case DOCUMENT_BOUNDARY: {
NodeImpl *de = m_start.node()->getDocument()->documentElement();
- m_start = CaretPosition(de, 0).deepEquivalent();
- m_end = CaretPosition(de, de ? de->childNodeCount() : 0).deepEquivalent();
+ m_start = VisiblePosition(de, 0).deepEquivalent();
+ m_end = VisiblePosition(de, de ? de->childNodeCount() : 0).deepEquivalent();
break;
}
case PARAGRAPH_BOUNDARY:
#include <qrect.h>
#include "xml/dom_position.h"
+#include "text_granularity.h"
class KHTMLPart;
class QPainter;
namespace khtml {
- class RenderObject;
-}
-
-namespace DOM {
-class CaretPosition;
+class RenderObject;
+class VisiblePosition;
class Selection
{
enum EState { NONE, CARET, RANGE };
enum EAlter { MOVE, EXTEND };
enum EDirection { FORWARD, BACKWARD, RIGHT, LEFT };
- enum ETextGranularity { CHARACTER, WORD, LINE, PARAGRAPH, LINE_BOUNDARY, PARAGRAPH_BOUNDARY, DOCUMENT_BOUNDARY };
+
+ typedef DOM::EAffinity EAffinity;
+ typedef DOM::Range Range;
+ typedef DOM::Position Position;
Selection();
Selection(const Range &);
- Selection(const CaretPosition &);
- Selection(const CaretPosition &, const CaretPosition &);
+ Selection(const VisiblePosition &);
+ Selection(const VisiblePosition &, const VisiblePosition &);
Selection(const Position &);
Selection(const Position &, const Position &);
Selection(const Selection &);
Selection &operator=(const Selection &o);
Selection &operator=(const Range &r) { moveTo(r); return *this; }
- Selection &operator=(const CaretPosition &r) { moveTo(r); return *this; }
+ Selection &operator=(const VisiblePosition &r) { moveTo(r); return *this; }
Selection &operator=(const Position &r) { moveTo(r); return *this; }
void moveTo(const Range &);
- void moveTo(const CaretPosition &);
- void moveTo(const CaretPosition &, const CaretPosition &);
+ void moveTo(const VisiblePosition &);
+ void moveTo(const VisiblePosition &, const VisiblePosition &);
void moveTo(const Position &);
void moveTo(const Position &, const Position &);
void moveTo(const Selection &);
bool expandUsingGranularity(ETextGranularity);
void clear();
- void setBase(const CaretPosition &);
- void setExtent(const CaretPosition &);
- void setBaseAndExtent(const CaretPosition &base, const CaretPosition &extent);
+ void setBase(const VisiblePosition &);
+ void setExtent(const VisiblePosition &);
+ void setBaseAndExtent(const VisiblePosition &base, const VisiblePosition &extent);
void setBase(const Position &pos);
void setExtent(const Position &pos);
void init();
void validate(ETextGranularity granularity = CHARACTER);
- CaretPosition modifyExtendingRightForward(ETextGranularity);
- CaretPosition modifyMovingRightForward(ETextGranularity);
- CaretPosition modifyExtendingLeftBackward(ETextGranularity);
- CaretPosition modifyMovingLeftBackward(ETextGranularity);
+ VisiblePosition modifyExtendingRightForward(ETextGranularity);
+ VisiblePosition modifyMovingRightForward(ETextGranularity);
+ VisiblePosition modifyExtendingLeftBackward(ETextGranularity);
+ VisiblePosition modifyMovingLeftBackward(ETextGranularity);
void layoutCaret();
void needsCaretRepaint();
#define LOG(channel, formatAndArgs...) ((void)0)
#endif
-using khtml::InlineTextBox;
-using khtml::RenderObject;
-using khtml::RenderText;
-using khtml::VISIBLE;
+using DOM::CharacterDataImpl;
+using DOM::offsetInCharacters;
+using DOM::Position;
+using DOM::Range;
+using DOM::RangeImpl;
-namespace DOM {
+namespace khtml {
-CaretPosition::CaretPosition(NodeImpl *node, long offset)
+VisiblePosition::VisiblePosition(NodeImpl *node, long offset)
{
init(Position(node, offset));
}
-CaretPosition::CaretPosition(const Position &pos)
+VisiblePosition::VisiblePosition(const Position &pos)
{
init(pos);
}
-void CaretPosition::init(const Position &pos)
+void VisiblePosition::init(const Position &pos)
{
Position deepPos = deepEquivalent(pos);
if (isCandidate(deepPos)) {
m_deepPosition = deepPos;
- Position previous = previousCaretPosition(deepPos);
+ Position previous = previousVisiblePosition(deepPos);
if (previous.isNotNull()) {
- Position next = nextCaretPosition(previous);
+ Position next = nextVisiblePosition(previous);
if (next.isNotNull())
m_deepPosition = next;
}
}
else {
- Position next = nextCaretPosition(deepPos);
+ Position next = nextVisiblePosition(deepPos);
if (next.isNotNull()) {
m_deepPosition = next;
}
else {
- Position previous = previousCaretPosition(deepPos);
+ Position previous = previousVisiblePosition(deepPos);
if (previous.isNotNull())
m_deepPosition = previous;
}
}
}
-bool CaretPosition::isLastInBlock() const
+bool VisiblePosition::isLastInBlock() const
{
if (isNull())
return false;
- CaretPosition n = next();
+ VisiblePosition n = next();
return n.isNull() || (n.deepEquivalent().node()->enclosingBlockFlowElement() != m_deepPosition.node()->enclosingBlockFlowElement());
}
-CaretPosition CaretPosition::next() const
+VisiblePosition VisiblePosition::next() const
{
- CaretPosition result;
- result.m_deepPosition = nextCaretPosition(m_deepPosition);
+ VisiblePosition result;
+ result.m_deepPosition = nextVisiblePosition(m_deepPosition);
return result;
}
-CaretPosition CaretPosition::previous() const
+VisiblePosition VisiblePosition::previous() const
{
- CaretPosition result;
- result.m_deepPosition = previousCaretPosition(m_deepPosition);
+ VisiblePosition result;
+ result.m_deepPosition = previousVisiblePosition(m_deepPosition);
return result;
}
-Position CaretPosition::previousCaretPosition(const Position &pos)
+Position VisiblePosition::previousVisiblePosition(const Position &pos)
{
if (pos.isNull() || atStart(pos))
return Position();
Position test = deepEquivalent(pos);
- bool acceptAnyCaretPosition = !isCandidate(test) || pos.isFirstRenderedPositionOnLine();
+ bool acceptAnyVisiblePosition = !isCandidate(test) || pos.isFirstRenderedPositionOnLine();
Position current = test;
while (!atStart(current)) {
current = previousPosition(current);
- if (isCandidate(current) && (acceptAnyCaretPosition || current.rendersInDifferentPosition(test))) {
+ if (isCandidate(current) && (acceptAnyVisiblePosition || current.rendersInDifferentPosition(test))) {
return current;
}
}
return Position();
}
-Position CaretPosition::nextCaretPosition(const Position &pos)
+Position VisiblePosition::nextVisiblePosition(const Position &pos)
{
if (pos.isNull() || atEnd(pos))
return Position();
Position test = deepEquivalent(pos);
- bool acceptAnyCaretPosition = !isCandidate(test) || pos.isLastRenderedPositionOnLine();
+ bool acceptAnyVisiblePosition = !isCandidate(test) || pos.isLastRenderedPositionOnLine();
Position current = test;
while (!atEnd(current)) {
current = nextPosition(current);
- if (isCandidate(current) && (acceptAnyCaretPosition || current.rendersInDifferentPosition(test))) {
+ if (isCandidate(current) && (acceptAnyVisiblePosition || current.rendersInDifferentPosition(test))) {
return current;
}
}
return Position();
}
-Position CaretPosition::previousPosition(const Position &pos)
+Position VisiblePosition::previousPosition(const Position &pos)
{
if (pos.isNull())
return pos;
return result;
}
-Position CaretPosition::nextPosition(const Position &pos)
+Position VisiblePosition::nextPosition(const Position &pos)
{
if (pos.isNull())
return pos;
return result;
}
-bool CaretPosition::atStart(const Position &pos)
+bool VisiblePosition::atStart(const Position &pos)
{
if (pos.isNull())
return true;
return pos.offset() <= 0 && pos.node()->previousLeafNode() == 0;
}
-bool CaretPosition::atEnd(const Position &pos)
+bool VisiblePosition::atEnd(const Position &pos)
{
if (pos.isNull())
return true;
return pos.offset() >= pos.node()->maxOffset() && pos.node()->nextLeafNode() == 0;
}
-bool CaretPosition::isCandidate(const Position &pos)
+bool VisiblePosition::isCandidate(const Position &pos)
{
if (pos.isNull())
return false;
return false;
}
-Position CaretPosition::deepEquivalent(const Position &pos)
+Position VisiblePosition::deepEquivalent(const Position &pos)
{
NodeImpl *node = pos.node();
long offset = pos.offset();
return Position(node, 0);
}
-Position CaretPosition::rangeCompliantEquivalent(const Position &pos)
+Position VisiblePosition::rangeCompliantEquivalent(const Position &pos)
{
NodeImpl *node = pos.node();
if (!node)
return Position(node, kMax(0L, kMin(offset, maxOffset(node))));
}
-long CaretPosition::maxOffset(const NodeImpl *node)
+long VisiblePosition::maxOffset(const NodeImpl *node)
{
return offsetInCharacters(node->nodeType()) ? (long)static_cast<const CharacterDataImpl *>(node)->length() : (long)node->childNodeCount();
}
-bool CaretPosition::isAtomicNode(const NodeImpl *node)
+bool VisiblePosition::isAtomicNode(const NodeImpl *node)
{
return node && (!node->hasChildNodes() || (node->id() == ID_OBJECT && node->renderer() && node->renderer()->isReplaced()));
}
-void CaretPosition::debugPosition(const char *msg) const
+void VisiblePosition::debugPosition(const char *msg) const
{
if (isNull())
fprintf(stderr, "Position [%s]: null\n", msg);
}
#ifndef NDEBUG
-void CaretPosition::formatForDebugger(char *buffer, unsigned length) const
+void VisiblePosition::formatForDebugger(char *buffer, unsigned length) const
{
m_deepPosition.formatForDebugger(buffer, length);
}
#endif
-Range makeRange(const CaretPosition &start, const CaretPosition &end)
+Range 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());
}
-CaretPosition start(const Range &r)
+VisiblePosition startVisiblePosition(const Range &r)
{
- return CaretPosition(r.startContainer().handle(), r.startOffset());
+ return VisiblePosition(r.startContainer().handle(), r.startOffset());
}
-CaretPosition end(const Range &r)
+VisiblePosition endVisiblePosition(const Range &r)
{
- return CaretPosition(r.endContainer().handle(), r.endOffset());
+ return VisiblePosition(r.endContainer().handle(), r.endOffset());
}
-bool setStart(Range &r, const CaretPosition &c)
+bool setStart(Range &r, const VisiblePosition &c)
{
RangeImpl *ri = r.handle();
if (!ri)
return code == 0;
}
-bool setEnd(Range &r, const CaretPosition &c)
+bool setEnd(Range &r, const VisiblePosition &c)
{
RangeImpl *ri = r.handle();
if (!ri)
#include "xml/dom_position.h"
namespace DOM {
+ class Range;
+ class RangeImpl;
+}
-class Range;
-class RangeImpl;
+namespace khtml {
-class CaretPosition
+class VisiblePosition
{
public:
- CaretPosition() { }
- CaretPosition(NodeImpl *, long offset);
- CaretPosition(const Position &);
+ typedef DOM::NodeImpl NodeImpl;
+ typedef DOM::Position Position;
+
+ VisiblePosition() { }
+ VisiblePosition(NodeImpl *, long offset);
+ VisiblePosition(const Position &);
void clear() { m_deepPosition.clear(); }
Position position() const { return rangeCompliantEquivalent(m_deepPosition); }
Position deepEquivalent() const { return m_deepPosition; }
- friend inline bool operator==(const CaretPosition &a, const CaretPosition &b);
+ friend inline bool operator==(const VisiblePosition &a, const VisiblePosition &b);
- CaretPosition next() const;
- CaretPosition previous() const;
+ VisiblePosition next() const;
+ VisiblePosition previous() const;
bool isLastInBlock() const;
static long maxOffset(const NodeImpl *);
static bool isAtomicNode(const NodeImpl *);
- static Position previousCaretPosition(const Position &);
- static Position nextCaretPosition(const Position &);
+ static Position previousVisiblePosition(const Position &);
+ static Position nextVisiblePosition(const Position &);
static Position previousPosition(const Position &);
static Position nextPosition(const Position &);
Position m_deepPosition;
};
-inline bool operator==(const CaretPosition &a, const CaretPosition &b)
+inline bool operator==(const VisiblePosition &a, const VisiblePosition &b)
{
return a.m_deepPosition == b.m_deepPosition;
}
-inline bool operator!=(const CaretPosition &a, const CaretPosition &b)
+inline bool operator!=(const VisiblePosition &a, const VisiblePosition &b)
{
return !(a == b);
}
-Range makeRange(const CaretPosition &start, const CaretPosition &end);
-bool setStart(Range &, const CaretPosition &start);
-bool setStart(RangeImpl *, const CaretPosition &start);
-bool setEnd(Range &, const CaretPosition &start);
-bool setEnd(RangeImpl *, const CaretPosition &start);
-CaretPosition start(const Range &);
-CaretPosition start(const RangeImpl *);
-CaretPosition end(const Range &);
-CaretPosition end(const RangeImpl *);
+DOM::Range makeRange(const VisiblePosition &start, const VisiblePosition &end);
+bool setStart(DOM::Range &, const VisiblePosition &start);
+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 &);
+VisiblePosition startVisiblePosition(const DOM::RangeImpl *);
+VisiblePosition endVisiblePosition(const DOM::Range &);
+VisiblePosition endVisiblePosition(const DOM::RangeImpl *);
} // namespace DOM
TextIterator m_textIterator;
};
-
// Very similar to the TextIterator, except that the chunks of text returned are "well behaved",
// meaning they never end split up a word. This is useful for spellcheck or (perhaps one day) searching.
class WordAwareIterator {
#include "visible_text.h"
#include "xml/dom_docimpl.h"
-using khtml::CharacterIterator;
-using khtml::findWordBoundary;
-using khtml::nextWordFromIndex;
-using khtml::PRE;
-using khtml::RenderObject;
-using khtml::RenderStyle;
-using khtml::RenderText;
-using khtml::SimplifiedBackwardsTextIterator;
-using khtml::TextIterator;
-using khtml::VISIBLE;
-
-namespace DOM {
-
-static CaretPosition previousWordBoundary(const CaretPosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
+using DOM::DocumentImpl;
+using DOM::DOWNSTREAM;
+using DOM::NodeImpl;
+using DOM::Position;
+using DOM::Range;
+using DOM::UPSTREAM;
+
+namespace khtml {
+
+static VisiblePosition previousWordBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
{
Position pos = c.deepEquivalent();
NodeImpl *n = pos.node();
if (!n)
- return CaretPosition();
+ return VisiblePosition();
DocumentImpl *d = n->getDocument();
if (!d)
- return CaretPosition();
+ return VisiblePosition();
NodeImpl *de = d->documentElement();
if (!de)
- return CaretPosition();
+ return VisiblePosition();
Range searchRange(d);
searchRange.setStartBefore(de);
return pos.equivalentDeepPosition().closestRenderedPosition(DOWNSTREAM);
}
-static CaretPosition nextWordBoundary(const CaretPosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
+static VisiblePosition nextWordBoundary(const VisiblePosition &c, unsigned (*searchFunction)(const QChar *, unsigned))
{
Position pos = c.deepEquivalent();
NodeImpl *n = pos.node();
if (!n)
- return CaretPosition();
+ return VisiblePosition();
DocumentImpl *d = n->getDocument();
if (!d)
- return CaretPosition();
+ return VisiblePosition();
NodeImpl *de = d->documentElement();
if (!de)
- return CaretPosition();
+ return VisiblePosition();
Range searchRange(d);
Position start(pos.equivalentRangeCompliantPosition());
return start;
}
-CaretPosition startOfWord(const CaretPosition &c, EWordSide side)
+VisiblePosition startOfWord(const VisiblePosition &c, EWordSide side)
{
- CaretPosition p = c;
+ VisiblePosition p = c;
if (side == RightWordIfOnBoundary) {
p = c.next();
if (p.isNull())
return end;
}
-CaretPosition endOfWord(const CaretPosition &c, EWordSide side)
+VisiblePosition endOfWord(const VisiblePosition &c, EWordSide side)
{
- CaretPosition p = c;
+ VisiblePosition p = c;
if (side == LeftWordIfOnBoundary) {
p = c.previous();
if (p.isNull())
return nextWordFromIndex(characters, length, length, false);
}
-CaretPosition previousWordPosition(const CaretPosition &c)
+VisiblePosition previousWordPosition(const VisiblePosition &c)
{
return previousWordBoundary(c, previousWordPositionBoundary);
}
return nextWordFromIndex(characters, length, 0, true);
}
-CaretPosition nextWordPosition(const CaretPosition &c)
+VisiblePosition nextWordPosition(const VisiblePosition &c)
{
return nextWordBoundary(c, nextWordPositionBoundary);
}
-CaretPosition previousLinePosition(const CaretPosition &c, int x)
+VisiblePosition previousLinePosition(const VisiblePosition &c, int x)
{
return c.deepEquivalent().previousLinePosition(x);
}
-CaretPosition nextLinePosition(const CaretPosition &c, int x)
+VisiblePosition nextLinePosition(const VisiblePosition &c, int x)
{
return c.deepEquivalent().nextLinePosition(x);
}
-CaretPosition startOfParagraph(const CaretPosition &c)
+VisiblePosition startOfParagraph(const VisiblePosition &c)
{
Position p = c.deepEquivalent();
NodeImpl *startNode = p.node();
if (!startNode)
- return CaretPosition();
+ return VisiblePosition();
NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
i = kMax(0L, o);
while (--i >= 0)
if (text[i] == '\n')
- return CaretPosition(n, i + 1);
+ return VisiblePosition(n, i + 1);
}
node = n;
offset = 0;
}
}
- return CaretPosition(node, offset);
+ return VisiblePosition(node, offset);
}
-CaretPosition endOfParagraph(const CaretPosition &c, EIncludeLineBreak includeLineBreak)
+VisiblePosition endOfParagraph(const VisiblePosition &c, EIncludeLineBreak includeLineBreak)
{
Position p = c.deepEquivalent();
NodeImpl *startNode = p.node();
if (!startNode)
- return CaretPosition();
+ return VisiblePosition();
NodeImpl *startBlock = startNode->enclosingBlockFlowElement();
continue;
if (r->isBR()) {
if (includeLineBreak)
- return CaretPosition(n, 1);
+ return VisiblePosition(n, 1);
break;
}
if (r->isBlockFlow()) {
if (includeLineBreak)
- return CaretPosition(n, 0);
+ return VisiblePosition(n, 0);
break;
}
if (r->isText()) {
o = offset;
for (long i = o; i < length; ++i)
if (text[i] == '\n')
- return CaretPosition(n, i + includeLineBreak);
+ return VisiblePosition(n, i + includeLineBreak);
}
node = n;
offset = length;
}
}
- return CaretPosition(node, offset);
+ return VisiblePosition(node, offset);
}
-bool inSameParagraph(const CaretPosition &a, const CaretPosition &b)
+bool inSameParagraph(const VisiblePosition &a, const VisiblePosition &b)
{
return a == b || startOfParagraph(a) == startOfParagraph(b);
}
-CaretPosition previousParagraphPosition(const CaretPosition &p, int x)
+VisiblePosition previousParagraphPosition(const VisiblePosition &p, int x)
{
- CaretPosition pos = p;
+ VisiblePosition pos = p;
do {
- CaretPosition n = previousLinePosition(pos, x);
+ VisiblePosition n = previousLinePosition(pos, x);
if (n.isNull() || n == pos)
return p;
pos = n;
return pos;
}
-CaretPosition nextParagraphPosition(const CaretPosition &p, int x)
+VisiblePosition nextParagraphPosition(const VisiblePosition &p, int x)
{
- CaretPosition pos = p;
+ VisiblePosition pos = p;
do {
- CaretPosition n = nextLinePosition(pos, x);
+ VisiblePosition n = nextLinePosition(pos, x);
if (n.isNull() || n == pos)
return p;
pos = n;
#ifndef KHTML_EDITING_VISIBLE_UNITS_H
#define KHTML_EDITING_VISIBLE_UNITS_H
-namespace DOM {
+namespace khtml {
-class CaretPosition;
+class VisiblePosition;
enum EWordSide { RightWordIfOnBoundary = false, LeftWordIfOnBoundary = true };
enum EIncludeLineBreak { DoNotIncludeLineBreak = false, IncludeLineBreak = true };
// words
-CaretPosition startOfWord(const CaretPosition &, EWordSide = RightWordIfOnBoundary);
-CaretPosition endOfWord(const CaretPosition &, EWordSide = RightWordIfOnBoundary);
-CaretPosition previousWordPosition(const CaretPosition &);
-CaretPosition nextWordPosition(const CaretPosition &);
+VisiblePosition startOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
+VisiblePosition endOfWord(const VisiblePosition &, EWordSide = RightWordIfOnBoundary);
+VisiblePosition previousWordPosition(const VisiblePosition &);
+VisiblePosition nextWordPosition(const VisiblePosition &);
// lines
-CaretPosition startOfLine(const CaretPosition &);
-CaretPosition endOfLine(const CaretPosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
-CaretPosition previousLinePosition(const CaretPosition &, int x);
-CaretPosition nextLinePosition(const CaretPosition &, int x);
+VisiblePosition startOfLine(const VisiblePosition &);
+VisiblePosition endOfLine(const VisiblePosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
+VisiblePosition previousLinePosition(const VisiblePosition &, int x);
+VisiblePosition nextLinePosition(const VisiblePosition &, int x);
// paragraphs
-CaretPosition startOfParagraph(const CaretPosition &);
-CaretPosition endOfParagraph(const CaretPosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
-CaretPosition previousParagraphPosition(const CaretPosition &, int x);
-CaretPosition nextParagraphPosition(const CaretPosition &, int x);
-bool inSameParagraph(const CaretPosition &, const CaretPosition &);
+VisiblePosition startOfParagraph(const VisiblePosition &);
+VisiblePosition endOfParagraph(const VisiblePosition &, EIncludeLineBreak = DoNotIncludeLineBreak);
+VisiblePosition previousParagraphPosition(const VisiblePosition &, int x);
+VisiblePosition nextParagraphPosition(const VisiblePosition &, int x);
+bool inSameParagraph(const VisiblePosition &, const VisiblePosition &);
} // namespace DOM
#include "dom/dom_element.h"
#include "dom/html_document.h"
#include "editing/htmlediting.h"
+#include "editing/selection.h"
+#include "editing/visible_position.h"
+#include "editing/visible_text.h"
#include "html/html_documentimpl.h"
#include "html/html_baseimpl.h"
#include "html/html_miscimpl.h"
#include "rendering/render_frames.h"
#include "misc/htmlhashes.h"
#include "misc/loader.h"
-#include "editing/visible_position.h"
#include "xml/dom2_eventsimpl.h"
#include "xml/xml_tokenizer.h"
#include "css/css_computedstyle.h"
#include "css/cssstyleselector.h"
#include "css/csshelper.h"
-#include "editing/visible_text.h"
#include "css/css_computedstyle.h"
using namespace DOM;
#include <ksslcertchain.h>
#include <ksslinfodlg.h>
-
#include <qclipboard.h>
#include <qfile.h>
#include <qmetaobject.h>
#endif
using khtml::ApplyStyleCommand;
+using khtml::CHARACTER;
using khtml::ChildFrame;
using khtml::Decoder;
using khtml::DeleteSelectionCommand;
using khtml::EditCommand;
+using khtml::ETextGranularity;
using khtml::FormData;
using khtml::InlineTextBox;
+using khtml::PARAGRAPH;
using khtml::plainText;
using khtml::RenderObject;
using khtml::RenderText;
+using khtml::Selection;
using khtml::Tokenizer;
using khtml::TypingCommand;
+using khtml::VisiblePosition;
+using khtml::WORD;
using KParts::BrowserInterface;
-enum { CARET_BLINK_FREQUENCY = 500 };
+const int CARET_BLINK_FREQUENCY = 500;
namespace khtml {
class PartStyleSheetLoader : public CachedObjectClient
QGuardedPtr<KHTMLPart> m_part;
khtml::CachedCSSStyleSheet *m_cachedSheet;
};
-};
-
+}
FrameList::Iterator FrameList::find( const QString &name )
{
return d->m_selection;
}
-DOM::Selection::ETextGranularity KHTMLPart::selectionGranularity() const
+ETextGranularity KHTMLPart::selectionGranularity() const
{
return d->m_selectionGranularity;
}
}
}
-void KHTMLPart::setDragCaret(const DOM::Selection &dragCaret)
+void KHTMLPart::setDragCaret(const Selection &dragCaret)
{
if (d->m_dragCaret != dragCaret) {
d->m_dragCaret.needsCaretRepaint();
Position pos(innerNode.handle()->positionForCoordinates(x, y));
if (pos.isNotNull()) {
selection.moveTo(pos);
- selection.expandUsingGranularity(Selection::WORD);
+ selection.expandUsingGranularity(WORD);
}
}
if (selection.isRange()) {
- d->m_selectionGranularity = Selection::WORD;
+ d->m_selectionGranularity = WORD;
d->m_beganSelectingText = true;
}
Position pos(innerNode.handle()->positionForCoordinates(event->x(), event->y()));
if (pos.isNotNull()) {
selection.moveTo(pos);
- selection.expandUsingGranularity(Selection::PARAGRAPH);
+ selection.expandUsingGranularity(PARAGRAPH);
}
}
if (selection.isRange()) {
- d->m_selectionGranularity = Selection::PARAGRAPH;
+ d->m_selectionGranularity = PARAGRAPH;
d->m_beganSelectingText = true;
}
if (extendSelection && sel.isCaretOrRange()) {
sel.clearModifyBias();
sel.setExtent(pos);
- if (d->m_selectionGranularity != Selection::CHARACTER) {
+ if (d->m_selectionGranularity != CHARACTER) {
sel.expandUsingGranularity(d->m_selectionGranularity);
}
d->m_beganSelectingText = true;
} else {
sel = pos;
- d->m_selectionGranularity = Selection::CHARACTER;
+ d->m_selectionGranularity = CHARACTER;
}
}
}
sel.setExtent(pos);
- if (d->m_selectionGranularity != Selection::CHARACTER) {
+ if (d->m_selectionGranularity != CHARACTER) {
sel.expandUsingGranularity(d->m_selectionGranularity);
}
setSelection(sel);
if (!d->m_doc)
return;
NodeImpl *de = d->m_doc->documentElement();
- CaretPosition start(de, 0);
- CaretPosition end(de, de ? de->childNodeCount() : 0);
- Selection selection(start.deepEquivalent(), end.deepEquivalent());
- setSelection(selection);
+ int n = de ? de->childNodeCount() : 0;
+ setSelection(Selection(VisiblePosition(de, 0), VisiblePosition(de, n)));
}
bool KHTMLPart::shouldBeginEditing(const Range &range) const
#ifndef __khtml_part_h__
#define __khtml_part_h__
-#include "editing/selection.h" // only for text granularity -- should fix this to reduce dependencies
+#include "editing/text_granularity.h"
#include <kparts/part.h>
#include <kparts/browserextension.h>
class Node;
class NodeImpl;
class Range;
- class Selection;
}
namespace khtml
class RenderPart;
class RenderPartObject;
class RenderWidget;
+ class Selection;
class XMLTokenizer;
}
/**
* Returns the selected part of the HTML.
*/
- const DOM::Selection &selection() const;
+ const khtml::Selection &selection() const;
- DOM::Selection::ETextGranularity selectionGranularity() const;
+ /**
+ * Returns the granularity of the selection (character, word, line, paragraph).
+ */
+ khtml::ETextGranularity selectionGranularity() const;
/**
* Returns the drag caret of the HTML.
*/
- const DOM::Selection &dragCaret() const;
+ const khtml::Selection &dragCaret() const;
/**
* Sets the current selection.
*/
- void setSelection(const DOM::Selection &, bool closeTyping = true, bool unmarkOldSelection = true);
+ void setSelection(const khtml::Selection &, bool closeTyping = true, bool unmarkOldSelection = true);
/**
* Returns a mark, to be used as emacs uses it.
*/
- const DOM::Selection &mark() const;
+ const khtml::Selection &mark() const;
/**
* Returns the mark.
*/
- void setMark(const DOM::Selection &);
+ void setMark(const khtml::Selection &);
/**
* Sets the current drag cart.
*/
- void setDragCaret(const DOM::Selection &);
+ void setDragCaret(const khtml::Selection &);
/**
* Clears the current selection.
KHTMLPartPrivate *d;
friend class KHTMLPartPrivate;
- friend class DOM::Selection;
+ friend class khtml::Selection;
#if APPLE_CHANGES
public:
bool m_bMousePressed;
DOM::Node m_mousePressNode; //node under the mouse when the mouse was pressed (set in the mouse handler)
- DOM::Selection::ETextGranularity m_selectionGranularity;
+ khtml::ETextGranularity m_selectionGranularity;
bool m_beganSelectingText;
#if !APPLE_CHANGES
QString m_overURL;
QString m_overURLTarget;
#endif
- DOM::Selection m_selection;
- DOM::Selection m_dragCaret;
- DOM::Selection m_mark;
+ khtml::Selection m_selection;
+ khtml::Selection m_dragCaret;
+ khtml::Selection m_mark;
int m_caretBlinkTimer;
bool m_caretVisible:1;
#include "xml/dom_position.h"
#include "html/html_formimpl.h"
#include "render_block.h"
+#include "editing/selection.h"
#include "khtmlview.h"
#include "khtml_part.h"
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* (C) 1999 Antti Koivisto (koivisto@kde.org)
* (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003 Apple Computer, Inc.
+ * Copyright (C) 2004 Apple Computer, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
class ProcessingInstructionImpl;
class RangeImpl;
class RegisteredEventListener;
- class Selection;
class StyleSheetImpl;
class StyleSheetListImpl;
class TextImpl;
*/
#include "xml/dom_nodeimpl.h"
+
#include "dom/dom_exception.h"
#include "misc/htmlattrs.h"
#include "misc/htmltags.h"
#include "xml/dom2_rangeimpl.h"
#include "css/csshelper.h"
#include "css/cssstyleselector.h"
+#include "editing/selection.h"
#include <kglobal.h>
#include <kdebug.h>
NodeImpl::setFocus(received);
if (received && isEditableBlock() && !hasChildNodes()) {
- KHTMLPart *part = getDocument()->part();
- part->setSelection(Selection(Position(this, 0)));
+ getDocument()->part()->setSelection(Position(this, 0));
}
// note that we need to recalc the style
NSImage *snapshotDragImage(DOM::Node node, NSRect *imageRect, NSRect *elementRect) const;
NSFont *fontForSelection(bool *hasMultipleFonts) const;
- void markMisspellingsInSelection(const DOM::Selection &selection);
+ void markMisspellingsInSelection(const khtml::Selection &selection);
void updateSpellChecking();
NSFileWrapper *fileWrapperForElement(DOM::ElementImpl *);
#undef _KWQ_TIMING
using DOM::AtomicString;
-using DOM::CaretPosition;
using DOM::ClipboardEventImpl;
using DOM::DocumentFragmentImpl;
using DOM::DocumentImpl;
using DOM::HTMLFrameElementImpl;
using DOM::HTMLGenericFormElementImpl;
using DOM::HTMLTableCellElementImpl;
-using DOM::LeftWordIfOnBoundary;
using DOM::Node;
using DOM::NodeImpl;
using DOM::Position;
using DOM::Range;
using DOM::RangeImpl;
-using DOM::RightWordIfOnBoundary;
-using DOM::Selection;
using DOM::TextImpl;
using DOM::UPSTREAM;
using khtml::ChildFrame;
using khtml::Decoder;
using khtml::DashboardRegionValue;
+using khtml::endOfWord;
using khtml::findPlainText;
using khtml::InlineTextBox;
+using khtml::LeftWordIfOnBoundary;
using khtml::MouseDoubleClickEvent;
using khtml::MouseMoveEvent;
using khtml::MousePressEvent;
using khtml::RenderTableCell;
using khtml::RenderText;
using khtml::RenderWidget;
+using khtml::RightWordIfOnBoundary;
+using khtml::Selection;
+using khtml::setEnd;
+using khtml::setStart;
+using khtml::startOfWord;
+using khtml::startVisiblePosition;
using khtml::TextIterator;
using khtml::VISIBLE;
+using khtml::VisiblePosition;
using khtml::WordAwareIterator;
using KIO::Job;
if (selectionStart()) {
startedWithSelection = true;
if (startBeforeSelection) {
- CaretPosition start = selection().start();
+ VisiblePosition start = selection().start();
// We match AppKit's rule: Start 1 character before the selection.
- CaretPosition oneBeforeStart = start.previous();
+ VisiblePosition oneBeforeStart = start.previous();
setStart(searchRange, oneBeforeStart.isNotNull() ? oneBeforeStart : start);
} else {
- setStart(searchRange, CaretPosition(selection().end()));
+ setStart(searchRange, VisiblePosition(selection().end()));
}
}
// 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) {
- CaretPosition oneBeforeStart = start(searchRange).previous();
+ VisiblePosition oneBeforeStart = startVisiblePosition(searchRange).previous();
if (oneBeforeStart.isNotNull()) {
setStart(searchRange, endOfWord(oneBeforeStart));
} // else we were already at the start of the editable node
// So, for now, the idea is to mimic AppKit behavior and limit the selection to the first word
// of the selection passed in.
// This is not ideal by any means, but this is the convention.
- CaretPosition end = endOfWord(selection.start());
+ VisiblePosition end = endOfWord(selection.start());
if (end == selection.start())
end = endOfWord(end.next());
Selection s(startOfWord(selection.start()), end);
if ([_bridge isContinuousSpellCheckingEnabled]) {
// This only erases a marker in the first word of the selection. Perhaps peculiar, but it
// matches AppKit.
- CaretPosition start(startOfWord(selection().start(), LeftWordIfOnBoundary));
- CaretPosition end(endOfWord(selection().start(), LeftWordIfOnBoundary));
+ VisiblePosition start(startOfWord(selection().start(), LeftWordIfOnBoundary));
+ VisiblePosition end(endOfWord(selection().start(), LeftWordIfOnBoundary));
if (end == selection().start())
end = endOfWord(end, RightWordIfOnBoundary);
Selection selection(start, end);
#include "KWQRenderTreeDebug.h"
+#include "dom_docimpl.h"
+#include "dom_position.h"
#include "htmltags.h"
#include "khtmlview.h"
+#include "render_canvas.h"
#include "render_replaced.h"
#include "render_table.h"
#include "render_text.h"
-#include "render_canvas.h"
-#include "xml/dom_docimpl.h"
-#include "xml/dom_nodeimpl.h"
-#include "xml/dom_position.h"
+#include "selection.h"
#include "KWQKHTMLPart.h"
#include "KWQTextStream.h"
using DOM::DocumentImpl;
using DOM::NodeImpl;
using DOM::Position;
-using DOM::Selection;
+
+using khtml::BorderValue;
+using khtml::EBorderStyle;
+using khtml::InlineTextBox;
using khtml::RenderLayer;
using khtml::RenderObject;
using khtml::RenderTableCell;
using khtml::RenderWidget;
using khtml::RenderText;
using khtml::RenderCanvas;
-using khtml::InlineTextBox;
-using khtml::BorderValue;
-using khtml::EBorderStyle;
+using khtml::Selection;
using khtml::transparentColor;
static void writeLayers(QTextStream &ts, const RenderLayer* rootLayer, RenderLayer* l,
@class NSView;
using DOM::AtomicString;
-using DOM::CaretPosition;
using DOM::DocumentFragmentImpl;
using DOM::DocumentImpl;
using DOM::DocumentTypeImpl;
using DOM::NodeImpl;
using DOM::Position;
using DOM::Range;
-using DOM::Selection;
using DOM::UPSTREAM;
using khtml::ApplyStyleCommand;
using khtml::DeleteSelectionCommand;
using khtml::EditCommand;
using khtml::EditCommandImpl;
+using khtml::ETextGranularity;
using khtml::MoveSelectionCommand;
using khtml::parseURL;
using khtml::RenderCanvas;
using khtml::RenderStyle;
using khtml::RenderWidget;
using khtml::ReplaceSelectionCommand;
+using khtml::Selection;
using khtml::TypingCommand;
+using khtml::VisiblePosition;
using KJS::ExecState;
using KJS::ObjectImp;
// NOTE: The enums *must* match the very similar ones declared in ktml_selection.h
Selection selection(_part->selection());
- selection.expandUsingGranularity(static_cast<Selection::ETextGranularity>(granularity));
+ selection.expandUsingGranularity(static_cast<ETextGranularity>(granularity));
return [DOMRange _rangeWithImpl:selection.toRange().handle()];
}
Selection selection(_part->selection());
selection.modify(static_cast<Selection::EAlter>(alteration),
static_cast<Selection::EDirection>(direction),
- static_cast<Selection::ETextGranularity>(granularity));
+ static_cast<ETextGranularity>(granularity));
return [DOMRange _rangeWithImpl:selection.toRange().handle()];
}
Selection selection(_part->selection());
selection.modify(static_cast<Selection::EAlter>(alteration),
static_cast<Selection::EDirection>(direction),
- static_cast<Selection::ETextGranularity>(granularity));
+ static_cast<ETextGranularity>(granularity));
// save vertical navigation x position if necessary
int xPos = KHTMLPart::NoXPosForVerticalArrowNavigation;
if (!selection.isCaret())
return nil;
- CaretPosition caret(selection.start());
- CaretPosition next = caret.next();
- CaretPosition previous = caret.previous();
+ VisiblePosition caret(selection.start());
+ VisiblePosition next = caret.next();
+ VisiblePosition previous = caret.previous();
if (caret == next || caret == previous)
return nil;
git://git.webkit.org / WebKit-https.git / commitdiff