1 /*
2 * IP Address control
3 *
4 * Copyright 2002 Dimitrie O. Paun
5 * Copyright 1999 Chris Morgan<cmorgan@wpi.edu>
6 * Copyright 1999 James Abbatiello<abbeyj@wpi.edu>
7 * Copyright 1998, 1999 Eric Kohl
8 * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * NOTE
25 *
26 * This code was audited for completeness against the documented features
27 * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
28 *
29 * Unless otherwise noted, we believe this code to be complete, as per
30 * the specification mentioned above.
31 * If you discover missing features, or bugs, please note them below.
32 *
33 */
34
35 #include <ctype.h>
36 #include <stdlib.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <string.h>
40
41 #include "windef.h"
42 #include "winbase.h"
43 #include "wingdi.h"
44 #include "winuser.h"
45 #include "winnls.h"
46 #include "commctrl.h"
47 #include "comctl32.h"
48 #include "wine/unicode.h"
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(ipaddress);
52
53 typedef struct
54 {
55 HWND EditHwnd;
56 INT LowerLimit;
57 INT UpperLimit;
58 WNDPROC OrigProc;
59 } IPPART_INFO;
60
61 typedef struct
62 {
63 HWND Self;
64 HWND Notify;
65 BOOL Enabled;
66 IPPART_INFO Part[4];
67 } IPADDRESS_INFO;
68
69 static const WCHAR IP_SUBCLASS_PROP[] =
70 { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };
71
72 #define POS_DEFAULT 0
73 #define POS_LEFT 1
74 #define POS_RIGHT 2
75 #define POS_SELALL 3
76
77 static LRESULT CALLBACK
78 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
79
80 static void IPADDRESS_UpdateText (const IPADDRESS_INFO *infoPtr)
81 {
82 static const WCHAR zero[2] = {'', 0};
83 static const WCHAR dot[2] = {'.', 0};
84 WCHAR field[4];
85 WCHAR ip[16];
86 INT i;
87
88 ip[0] = 0;
89
90 for (i = 0; i < 4; i++) {
91 if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
92 strcatW(ip, field);
93 else
94 /* empty edit treated as zero */
95 strcatW(ip, zero);
96 if (i != 3)
97 strcatW(ip, dot);
98 }
99
100 SetWindowTextW(infoPtr->Self, ip);
101 }
102
103 static LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
104 {
105 HWND hwnd = infoPtr->Self;
106
107 TRACE("(command=%x)\n", command);
108
109 return SendMessageW (infoPtr->Notify, WM_COMMAND,
110 MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
111 }
112
113 static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
114 {
115 NMIPADDRESS nmip;
116
117 TRACE("(field=%x, value=%d)\n", field, value);
118
119 nmip.hdr.hwndFrom = infoPtr->Self;
120 nmip.hdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
121 nmip.hdr.code = IPN_FIELDCHANGED;
122
123 nmip.iField = field;
124 nmip.iValue = value;
125
126 SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
127
128 TRACE("<-- %d\n", nmip.iValue);
129
130 return nmip.iValue;
131 }
132
133
134 static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
135 {
136 int i;
137
138 TRACE("(hwnd=%p)\n", hwnd);
139
140 for (i = 0; i < 4; i++)
141 if (infoPtr->Part[i].EditHwnd == hwnd) return i;
142
143 ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
144 return -1;
145 }
146
147
148 static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
149 {
150 static const WCHAR dotW[] = { '.', 0 };
151 RECT rect, rcPart;
152 POINT pt;
153 COLORREF bgCol, fgCol;
154 int i;
155
156 TRACE("\n");
157
158 GetClientRect (infoPtr->Self, &rect);
159
160 if (infoPtr->Enabled) {
161 bgCol = comctl32_color.clrWindow;
162 fgCol = comctl32_color.clrWindowText;
163 } else {
164 bgCol = comctl32_color.clr3dFace;
165 fgCol = comctl32_color.clrGrayText;
166 }
167
168 FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
169 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
170
171 SetBkColor (hdc, bgCol);
172 SetTextColor(hdc, fgCol);
173
174 for (i = 0; i < 3; i++) {
175 GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
176 pt.x = rcPart.right;
177 ScreenToClient(infoPtr->Self, &pt);
178 rect.left = pt.x;
179 GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
180 pt.x = rcPart.left;
181 ScreenToClient(infoPtr->Self, &pt);
182 rect.right = pt.x;
183 DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
184 }
185
186 return 0;
187 }
188
189
190 static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
191 {
192 static const WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
193 IPADDRESS_INFO *infoPtr;
194 RECT rcClient, edit;
195 int i, fieldsize;
196 HFONT hFont, hSysFont;
197 LOGFONTW logFont, logSysFont;
198
199 TRACE("\n");
200
201 SetWindowLongW (hwnd, GWL_STYLE,
202 GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
203
204 infoPtr = Alloc (sizeof(IPADDRESS_INFO));
205 if (!infoPtr) return -1;
206 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
207
208 GetClientRect (hwnd, &rcClient);
209
210 fieldsize = (rcClient.right - rcClient.left) / 4;
211
212 edit.top = rcClient.top + 2;
213 edit.bottom = rcClient.bottom - 2;
214
215 infoPtr->Self = hwnd;
216 infoPtr->Enabled = TRUE;
217 infoPtr->Notify = lpCreate->hwndParent;
218
219 hSysFont = GetStockObject(ANSI_VAR_FONT);
220 GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
221 SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
222 strcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
223 hFont = CreateFontIndirectW(&logFont);
224
225 for (i = 0; i < 4; i++) {
226 IPPART_INFO* part = &infoPtr->Part[i];
227
228 part->LowerLimit = 0;
229 part->UpperLimit = 255;
230 edit.left = rcClient.left + i*fieldsize + 6;
231 edit.right = rcClient.left + (i+1)*fieldsize - 2;
232 part->EditHwnd =
233 CreateWindowW (EDIT, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
234 edit.left, edit.top, edit.right - edit.left,
235 edit.bottom - edit.top, hwnd, (HMENU) 1,
236 (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
237 SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
238 SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
239 part->OrigProc = (WNDPROC)
240 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
241 (DWORD_PTR)IPADDRESS_SubclassProc);
242 EnableWindow(part->EditHwnd, infoPtr->Enabled);
243 }
244
245 IPADDRESS_UpdateText (infoPtr);
246
247 return 0;
248 }
249
250
251 static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
252 {
253 int i;
254
255 TRACE("\n");
256
257 for (i = 0; i < 4; i++) {
258 IPPART_INFO* part = &infoPtr->Part[i];
259 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
260 }
261
262 SetWindowLongPtrW (infoPtr->Self, 0, 0);
263 Free (infoPtr);
264 return 0;
265 }
266
267
268 static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
269 {
270 int i;
271
272 infoPtr->Enabled = enabled;
273
274 for (i = 0; i < 4; i++)
275 EnableWindow(infoPtr->Part[i].EditHwnd, enabled);
276
277 InvalidateRgn(infoPtr->Self, NULL, FALSE);
278 return 0;
279 }
280
281
282 static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
283 {
284 PAINTSTRUCT ps;
285
286 TRACE("\n");
287
288 if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
289
290 hdc = BeginPaint (infoPtr->Self, &ps);
291 IPADDRESS_Draw (infoPtr, hdc);
292 EndPaint (infoPtr->Self, &ps);
293 return 0;
294 }
295
296
297 static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
298 {
299 int i;
300
301 TRACE("\n");
302
303 for (i = 0; i < 4; i++)
304 if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
305
306 return TRUE;
307 }
308
309
310 static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
311 {
312 WCHAR field[5];
313 int i, invalid = 0;
314 DWORD ip_addr = 0;
315
316 TRACE("\n");
317
318 for (i = 0; i < 4; i++) {
319 ip_addr *= 256;
320 if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
321 ip_addr += atolW(field);
322 else
323 invalid++;
324 }
325 *ip_address = ip_addr;
326
327 return 4 - invalid;
328 }
329
330
331 static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
332 {
333 TRACE("\n");
334
335 if ( (index < 0) || (index > 3) ) return FALSE;
336
337 infoPtr->Part[index].LowerLimit = range & 0xFF;
338 infoPtr->Part[index].UpperLimit = (range >> 8) & 0xFF;
339
340 return TRUE;
341 }
342
343
344 static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
345 {
346 WCHAR nil[1] = { 0 };
347 int i;
348
349 TRACE("\n");
350
351 for (i = 0; i < 4; i++)
352 SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
353 }
354
355
356 static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
357 {
358 WCHAR buf[20];
359 static const WCHAR fmt[] = { '%', 'd', 0 };
360 int i;
361
362 TRACE("\n");
363
364 for (i = 3; i >= 0; i--) {
365 const IPPART_INFO* part = &infoPtr->Part[i];
366 int value = ip_address & 0xff;
367 if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
368 wsprintfW (buf, fmt, value);
369 SetWindowTextW (part->EditHwnd, buf);
370 IPADDRESS_Notify (infoPtr, EN_CHANGE);
371 }
372 ip_address >>= 8;
373 }
374
375 return TRUE;
376 }
377
378
379 static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
380 {
381 TRACE("(index=%d)\n", index);
382
383 if (index > 3 || index < 0) index=0;
384
385 SetFocus (infoPtr->Part[index].EditHwnd);
386 }
387
388
389 static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
390 {
391 const IPPART_INFO *part = &infoPtr->Part[currentfield];
392 WCHAR field[10];
393 static const WCHAR fmt[] = { '%', 'd', 0 };
394 int curValue, newValue;
395
396 TRACE("(currentfield=%d)\n", currentfield);
397
398 if (currentfield < 0 || currentfield > 3) return FALSE;
399
400 if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
401
402 curValue = atoiW(field);
403 TRACE(" curValue=%d\n", curValue);
404
405 newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
406 TRACE(" newValue=%d\n", newValue);
407
408 if (newValue < part->LowerLimit) newValue = part->LowerLimit;
409 if (newValue > part->UpperLimit) newValue = part->UpperLimit;
410
411 if (newValue == curValue) return FALSE;
412
413 wsprintfW (field, fmt, newValue);
414 TRACE(" field=%s\n", debugstr_w(field));
415 return SetWindowTextW (part->EditHwnd, field);
416 }
417
418
419 static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
420 {
421 TRACE("\n");
422
423 if(cur >= -1 && cur < 4) {
424 IPADDRESS_ConstrainField(infoPtr, cur);
425
426 if(cur < 3) {
427 const IPPART_INFO *next = &infoPtr->Part[cur + 1];
428 int start = 0, end = 0;
429 SetFocus (next->EditHwnd);
430 if (sel != POS_DEFAULT) {
431 if (sel == POS_RIGHT)
432 start = end = GetWindowTextLengthW(next->EditHwnd);
433 else if (sel == POS_SELALL)
434 end = -1;
435 SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
436 }
437 return TRUE;
438 }
439
440 }
441 return FALSE;
442 }
443
444
445 /*
446 * period: move and select the text in the next field to the right if
447 * the current field is not empty(l!=0), we are not in the
448 * left most position, and nothing is selected(startsel==endsel)
449 *
450 * spacebar: same behavior as period
451 *
452 * alpha characters: completely ignored
453 *
454 * digits: accepted when field text length < 2 ignored otherwise.
455 * when 3 numbers have been entered into the field the value
456 * of the field is checked, if the field value exceeds the
457 * maximum value and is changed the field remains the current
458 * field, otherwise focus moves to the field to the right
459 *
460 * tab: change focus from the current ipaddress control to the next
461 * control in the tab order
462 *
463 * right arrow: move to the field on the right to the left most
464 * position in that field if no text is selected,
465 * we are in the right most position in the field,
466 * we are not in the right most field
467 *
468 * left arrow: move to the field on the left to the right most
469 * position in that field if no text is selected,
470 * we are in the left most position in the current field
471 * and we are not in the left most field
472 *
473 * backspace: delete the character to the left of the cursor position,
474 * if none are present move to the field on the left if
475 * we are not in the left most field and delete the right
476 * most digit in that field while keeping the cursor
477 * on the right side of the field
478 */
479 LRESULT CALLBACK
480 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
481 {
482 HWND Self = GetPropW (hwnd, IP_SUBCLASS_PROP);
483 IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
484 CHAR c = (CHAR)wParam;
485 INT index, len = 0, startsel, endsel;
486 IPPART_INFO *part;
487
488 TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
489
490 if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
491 part = &infoPtr->Part[index];
492
493 if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
494 len = GetWindowTextLengthW (hwnd);
495 SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
496 }
497 switch (uMsg) {
498 case WM_CHAR:
499 if(isdigit(c)) {
500 if(len == 2 && startsel==endsel && endsel==len) {
501 /* process the digit press before we check the field */
502 int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
503
504 /* if the field value was changed stay at the current field */
505 if(!IPADDRESS_ConstrainField(infoPtr, index))
506 IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
507
508 return return_val;
509 } else if (len == 3 && startsel==endsel && endsel==len)
510 IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
511 else if (len < 3 || startsel != endsel) break;
512 } else if(c == '.' || c == ' ') {
513 if(len && startsel==endsel && startsel != 0) {
514 IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
515 }
516 } else if (c == VK_BACK) break;
517 return 0;
518
519 case WM_KEYDOWN:
520 switch(c) {
521 case VK_RIGHT:
522 if(startsel==endsel && startsel==len) {
523 IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
524 return 0;
525 }
526 break;
527 case VK_LEFT:
528 if(startsel==0 && startsel==endsel && index > 0) {
529 IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
530 return 0;
531 }
532 break;
533 case VK_BACK:
534 if(startsel==endsel && startsel==0 && index > 0) {
535 IPPART_INFO *prev = &infoPtr->Part[index-1];
536 WCHAR val[10];
537
538 if(GetWindowTextW(prev->EditHwnd, val, 5)) {
539 val[lstrlenW(val) - 1] = 0;
540 SetWindowTextW(prev->EditHwnd, val);
541 }
542
543 IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
544 return 0;
545 }
546 break;
547 }
548 break;
549 case WM_KILLFOCUS:
550 if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
551 IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
552 break;
553 case WM_SETFOCUS:
554 if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
555 IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
556 break;
557 }
558 return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
559 }
560
561
562 static LRESULT WINAPI
563 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
564 {
565 IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
566
567 TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
568
569 if (!infoPtr && (uMsg != WM_CREATE))
570 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
571
572 switch (uMsg)
573 {
574 case WM_CREATE:
575 return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
576
577 case WM_DESTROY:
578 return IPADDRESS_Destroy (infoPtr);
579
580 case WM_ENABLE:
581 return IPADDRESS_Enable (infoPtr, (BOOL)wParam);
582
583 case WM_PAINT:
584 return IPADDRESS_Paint (infoPtr, (HDC)wParam);
585
586 case WM_COMMAND:
587 switch(wParam >> 16) {
588 case EN_CHANGE:
589 IPADDRESS_UpdateText(infoPtr);
590 IPADDRESS_Notify(infoPtr, EN_CHANGE);
591 break;
592 case EN_KILLFOCUS:
593 IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
594 break;
595 }
596 break;
597
598 case WM_SYSCOLORCHANGE:
599 COMCTL32_RefreshSysColors();
600 return 0;
601
602 case IPM_CLEARADDRESS:
603 IPADDRESS_ClearAddress (infoPtr);
604 break;
605
606 case IPM_SETADDRESS:
607 return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
608
609 case IPM_GETADDRESS:
610 return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
611
612 case IPM_SETRANGE:
613 return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
614
615 case IPM_SETFOCUS:
616 IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
617 break;
618
619 case IPM_ISBLANK:
620 return IPADDRESS_IsBlank (infoPtr);
621
622 default:
623 if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
624 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
625 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
626 }
627 return 0;
628 }
629
630
631 void IPADDRESS_Register (void)
632 {
633 WNDCLASSW wndClass;
634
635 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
636 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
637 wndClass.lpfnWndProc = IPADDRESS_WindowProc;
638 wndClass.cbClsExtra = 0;
639 wndClass.cbWndExtra = sizeof(IPADDRESS_INFO *);
640 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
641 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
642 wndClass.lpszClassName = WC_IPADDRESSW;
643
644 RegisterClassW (&wndClass);
645 }
646
647
648 void IPADDRESS_Unregister (void)
649 {
650 UnregisterClassW (WC_IPADDRESSW, NULL);
651 }
652
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.