Home | History | Annotate | Download | only in editing 
      1 /*
      2  * Copyright (C) 2004 Apple Computer, Inc.  All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #ifndef VisibleSelection_h
     27 #define VisibleSelection_h
     28 
     29 #include "core/editing/SelectionType.h"
     30 #include "core/editing/TextGranularity.h"
     31 #include "core/editing/VisiblePosition.h"
     32 
     33 namespace WebCore {
     34 
     35 class LayoutPoint;
     36 class Position;
     37 
     38 const EAffinity SEL_DEFAULT_AFFINITY = DOWNSTREAM;
     39 enum SelectionDirection { DirectionForward, DirectionBackward, DirectionRight, DirectionLeft };
     40 
     41 class VisibleSelection {
     42     DISALLOW_ALLOCATION();
     43 public:
     44     VisibleSelection();
     45 
     46     VisibleSelection(const Position&, EAffinity, bool isDirectional = false);
     47     VisibleSelection(const Position&, const Position&, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
     48 
     49     explicit VisibleSelection(const Range*, EAffinity = SEL_DEFAULT_AFFINITY, bool isDirectional = false);
     50 
     51     explicit VisibleSelection(const VisiblePosition&, bool isDirectional = false);
     52     VisibleSelection(const VisiblePosition&, const VisiblePosition&, bool isDirectional = false);
     53 
     54     VisibleSelection(const VisibleSelection&);
     55     VisibleSelection& operator=(const VisibleSelection&);
     56 
     57     ~VisibleSelection();
     58 
     59     static VisibleSelection selectionFromContentsOfNode(Node*);
     60 
     61     SelectionType selectionType() const { return m_selectionType; }
     62 
     63     void setAffinity(EAffinity affinity) { m_affinity = affinity; }
     64     EAffinity affinity() const { return m_affinity; }
     65 
     66     void setBase(const Position&);
     67     void setBase(const VisiblePosition&);
     68     void setExtent(const Position&);
     69     void setExtent(const VisiblePosition&);
     70 
     71     Position base() const { return m_base; }
     72     Position extent() const { return m_extent; }
     73     Position start() const { return m_start; }
     74     Position end() const { return m_end; }
     75 
     76     VisiblePosition visibleStart() const { return VisiblePosition(m_start, isRange() ? DOWNSTREAM : affinity()); }
     77     VisiblePosition visibleEnd() const { return VisiblePosition(m_end, isRange() ? UPSTREAM : affinity()); }
     78     VisiblePosition visibleBase() const { return VisiblePosition(m_base, isRange() ? (isBaseFirst() ? UPSTREAM : DOWNSTREAM) : affinity()); }
     79     VisiblePosition visibleExtent() const { return VisiblePosition(m_extent, isRange() ? (isBaseFirst() ? DOWNSTREAM : UPSTREAM) : affinity()); }
     80 
     81     bool isNone() const { return selectionType() == NoSelection; }
     82     bool isCaret() const { return selectionType() == CaretSelection; }
     83     bool isRange() const { return selectionType() == RangeSelection; }
     84     bool isCaretOrRange() const { return selectionType() != NoSelection; }
     85     bool isNonOrphanedRange() const { return isRange() && !start().isOrphan() && !end().isOrphan(); }
     86     bool isNonOrphanedCaretOrRange() const { return isCaretOrRange() && !start().isOrphan() && !end().isOrphan(); }
     87 
     88     bool isBaseFirst() const { return m_baseIsFirst; }
     89     bool isDirectional() const { return m_isDirectional; }
     90     void setIsDirectional(bool isDirectional) { m_isDirectional = isDirectional; }
     91 
     92     void appendTrailingWhitespace();
     93 
     94     bool expandUsingGranularity(TextGranularity granularity);
     95 
     96     // We don't yet support multi-range selections, so we only ever have one range to return.
     97     PassRefPtrWillBeRawPtr<Range> firstRange() const;
     98 
     99     // FIXME: Most callers probably don't want this function, but are using it
    100     // for historical reasons.  toNormalizedRange contracts the range around
    101     // text, and moves the caret upstream before returning the range.
    102     PassRefPtrWillBeRawPtr<Range> toNormalizedRange() const;
    103 
    104     Element* rootEditableElement() const;
    105     bool isContentEditable() const;
    106     bool rendererIsEditable() const;
    107     bool isContentRichlyEditable() const;
    108     // Returns a shadow tree node for legacy shadow trees, a child of the
    109     // ShadowRoot node for new shadow trees, or 0 for non-shadow trees.
    110     Node* nonBoundaryShadowTreeRootNode() const;
    111 
    112     VisiblePosition visiblePositionRespectingEditingBoundary(const LayoutPoint& localPoint, Node* targetNode) const;
    113 
    114     void setWithoutValidation(const Position&, const Position&);
    115 
    116     // Listener of VisibleSelection modification. didChangeVisibleSelection() will be invoked when base, extent, start
    117     // or end is moved to a different position.
    118     //
    119     // Objects implementing |ChangeObserver| interface must outlive the VisibleSelection object.
    120     class ChangeObserver : public WillBeGarbageCollectedMixin {
    121         WTF_MAKE_NONCOPYABLE(ChangeObserver);
    122     public:
    123         ChangeObserver();
    124         virtual ~ChangeObserver();
    125         virtual void didChangeVisibleSelection() = 0;
    126         virtual void trace(Visitor*) { }
    127     };
    128 
    129     void setChangeObserver(ChangeObserver&);
    130     void clearChangeObserver();
    131     void didChange(); // Fire the change observer, if any.
    132 
    133     void trace(Visitor*);
    134 
    135     void validatePositionsIfNeeded();
    136 
    137 #ifndef NDEBUG
    138     void debugPosition() const;
    139     void formatForDebugger(char* buffer, unsigned length) const;
    140     void showTreeForThis() const;
    141 #endif
    142 
    143 private:
    144     void validate(TextGranularity = CharacterGranularity);
    145 
    146     // Support methods for validate()
    147     void setBaseAndExtentToDeepEquivalents();
    148     void setStartAndEndFromBaseAndExtentRespectingGranularity(TextGranularity);
    149     void adjustSelectionToAvoidCrossingShadowBoundaries();
    150     void adjustSelectionToAvoidCrossingEditingBoundaries();
    151     void updateSelectionType();
    152 
    153     // We need to store these as Positions because VisibleSelection is
    154     // used to store values in editing commands for use when
    155     // undoing the command. We need to be able to create a selection that, while currently
    156     // invalid, will be valid once the changes are undone.
    157 
    158     Position m_base;   // Where the first click happened
    159     Position m_extent; // Where the end click happened
    160     Position m_start;  // Leftmost position when expanded to respect granularity
    161     Position m_end;    // Rightmost position when expanded to respect granularity
    162 
    163     EAffinity m_affinity;           // the upstream/downstream affinity of the caret
    164 
    165     // Oilpan: this reference has a lifetime that is at least as long
    166     // as this object.
    167     RawPtrWillBeMember<ChangeObserver> m_changeObserver;
    168 
    169     // these are cached, can be recalculated by validate()
    170     SelectionType m_selectionType; // None, Caret, Range
    171     bool m_baseIsFirst : 1; // True if base is before the extent
    172     bool m_isDirectional : 1; // Non-directional ignores m_baseIsFirst and selection always extends on shift + arrow key.
    173 };
    174 
    175 inline bool operator==(const VisibleSelection& a, const VisibleSelection& b)
    176 {
    177     return a.start() == b.start() && a.end() == b.end() && a.affinity() == b.affinity() && a.isBaseFirst() == b.isBaseFirst()
    178         && a.isDirectional() == b.isDirectional();
    179 }
    180 
    181 inline bool operator!=(const VisibleSelection& a, const VisibleSelection& b)
    182 {
    183     return !(a == b);
    184 }
    185 
    186 } // namespace WebCore
    187 
    188 #ifndef NDEBUG
    189 // Outside the WebCore namespace for ease of invocation from gdb.
    190 void showTree(const WebCore::VisibleSelection&);
    191 void showTree(const WebCore::VisibleSelection*);
    192 #endif
    193 
    194 #endif // VisibleSelection_h
    195