]> git.saurik.com Git - wxWidgets.git/blob - src/common/windowid.cpp
fix building with WXWIN_COMPATIBILITY_2_8 == 0
[wxWidgets.git] / src / common / windowid.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/windowid.cpp
3 // Purpose: wxWindowID class - a class for managing window ids
4 // Author: Brian Vanderburg II
5 // Created: 2007-09-21
6 // Copyright: (c) 2007 Brian Vanderburg II
7 // Licence: wxWindows licence
8 ///////////////////////////////////////////////////////////////////////////////
9
10 // ----------------------------------------------------------------------------
11 // Needed headers
12 // ----------------------------------------------------------------------------
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #ifndef WX_PRECOMP
20 #include "wx/log.h"
21 #include "wx/intl.h"
22 #endif //WX_PRECOMP
23
24 #include "wx/hashmap.h"
25
26 // Not needed, included in defs.h
27 // #include "wx/windowid.h"
28
29 #define wxTRACE_WINDOWID wxT("windowid")
30
31 namespace
32 {
33
34 #if wxUSE_AUTOID_MANAGEMENT
35
36
37 // initially no ids are in use and we allocate them consecutively, but after we
38 // exhaust the entire range, we wrap around and reuse the ids freed in the
39 // meanwhile
40 static const wxUint8 ID_FREE = 0;
41 static const wxUint8 ID_STARTCOUNT = 1;
42 static const wxUint8 ID_COUNTTOOLARGE = 254;
43 static const wxUint8 ID_RESERVED = 255;
44
45 // we use a two level count, most IDs will be used less than ID_COUNTTOOLARGE-1
46 // thus we store their count directly in this array, however when the same ID
47 // is reused a great number of times (more than or equal to ID_COUNTTOOLARGE),
48 // the hash map stores the actual count
49 wxUint8 gs_autoIdsRefCount[wxID_AUTO_HIGHEST - wxID_AUTO_LOWEST + 1] = { 0 };
50
51 // NB: this variable is allocated (again) only when an ID gets at least
52 // ID_COUNTTOOLARGE refs, and is freed when the latest entry in the map gets
53 // freed. The cell storing the count for an ID is freed only when its count
54 // gets to zero (not when it goes below ID_COUNTTOOLARGE, so as to avoid
55 // degenerate cases)
56 wxLongToLongHashMap *gs_autoIdsLargeRefCount = NULL;
57
58 // this is an optimization used until we wrap around wxID_AUTO_HIGHEST: if this
59 // value is < wxID_AUTO_HIGHEST we know that we haven't wrapped yet and so can
60 // allocate the ids simply by incrementing it
61 wxWindowID gs_nextAutoId = wxID_AUTO_LOWEST;
62
63 // Reserve an ID
64 void ReserveIdRefCount(wxWindowID winid)
65 {
66 wxCHECK_RET(winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST,
67 wxT("invalid id range"));
68
69 winid -= wxID_AUTO_LOWEST;
70
71 wxCHECK_RET(gs_autoIdsRefCount[winid] == ID_FREE,
72 wxT("id already in use or already reserved"));
73 gs_autoIdsRefCount[winid] = ID_RESERVED;
74 }
75
76 // Unreserve and id
77 void UnreserveIdRefCount(wxWindowID winid)
78 {
79 wxCHECK_RET(winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST,
80 wxT("invalid id range"));
81
82 winid -= wxID_AUTO_LOWEST;
83
84 wxCHECK_RET(gs_autoIdsRefCount[winid] == ID_RESERVED,
85 wxT("id already in use or not reserved"));
86 gs_autoIdsRefCount[winid] = ID_FREE;
87 }
88
89 // Get the usage count of an id
90 int GetIdRefCount(wxWindowID winid)
91 {
92 wxCHECK_MSG(winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST, 0,
93 wxT("invalid id range"));
94
95 winid -= wxID_AUTO_LOWEST;
96 int refCount = gs_autoIdsRefCount[winid];
97 if (refCount == ID_COUNTTOOLARGE)
98 refCount = (*gs_autoIdsLargeRefCount)[winid];
99 return refCount;
100 }
101
102 // Increase the count for an id
103 void IncIdRefCount(wxWindowID winid)
104 {
105 wxCHECK_RET(winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST,
106 wxT("invalid id range"));
107
108 winid -= wxID_AUTO_LOWEST;
109
110 wxCHECK_RET(gs_autoIdsRefCount[winid] != ID_FREE, wxT("id should first be reserved"));
111
112 if(gs_autoIdsRefCount[winid] == ID_RESERVED)
113 {
114 gs_autoIdsRefCount[winid] = ID_STARTCOUNT;
115 }
116 else if (gs_autoIdsRefCount[winid] >= ID_COUNTTOOLARGE-1)
117 {
118 if (gs_autoIdsRefCount[winid] == ID_COUNTTOOLARGE-1)
119 {
120 // we need to allocate a cell, and maybe the hash map itself
121 if (!gs_autoIdsLargeRefCount)
122 gs_autoIdsLargeRefCount = new wxLongToLongHashMap;
123 (*gs_autoIdsLargeRefCount)[winid] = ID_COUNTTOOLARGE-1;
124
125 gs_autoIdsRefCount[winid] = ID_COUNTTOOLARGE;
126 }
127 ++(*gs_autoIdsLargeRefCount)[winid];
128 }
129 else
130 {
131 gs_autoIdsRefCount[winid]++;
132 }
133
134 wxLogTrace(wxTRACE_WINDOWID, wxT("Increasing ref count of ID %d to %d"),
135 winid + wxID_AUTO_LOWEST, GetIdRefCount(winid + wxID_AUTO_LOWEST));
136 }
137
138 // Decrease the count for an id
139 void DecIdRefCount(wxWindowID winid)
140 {
141 wxCHECK_RET(winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST,
142 wxT("invalid id range"));
143
144 winid -= wxID_AUTO_LOWEST;
145
146 wxCHECK_RET(gs_autoIdsRefCount[winid] != ID_FREE, wxT("id count already 0"));
147
148 // DecIdRefCount is only called on an ID that has been IncIdRefCount'ed'
149 // so it should never be reserved, but test anyway
150 if(gs_autoIdsRefCount[winid] == ID_RESERVED)
151 {
152 wxFAIL_MSG(wxT("reserve id being decreased"));
153 gs_autoIdsRefCount[winid] = ID_FREE;
154 }
155 else if(gs_autoIdsRefCount[winid] == ID_COUNTTOOLARGE)
156 {
157 long &largeCount = (*gs_autoIdsLargeRefCount)[winid];
158 --largeCount;
159 if (largeCount == 0)
160 {
161 gs_autoIdsLargeRefCount->erase (winid);
162 gs_autoIdsRefCount[winid] = ID_FREE;
163
164 if (gs_autoIdsLargeRefCount->empty())
165 wxDELETE (gs_autoIdsLargeRefCount);
166 }
167 }
168 else
169 gs_autoIdsRefCount[winid]--;
170
171 wxLogTrace(wxTRACE_WINDOWID, wxT("Decreasing ref count of ID %d to %d"),
172 winid + wxID_AUTO_LOWEST, GetIdRefCount(winid + wxID_AUTO_LOWEST));
173 }
174
175 #else // wxUSE_AUTOID_MANAGEMENT
176
177 static wxWindowID gs_nextAutoId = wxID_AUTO_HIGHEST;
178
179 #endif
180
181 } // anonymous namespace
182
183
184 #if wxUSE_AUTOID_MANAGEMENT
185
186 void wxWindowIDRef::Assign(wxWindowID winid)
187 {
188 if ( winid != m_id )
189 {
190 // decrease count if it is in the managed range
191 if ( m_id >= wxID_AUTO_LOWEST && m_id <= wxID_AUTO_HIGHEST )
192 DecIdRefCount(m_id);
193
194 m_id = winid;
195
196 // increase count if it is in the managed range
197 if ( m_id >= wxID_AUTO_LOWEST && m_id <= wxID_AUTO_HIGHEST )
198 IncIdRefCount(m_id);
199 }
200 }
201
202 #endif // wxUSE_AUTOID_MANAGEMENT
203
204
205
206 wxWindowID wxIdManager::ReserveId(int count)
207 {
208 wxASSERT_MSG(count > 0, wxT("can't allocate less than 1 id"));
209
210
211 #if wxUSE_AUTOID_MANAGEMENT
212 if ( gs_nextAutoId + count - 1 <= wxID_AUTO_HIGHEST )
213 {
214 wxWindowID winid = gs_nextAutoId;
215
216 while(count--)
217 {
218 ReserveIdRefCount(gs_nextAutoId++);
219 }
220
221 return winid;
222 }
223 else
224 {
225 int found = 0;
226
227 for(wxWindowID winid = wxID_AUTO_LOWEST; winid <= wxID_AUTO_HIGHEST; winid++)
228 {
229 if(GetIdRefCount(winid) == 0)
230 {
231 found++;
232 if(found == count)
233 {
234 // Imagine this: 100 free IDs left. Then NewId(50) takes 50
235 // so 50 left. Then, the 25 before that last 50 are freed, but
236 // gs_nextAutoId does not decrement and stays where it is at
237 // with 50 free. Then NewId(75) gets called, and since there
238 // are only 50 left according to gs_nextAutoId, it does a
239 // search and finds the 75 at the end. Then NewId(10) gets
240 // called, and accorind to gs_nextAutoId, their are still
241 // 50 at the end so it returns them without testing the ref
242 // To fix this, the next ID is also updated here as needed
243 if(winid >= gs_nextAutoId)
244 gs_nextAutoId = winid + 1;
245
246 while(count--)
247 ReserveIdRefCount(winid--);
248
249 return winid + 1;
250 }
251 }
252 else
253 {
254 found = 0;
255 }
256 }
257 }
258
259 wxLogError(_("Out of window IDs. Recommend shutting down application."));
260 return wxID_NONE;
261 #else // !wxUSE_AUTOID_MANAGEMENT
262 // Make sure enough in the range
263 wxWindowID winid;
264
265 winid = gs_nextAutoId - count + 1;
266
267 if ( winid >= wxID_AUTO_LOWEST && winid <= wxID_AUTO_HIGHEST )
268 {
269 // There is enough, but it may be time to wrap
270 if(winid == wxID_AUTO_LOWEST)
271 gs_nextAutoId = wxID_AUTO_HIGHEST;
272 else
273 gs_nextAutoId = winid - 1;
274
275 return winid;
276 }
277 else
278 {
279 // There is not enough at the low end of the range or
280 // count was big enough to wrap around to the positive
281 // Surely 'count' is not so big to take up much of the range
282 gs_nextAutoId = wxID_AUTO_HIGHEST - count;
283 return gs_nextAutoId + 1;
284 }
285 #endif // wxUSE_AUTOID_MANAGEMENT/!wxUSE_AUTOID_MANAGEMENT
286 }
287
288 void wxIdManager::UnreserveId(wxWindowID winid, int count)
289 {
290 wxASSERT_MSG(count > 0, wxT("can't unreserve less than 1 id"));
291
292 #if wxUSE_AUTOID_MANAGEMENT
293 while (count--)
294 UnreserveIdRefCount(winid++);
295 #else
296 wxUnusedVar(winid);
297 wxUnusedVar(count);
298 #endif
299 }
300