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
|
/*
* Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef RenderQueue_h
#define RenderQueue_h
#include <BlackBerryPlatformIntRectRegion.h>
#include <BlackBerryPlatformPrimitives.h>
#include <vector>
namespace BlackBerry {
namespace WebKit {
class BackingStorePrivate;
typedef std::vector<Platform::IntRect> IntRectList;
enum SortDirection {
LeftToRight = 0,
RightToLeft,
TopToBottom,
BottomToTop,
NumSortDirections
};
class RenderRect : public Platform::IntRect {
public:
RenderRect() { }
RenderRect(const Platform::IntPoint& location, const Platform::IntSize&, int splittingFactor);
RenderRect(int x, int y, int width, int height, int splittingFactor);
RenderRect(const Platform::IntRect&);
Platform::IntRect rectForRendering();
bool isCompleted() const { return !m_subRects.size(); }
const IntRectList& subRects() const { return m_subRects; }
void updateSortDirection(SortDirection primary, SortDirection secondary);
private:
void initialize(int splittingFactor);
void split();
void quickSort();
int m_splittingFactor;
IntRectList m_subRects;
SortDirection m_primarySortDirection;
SortDirection m_secondarySortDirection;
};
typedef std::vector<RenderRect> RenderRectList;
class RenderQueue {
public:
enum JobType { VisibleZoom, VisibleScroll, RegularRender, NonVisibleScroll };
RenderQueue(BackingStorePrivate*);
void reset();
RenderRect convertToRenderRect(const Platform::IntRect&) const;
bool isEmpty(bool shouldPerformRegularRenderJobs = true) const;
bool hasCurrentRegularRenderJob() const;
bool hasCurrentVisibleZoomJob() const;
bool hasCurrentVisibleScrollJob() const;
bool isCurrentVisibleScrollJob(const Platform::IntRect&) const;
bool isCurrentVisibleScrollJobCompleted(const Platform::IntRect&) const;
bool isCurrentRegularRenderJob(const Platform::IntRect&) const;
bool currentRegularRenderJobBatchUnderPressure() const;
void setCurrentRegularRenderJobBatchUnderPressure(bool);
void eventQueueCycled();
void addToQueue(JobType, const Platform::IntRect&);
void addToQueue(JobType, const IntRectList&);
void updateSortDirection(int lastDeltaX, int lastDeltaY);
void visibleContentChanged(const Platform::IntRect&);
void clear(const Platform::IntRectRegion&, bool clearRegularRenderJobs);
void clear(const Platform::IntRect&, bool clearRegularRenderJobs);
void clearRegularRenderJobs(const Platform::IntRect&);
void clearVisibleZoom();
bool regularRenderJobsPreviouslyAttemptedButNotRendered(const Platform::IntRect&);
Platform::IntRectRegion regularRenderJobsNotRenderedRegion() const { return m_regularRenderJobsNotRenderedRegion; }
void render(bool shouldPerformRegularRenderJobs = true);
void renderAllCurrentRegularRenderJobs();
private:
void startRegularRenderJobBatchIfNeeded();
// Render an item from the queue.
void renderVisibleZoomJob();
void renderVisibleScrollJob();
void renderRegularRenderJob();
void renderNonVisibleScrollJob();
// Methods to handle a completed set of scroll jobs.
void visibleScrollJobsCompleted(bool shouldBlit);
void nonVisibleScrollJobsCompleted();
// Internal method to add to the various queues.
void addToRegularQueue(const Platform::IntRect&);
void addToScrollZoomQueue(const RenderRect&, RenderRectList* queue);
void quickSort(RenderRectList*);
// The splitting factor for render rects.
int splittingFactor(const Platform::IntRect&) const;
BackingStorePrivate* m_parent;
// The highest priority queue.
RenderRectList m_visibleZoomJobs;
RenderRectList m_visibleScrollJobs;
RenderRectList m_visibleScrollJobsCompleted;
// The lowest priority queue.
RenderRectList m_nonVisibleScrollJobs;
RenderRectList m_nonVisibleScrollJobsCompleted;
// The regular render jobs are in the middle.
Platform::IntRectRegion m_regularRenderJobsRegion;
IntRectList m_currentRegularRenderJobsBatch;
Platform::IntRectRegion m_currentRegularRenderJobsBatchRegion;
bool m_rectsAddedToRegularRenderJobsInCurrentCycle;
bool m_currentRegularRenderJobsBatchUnderPressure;
// Holds the region of the page that we attempt to render, but the
// backingstore was not in the right place at the time. This will
// be checked before we try to restore a tile to it's last rendered
// place.
Platform::IntRectRegion m_regularRenderJobsNotRenderedRegion;
SortDirection m_primarySortDirection;
SortDirection m_secondarySortDirection;
};
} // namespace WebKit
} // namespace BlackBerry
#endif // RenderQueue_h
|
