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 blink {
     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     bool intersectsNode(Node*) const;
    100 
    101     // FIXME: Most callers probably don't want these functions, but
    102     // are using them for historical reasons. toNormalizedRange and
    103     // toNormalizedPositions contracts the range around text, and
    104     // moves the caret upstream before returning the range/positions.
    105     PassRefPtrWillBeRawPtr<Range> toNormalizedRange() const;
    106     bool toNormalizedPositions(Position& start, Position& end) const;
    107 
    108     Element* rootEditableElement() const;
    109     bool isContentEditable() const;
    110     bool hasEditableStyle() const;
    111     bool isContentRichlyEditable() const;
    112     // Returns a shadow tree node for legacy shadow trees, a child of the
    113     // ShadowRoot node for new shadow trees, or 0 for non-shadow trees.
    114     Node* nonBoundaryShadowTreeRootNode() const;
    115 
    116     VisiblePosition visiblePositionRespectingEditingBoundary(const LayoutPoint& localPoint, Node* targetNode) const;
    117 
    118     void setWithoutValidation(const Position&, const Position&);
    119 
    120     // Listener of VisibleSelection modification. didChangeVisibleSelection() will be invoked when base, extent, start
    121     // or end is moved to a different position.
    122     //
    123     // Objects implementing |ChangeObserver| interface must outlive the VisibleSelection object.
    124     class ChangeObserver : public WillBeGarbageCollectedMixin {
    125         WTF_MAKE_NONCOPYABLE(ChangeObserver);
    126     public:
    127         ChangeObserver();
    128         virtual ~ChangeObserver();
    129         virtual void didChangeVisibleSelection() = 0;
    130         virtual void trace(Visitor*) { }
    131     };
    132 
    133     void setChangeObserver(ChangeObserver&);
    134     void clearChangeObserver();
    135     void didChange(); // Fire the change observer, if any.
    136 
    137     void trace(Visitor*);
    138 
    139     void validatePositionsIfNeeded();
    140 
    141 #ifndef NDEBUG
    142     void debugPosition() const;
    143     void formatForDebugger(char* buffer, unsigned length) const;
    144     void showTreeForThis() const;
    145 #endif
    146 
    147 private:
    148     void validate(TextGranularity = CharacterGranularity);
    149 
    150     // Support methods for validate()
    151     void setBaseAndExtentToDeepEquivalents();
    152     void setStartAndEndFromBaseAndExtentRespectingGranularity(TextGranularity);
    153     void adjustSelectionToAvoidCrossingShadowBoundaries();
    154     void adjustSelectionToAvoidCrossingEditingBoundaries();
    155     void updateSelectionType();
    156 
    157     // We need to store these as Positions because VisibleSelection is
    158     // used to store values in editing commands for use when
    159     // undoing the command. We need to be able to create a selection that, while currently
    160     // invalid, will be valid once the changes are undone.
    161 
    162     Position m_base;   // Where the first click happened
    163     Position m_extent; // Where the end click happened
    164     Position m_start;  // Leftmost position when expanded to respect granularity
    165     Position m_end;    // Rightmost position when expanded to respect granularity
    166 
    167     EAffinity m_affinity;           // the upstream/downstream affinity of the caret
    168 
    169     // Oilpan: this reference has a lifetime that is at least as long
    170     // as this object.
    171     RawPtrWillBeMember<ChangeObserver> m_changeObserver;
    172 
    173     // these are cached, can be recalculated by validate()
    174     SelectionType m_selectionType; // None, Caret, Range
    175     bool m_baseIsFirst : 1; // True if base is before the extent
    176     bool m_isDirectional : 1; // Non-directional ignores m_baseIsFirst and selection always extends on shift + arrow key.
    177 };
    178 
    179 inline bool operator==(const VisibleSelection& a, const VisibleSelection& b)
    180 {
    181     return a.start() == b.start() && a.end() == b.end() && a.affinity() == b.affinity() && a.isBaseFirst() == b.isBaseFirst()
    182         && a.isDirectional() == b.isDirectional();
    183 }
    184 
    185 inline bool operator!=(const VisibleSelection& a, const VisibleSelection& b)
    186 {
    187     return !(a == b);
    188 }
    189 
    190 } // namespace blink
    191 
    192 #ifndef NDEBUG
    193 // Outside the WebCore namespace for ease of invocation from gdb.
    194 void showTree(const blink::VisibleSelection&);
    195 void showTree(const blink::VisibleSelection*);
    196 #endif
    197 
    198 #endif // VisibleSelection_h
    199