Mercurial > defr > drupal > core
comparison includes/pager.inc @ 1:c1f4ac30525a 6.0
Drupal 6.0
author | Franck Deroche <webmaster@defr.org> |
---|---|
date | Tue, 23 Dec 2008 14:28:28 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:5a113a1c4740 | 1:c1f4ac30525a |
---|---|
1 <?php | |
2 // $Id: pager.inc,v 1.63 2007/12/06 09:58:30 goba Exp $ | |
3 | |
4 /** | |
5 * @file | |
6 * Functions to aid in presenting database results as a set of pages. | |
7 */ | |
8 | |
9 /** | |
10 * Perform a paged database query. | |
11 * | |
12 * Use this function when doing select queries you wish to be able to page. The | |
13 * pager uses LIMIT-based queries to fetch only the records required to render a | |
14 * certain page. However, it has to learn the total number of records returned | |
15 * by the query to compute the number of pages (the number of records / records | |
16 * per page). This is done by inserting "COUNT(*)" in the original query. For | |
17 * example, the query "SELECT nid, type FROM node WHERE status = '1' ORDER BY | |
18 * sticky DESC, created DESC" would be rewritten to read "SELECT COUNT(*) FROM | |
19 * node WHERE status = '1' ORDER BY sticky DESC, created DESC". Rewriting the | |
20 * query is accomplished using a regular expression. | |
21 * | |
22 * Unfortunately, the rewrite rule does not always work as intended for queries | |
23 * that already have a "COUNT(*)" or a "GROUP BY" clause, and possibly for | |
24 * other complex queries. In those cases, you can optionally pass a query that | |
25 * will be used to count the records. | |
26 * | |
27 * For example, if you want to page the query "SELECT COUNT(*), TYPE FROM node | |
28 * GROUP BY TYPE", pager_query() would invoke the incorrect query "SELECT | |
29 * COUNT(*) FROM node GROUP BY TYPE". So instead, you should pass "SELECT | |
30 * COUNT(DISTINCT(TYPE)) FROM node" as the optional $count_query parameter. | |
31 * | |
32 * @param $query | |
33 * The SQL query that needs paging. | |
34 * @param $limit | |
35 * The number of query results to display per page. | |
36 * @param $element | |
37 * An optional integer to distinguish between multiple pagers on one page. | |
38 * @param $count_query | |
39 * An SQL query used to count matching records. | |
40 * @param ... | |
41 * A variable number of arguments which are substituted into the query (and | |
42 * the count query) using printf() syntax. Instead of a variable number of | |
43 * query arguments, you may also pass a single array containing the query | |
44 * arguments. | |
45 * @return | |
46 * A database query result resource, or FALSE if the query was not executed | |
47 * correctly. | |
48 * | |
49 * @ingroup database | |
50 */ | |
51 function pager_query($query, $limit = 10, $element = 0, $count_query = NULL) { | |
52 global $pager_page_array, $pager_total, $pager_total_items; | |
53 $page = isset($_GET['page']) ? $_GET['page'] : ''; | |
54 | |
55 // Substitute in query arguments. | |
56 $args = func_get_args(); | |
57 $args = array_slice($args, 4); | |
58 // Alternative syntax for '...' | |
59 if (isset($args[0]) && is_array($args[0])) { | |
60 $args = $args[0]; | |
61 } | |
62 | |
63 // Construct a count query if none was given. | |
64 if (!isset($count_query)) { | |
65 $count_query = preg_replace(array('/SELECT.*?FROM /As', '/ORDER BY .*/'), array('SELECT COUNT(*) FROM ', ''), $query); | |
66 } | |
67 | |
68 // Convert comma-separated $page to an array, used by other functions. | |
69 $pager_page_array = explode(',', $page); | |
70 | |
71 // We calculate the total of pages as ceil(items / limit). | |
72 $pager_total_items[$element] = db_result(db_query($count_query, $args)); | |
73 $pager_total[$element] = ceil($pager_total_items[$element] / $limit); | |
74 $pager_page_array[$element] = max(0, min((int)$pager_page_array[$element], ((int)$pager_total[$element]) - 1)); | |
75 return db_query_range($query, $args, $pager_page_array[$element] * $limit, $limit); | |
76 } | |
77 | |
78 /** | |
79 * Compose a query string to append to pager requests. | |
80 * | |
81 * @return | |
82 * A query string that consists of all components of the current page request | |
83 * except for those pertaining to paging. | |
84 */ | |
85 function pager_get_querystring() { | |
86 static $string = NULL; | |
87 if (!isset($string)) { | |
88 $string = drupal_query_string_encode($_REQUEST, array_merge(array('q', 'page'), array_keys($_COOKIE))); | |
89 } | |
90 return $string; | |
91 } | |
92 | |
93 /** | |
94 * Format a query pager. | |
95 * | |
96 * Menu callbacks that display paged query results should call theme('pager') to | |
97 * retrieve a pager control so that users can view other results. | |
98 * Format a list of nearby pages with additional query results. | |
99 * | |
100 * @param $tags | |
101 * An array of labels for the controls in the pager. | |
102 * @param $limit | |
103 * The number of query results to display per page. | |
104 * @param $element | |
105 * An optional integer to distinguish between multiple pagers on one page. | |
106 * @param $parameters | |
107 * An associative array of query string parameters to append to the pager links. | |
108 * @param $quantity | |
109 * The number of pages in the list. | |
110 * @return | |
111 * An HTML string that generates the query pager. | |
112 * | |
113 * @ingroup themeable | |
114 */ | |
115 function theme_pager($tags = array(), $limit = 10, $element = 0, $parameters = array(), $quantity = 9) { | |
116 global $pager_page_array, $pager_total; | |
117 | |
118 // Calculate various markers within this pager piece: | |
119 // Middle is used to "center" pages around the current page. | |
120 $pager_middle = ceil($quantity / 2); | |
121 // current is the page we are currently paged to | |
122 $pager_current = $pager_page_array[$element] + 1; | |
123 // first is the first page listed by this pager piece (re quantity) | |
124 $pager_first = $pager_current - $pager_middle + 1; | |
125 // last is the last page listed by this pager piece (re quantity) | |
126 $pager_last = $pager_current + $quantity - $pager_middle; | |
127 // max is the maximum page number | |
128 $pager_max = $pager_total[$element]; | |
129 // End of marker calculations. | |
130 | |
131 // Prepare for generation loop. | |
132 $i = $pager_first; | |
133 if ($pager_last > $pager_max) { | |
134 // Adjust "center" if at end of query. | |
135 $i = $i + ($pager_max - $pager_last); | |
136 $pager_last = $pager_max; | |
137 } | |
138 if ($i <= 0) { | |
139 // Adjust "center" if at start of query. | |
140 $pager_last = $pager_last + (1 - $i); | |
141 $i = 1; | |
142 } | |
143 // End of generation loop preparation. | |
144 | |
145 $li_first = theme('pager_first', (isset($tags[0]) ? $tags[0] : t('« first')), $limit, $element, $parameters); | |
146 $li_previous = theme('pager_previous', (isset($tags[1]) ? $tags[1] : t('‹ previous')), $limit, $element, 1, $parameters); | |
147 $li_next = theme('pager_next', (isset($tags[3]) ? $tags[3] : t('next ›')), $limit, $element, 1, $parameters); | |
148 $li_last = theme('pager_last', (isset($tags[4]) ? $tags[4] : t('last »')), $limit, $element, $parameters); | |
149 | |
150 if ($pager_total[$element] > 1) { | |
151 if ($li_first) { | |
152 $items[] = array( | |
153 'class' => 'pager-first', | |
154 'data' => $li_first, | |
155 ); | |
156 } | |
157 if ($li_previous) { | |
158 $items[] = array( | |
159 'class' => 'pager-previous', | |
160 'data' => $li_previous, | |
161 ); | |
162 } | |
163 | |
164 // When there is more than one page, create the pager list. | |
165 if ($i != $pager_max) { | |
166 if ($i > 1) { | |
167 $items[] = array( | |
168 'class' => 'pager-ellipsis', | |
169 'data' => '…', | |
170 ); | |
171 } | |
172 // Now generate the actual pager piece. | |
173 for (; $i <= $pager_last && $i <= $pager_max; $i++) { | |
174 if ($i < $pager_current) { | |
175 $items[] = array( | |
176 'class' => 'pager-item', | |
177 'data' => theme('pager_previous', $i, $limit, $element, ($pager_current - $i), $parameters), | |
178 ); | |
179 } | |
180 if ($i == $pager_current) { | |
181 $items[] = array( | |
182 'class' => 'pager-current', | |
183 'data' => $i, | |
184 ); | |
185 } | |
186 if ($i > $pager_current) { | |
187 $items[] = array( | |
188 'class' => 'pager-item', | |
189 'data' => theme('pager_next', $i, $limit, $element, ($i - $pager_current), $parameters), | |
190 ); | |
191 } | |
192 } | |
193 if ($i < $pager_max) { | |
194 $items[] = array( | |
195 'class' => 'pager-ellipsis', | |
196 'data' => '…', | |
197 ); | |
198 } | |
199 } | |
200 // End generation. | |
201 if ($li_next) { | |
202 $items[] = array( | |
203 'class' => 'pager-next', | |
204 'data' => $li_next, | |
205 ); | |
206 } | |
207 if ($li_last) { | |
208 $items[] = array( | |
209 'class' => 'pager-last', | |
210 'data' => $li_last, | |
211 ); | |
212 } | |
213 return theme('item_list', $items, NULL, 'ul', array('class' => 'pager')); | |
214 } | |
215 } | |
216 | |
217 | |
218 /** | |
219 * @name Pager pieces | |
220 * @{ | |
221 * Use these pieces to construct your own custom pagers in your theme. Note that | |
222 * you should NOT modify this file to customize your pager. | |
223 */ | |
224 | |
225 /** | |
226 * Format a "first page" link. | |
227 * | |
228 * @param $text | |
229 * The name (or image) of the link. | |
230 * @param $limit | |
231 * The number of query results to display per page. | |
232 * @param $element | |
233 * An optional integer to distinguish between multiple pagers on one page. | |
234 * @param $parameters | |
235 * An associative array of query string parameters to append to the pager links. | |
236 * @return | |
237 * An HTML string that generates this piece of the query pager. | |
238 * | |
239 * @ingroup themeable | |
240 */ | |
241 function theme_pager_first($text, $limit, $element = 0, $parameters = array()) { | |
242 global $pager_page_array; | |
243 $output = ''; | |
244 | |
245 // If we are anywhere but the first page | |
246 if ($pager_page_array[$element] > 0) { | |
247 $output = theme('pager_link', $text, pager_load_array(0, $element, $pager_page_array), $element, $parameters); | |
248 } | |
249 | |
250 return $output; | |
251 } | |
252 | |
253 /** | |
254 * Format a "previous page" link. | |
255 * | |
256 * @param $text | |
257 * The name (or image) of the link. | |
258 * @param $limit | |
259 * The number of query results to display per page. | |
260 * @param $element | |
261 * An optional integer to distinguish between multiple pagers on one page. | |
262 * @param $interval | |
263 * The number of pages to move backward when the link is clicked. | |
264 * @param $parameters | |
265 * An associative array of query string parameters to append to the pager links. | |
266 * @return | |
267 * An HTML string that generates this piece of the query pager. | |
268 * | |
269 * @ingroup themeable | |
270 */ | |
271 function theme_pager_previous($text, $limit, $element = 0, $interval = 1, $parameters = array()) { | |
272 global $pager_page_array; | |
273 $output = ''; | |
274 | |
275 // If we are anywhere but the first page | |
276 if ($pager_page_array[$element] > 0) { | |
277 $page_new = pager_load_array($pager_page_array[$element] - $interval, $element, $pager_page_array); | |
278 | |
279 // If the previous page is the first page, mark the link as such. | |
280 if ($page_new[$element] == 0) { | |
281 $output = theme('pager_first', $text, $limit, $element, $parameters); | |
282 } | |
283 // The previous page is not the first page. | |
284 else { | |
285 $output = theme('pager_link', $text, $page_new, $element, $parameters); | |
286 } | |
287 } | |
288 | |
289 return $output; | |
290 } | |
291 | |
292 /** | |
293 * Format a "next page" link. | |
294 * | |
295 * @param $text | |
296 * The name (or image) of the link. | |
297 * @param $limit | |
298 * The number of query results to display per page. | |
299 * @param $element | |
300 * An optional integer to distinguish between multiple pagers on one page. | |
301 * @param $interval | |
302 * The number of pages to move forward when the link is clicked. | |
303 * @param $parameters | |
304 * An associative array of query string parameters to append to the pager links. | |
305 * @return | |
306 * An HTML string that generates this piece of the query pager. | |
307 * | |
308 * @ingroup themeable | |
309 */ | |
310 function theme_pager_next($text, $limit, $element = 0, $interval = 1, $parameters = array()) { | |
311 global $pager_page_array, $pager_total; | |
312 $output = ''; | |
313 | |
314 // If we are anywhere but the last page | |
315 if ($pager_page_array[$element] < ($pager_total[$element] - 1)) { | |
316 $page_new = pager_load_array($pager_page_array[$element] + $interval, $element, $pager_page_array); | |
317 // If the next page is the last page, mark the link as such. | |
318 if ($page_new[$element] == ($pager_total[$element] - 1)) { | |
319 $output = theme('pager_last', $text, $limit, $element, $parameters); | |
320 } | |
321 // The next page is not the last page. | |
322 else { | |
323 $output = theme('pager_link', $text, $page_new, $element, $parameters); | |
324 } | |
325 } | |
326 | |
327 return $output; | |
328 } | |
329 | |
330 /** | |
331 * Format a "last page" link. | |
332 * | |
333 * @param $text | |
334 * The name (or image) of the link. | |
335 * @param $limit | |
336 * The number of query results to display per page. | |
337 * @param $element | |
338 * An optional integer to distinguish between multiple pagers on one page. | |
339 * @param $parameters | |
340 * An associative array of query string parameters to append to the pager links. | |
341 * @return | |
342 * An HTML string that generates this piece of the query pager. | |
343 * | |
344 * @ingroup themeable | |
345 */ | |
346 function theme_pager_last($text, $limit, $element = 0, $parameters = array()) { | |
347 global $pager_page_array, $pager_total; | |
348 $output = ''; | |
349 | |
350 // If we are anywhere but the last page | |
351 if ($pager_page_array[$element] < ($pager_total[$element] - 1)) { | |
352 $output = theme('pager_link', $text, pager_load_array($pager_total[$element] - 1, $element, $pager_page_array), $element, $parameters); | |
353 } | |
354 | |
355 return $output; | |
356 } | |
357 | |
358 | |
359 /** | |
360 * Format a link to a specific query result page. | |
361 * | |
362 * @param $page_new | |
363 * The first result to display on the linked page. | |
364 * @param $element | |
365 * An optional integer to distinguish between multiple pagers on one page. | |
366 * @param $parameters | |
367 * An associative array of query string parameters to append to the pager link. | |
368 * @param $attributes | |
369 * An associative array of HTML attributes to apply to a pager anchor tag. | |
370 * @return | |
371 * An HTML string that generates the link. | |
372 * | |
373 * @ingroup themeable | |
374 */ | |
375 function theme_pager_link($text, $page_new, $element, $parameters = array(), $attributes = array()) { | |
376 $page = isset($_GET['page']) ? $_GET['page'] : ''; | |
377 if ($new_page = implode(',', pager_load_array($page_new[$element], $element, explode(',', $page)))) { | |
378 $parameters['page'] = $new_page; | |
379 } | |
380 | |
381 $query = array(); | |
382 if (count($parameters)) { | |
383 $query[] = drupal_query_string_encode($parameters, array()); | |
384 } | |
385 $querystring = pager_get_querystring(); | |
386 if ($querystring != '') { | |
387 $query[] = $querystring; | |
388 } | |
389 | |
390 // Set each pager link title | |
391 if (!isset($attributes['title'])) { | |
392 static $titles = NULL; | |
393 if (!isset($titles)) { | |
394 $titles = array( | |
395 t('« first') => t('Go to first page'), | |
396 t('‹ previous') => t('Go to previous page'), | |
397 t('next ›') => t('Go to next page'), | |
398 t('last »') => t('Go to last page'), | |
399 ); | |
400 } | |
401 if (isset($titles[$text])) { | |
402 $attributes['title'] = $titles[$text]; | |
403 } | |
404 else if (is_numeric($text)) { | |
405 $attributes['title'] = t('Go to page @number', array('@number' => $text)); | |
406 } | |
407 } | |
408 | |
409 return l($text, $_GET['q'], array('attributes' => $attributes, 'query' => count($query) ? implode('&', $query) : NULL)); | |
410 } | |
411 | |
412 /** | |
413 * @} End of "Pager pieces". | |
414 */ | |
415 | |
416 /** | |
417 * Helper function | |
418 * | |
419 * Copies $old_array to $new_array and sets $new_array[$element] = $value | |
420 * Fills in $new_array[0 .. $element - 1] = 0 | |
421 */ | |
422 function pager_load_array($value, $element, $old_array) { | |
423 $new_array = $old_array; | |
424 // Look for empty elements. | |
425 for ($i = 0; $i < $element; $i++) { | |
426 if (!$new_array[$i]) { | |
427 // Load found empty element with 0. | |
428 $new_array[$i] = 0; | |
429 } | |
430 } | |
431 // Update the changed element. | |
432 $new_array[$element] = (int)$value; | |
433 return $new_array; | |
434 } |