1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
/*
* Copyright 2006, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CacheBuilder_H
#define CacheBuilder_H
#include "CachedDebug.h"
#include "CachedNodeType.h"
#include "IntRect.h"
#include "PlatformString.h"
#include "TextDirection.h"
#include <wtf/Forward.h>
#include <wtf/Vector.h>
#define NAVIGATION_MAX_PHONE_LENGTH 14
using namespace WebCore;
namespace WebCore {
class ColumnInfo;
class Document;
class Frame;
class HTMLAreaElement;
class InlineTextBox;
class LayerAndroid;
class Node;
class PlatformGraphicsContext;
class RenderBlock;
class RenderFlow;
class RenderLayer;
class RenderObject;
class Text;
}
namespace android {
class CachedFrame;
class CachedNode;
class CachedRoot;
class CacheBuilder {
public:
enum Direction {
UNINITIALIZED = -1,
LEFT,
RIGHT,
UP,
DOWN,
DIRECTION_COUNT,
UP_DOWN = UP & DOWN, // mask and result
RIGHT_DOWN = RIGHT & DOWN, // mask and result
};
enum FoundState {
FOUND_NONE,
FOUND_PARTIAL,
FOUND_COMPLETE
};
CacheBuilder();
void allowAllTextDetection() { mAllowableTypes = ALL_CACHEDNODE_BITS; }
void buildCache(CachedRoot* root);
static bool ConstructPartRects(Node* node, const IntRect& bounds,
IntRect* focusBounds, int x, int y, WTF::Vector<IntRect>* result,
int* imageCountPtr);
Node* currentFocus() const;
void disallowAddressDetection() { mAllowableTypes = (CachedNodeBits) (
mAllowableTypes & ~ADDRESS_CACHEDNODE_BIT); }
void disallowEmailDetection() { mAllowableTypes = (CachedNodeBits) (
mAllowableTypes & ~EMAIL_CACHEDNODE_BIT); }
void disallowPhoneDetection() { mAllowableTypes = (CachedNodeBits) (
mAllowableTypes & ~PHONE_CACHEDNODE_BIT); }
static FoundState FindAddress(const UChar* , unsigned length, int* start,
int* end, bool caseInsensitive);
static IntRect getAreaRect(const HTMLAreaElement* area);
static void GetGlobalOffset(Frame* , int* x, int * y);
static void GetGlobalOffset(Node* , int* x, int * y);
bool pictureSetDisabled() { return mPictureSetDisabled; }
static bool validNode(Frame* startFrame, void* framePtr, void* nodePtr);
private:
enum AddressProgress {
NO_ADDRESS,
SKIP_TO_SPACE,
HOUSE_NUMBER,
NUMBER_TRAILING_SPACE,
ADDRESS_LINE,
STATE_NAME,
SECOND_HALF,
ZIP_CODE,
PLUS_4,
FIND_STREET
};
struct NodeWalk {
NodeWalk() { reset(); }
int mStart;
int mEnd;
Node* mFinalNode;
InlineTextBox* mLastInline;
bool mMore;
void reset() { mMore = false; }
};
struct BoundsPart {
IntRect mRect;
int mStart;
int mEnd;
};
struct Bounds {
typedef bool (*FindText)(BoundsPart* result, InlineTextBox* , const String& match);
IntRect mNodeBounds;
BoundsPart mPart;
WTF::Vector<BoundsPart> mParts;
char mStore[NAVIGATION_MAX_PHONE_LENGTH + 1];
int mPartIndex;
Node* mNode;
Node* mFinalNode;
void reset() { mNode = NULL; }
};
struct FindState {
int mStartResult;
int mEndResult;
const UChar* mCurrentStart;
const UChar* mEnd;
AddressProgress mProgress;
int mNumberCount;
int mLetterCount;
unsigned mWordCount;
int mLineCount;
const UChar* mFirstLower;
const UChar* mZipStart;
const UChar* mBases[16]; // FIXME: random guess, maybe too small, maybe too big
const UChar* mWords[16];
const UChar* mEnds[16];
const UChar* mStarts[16]; // text is not necessarily contiguous
const char* mStates;
int mEndWord;
int mStateWord;
int mZipHint;
int mSectionLength;
unsigned mNumberWords; // must contain as many bits as mWords contains elements
char* mPattern;
UChar mStore[NAVIGATION_MAX_PHONE_LENGTH + 1];
UChar* mStorePtr;
UChar mBackOne;
UChar mBackTwo;
UChar mCurrent;
bool mUnparsed;
bool mZipDelimiter;
bool mOpenParen;
bool mInitialized;
bool mContinuationNode;
bool mCaseInsensitive;
void shiftWords(int shift) {
memmove(mBases, &mBases[shift], (sizeof(mBases) /
sizeof(mBases[0]) - shift) * sizeof(mBases[0]));
memmove(mWords, &mWords[shift], (sizeof(mWords) /
sizeof(mWords[0]) - shift) * sizeof(mWords[0]));
memmove(mEnds, &mEnds[shift], (sizeof(mEnds) /
sizeof(mEnds[0]) - shift) * sizeof(mEnds[0]));
memmove(mStarts, &mStarts[shift], (sizeof(mStarts) /
sizeof(mStarts[0]) - shift) * sizeof(mStarts[0]));
}
void newWord(const UChar* baseChars, const UChar* chars) {
mBases[mWordCount] = baseChars;
mWords[mWordCount] = chars;
mEnds[mWordCount] = mEnd;
mStarts[mWordCount] = mCurrentStart;
}
};
struct Tracker {
Node* mLastChild;
};
struct ClipColumnTracker : Tracker {
Node* mNode;
IntRect mBounds;
ColumnInfo* mColumnInfo;
int mColumnGap;
TextDirection mDirection;
bool mHasClip;
};
struct LayerTracker : Tracker {
LayerAndroid* mLayer;
RenderLayer* mRenderLayer;
IntRect mBounds;
IntPoint mScroll;
~LayerTracker();
};
struct TabIndexTracker : Tracker {
int mTabIndex;
};
struct FocusTracker : TabIndexTracker {
int mCachedNodeIndex;
bool mSomeParentTakesFocus;
};
void adjustForColumns(const ClipColumnTracker& track,
CachedNode* node, IntRect* bounds, RenderBlock*);
static bool AddPartRect(IntRect& bounds, int x, int y,
WTF::Vector<IntRect>* result, IntRect* focusBounds);
static bool AnyIsClick(Node* node);
static bool AnyChildIsClick(Node* node);
static bool NodeHasEventListeners(Node* node, AtomicString* eventTypes, int length);
void BuildFrame(Frame* root, Frame* frame,
CachedRoot* cachedRoot, CachedFrame* cachedFrame);
bool CleanUpContainedNodes(CachedRoot* cachedRoot, CachedFrame* cachedFrame,
const FocusTracker* last, int lastChildIndex);
static bool ConstructTextRect(Text* textNode,
InlineTextBox* textBox, int start, int relEnd, int x, int y,
IntRect* focusBounds, const IntRect& clip, WTF::Vector<IntRect>* result);
static bool ConstructTextRects(Text* node, int start,
Text* last, int end, int x, int y, IntRect* focusBounds,
const IntRect& clip, WTF::Vector<IntRect>* result);
static FoundState FindPartialAddress(const UChar* , const UChar* , unsigned length, FindState* );
static FoundState FindPartialEMail(const UChar* , unsigned length, FindState* );
static FoundState FindPartialNumber(const UChar* , unsigned length, FindState* );
static FoundState FindPhoneNumber(const UChar* chars, unsigned length, int* start, int* end);
static void FindReset(FindState* );
static void FindResetNumber(FindState* );
static Frame* FrameAnd(CacheBuilder* focusNav);
static Frame* FrameAnd(const CacheBuilder* focusNav);
static CacheBuilder* Builder(Frame* );
static Frame* HasFrame(Node* );
static bool HasOverOrOut(Node* );
static bool HasTriggerEvent(Node* );
static bool IsDomainChar(UChar ch);
bool isFocusableText(NodeWalk* , bool oldMore, Node* , CachedNodeType* type,
String* exported) const; //returns true if it is focusable
static bool IsMailboxChar(UChar ch);
static bool IsRealNode(Frame* , Node* );
int overlap(int left, int right); // returns distance scale factor as 16.16 scalar
bool setData(CachedFrame* );
#if USE(ACCELERATED_COMPOSITING)
void TrackLayer(WTF::Vector<LayerTracker>& layerTracker,
RenderObject* nodeRenderer, Node* lastChild, int offsetX, int offsetY);
#endif
Node* tryFocus(Direction direction);
Node* trySegment(Direction direction, int mainStart, int mainEnd);
CachedNodeBits mAllowableTypes;
bool mPictureSetDisabled;
#if DUMP_NAV_CACHE
public:
class Debug {
public:
void frameName(char*& namePtr, const char* max) const;
void init(char* buffer, size_t size);
static int ParentIndex(Node* node, int count, Node* parent);
void print() { frames(); }
void print(const char* name);
void wideString(const String& str);
private:
void attr(const AtomicString& name, const AtomicString& value);
void comma(const char* str);
void flush();
Frame* frameAnd() const;
void frames();
void groups();
bool isFocusable(Node* node);
void localName(Node* node);
void newLine(int indent = 0);
void print(const char* name, unsigned len);
void setIndent(int );
void uChar(const UChar* name, unsigned len, bool hex);
void validateFrame();
void validateStringData();
void wideString(const UChar* chars, int length, bool hex);
char* mBuffer;
size_t mBufferSize;
int mIndex;
const char* mPrefix;
int mMinPrefix;
} mDebug;
#endif
};
}
#endif
|
