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 LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
81 {
82 HWND hwnd = infoPtr->Self;
83
84 TRACE("(command=%x)\n", command);
85
86 return SendMessageW (infoPtr->Notify, WM_COMMAND,
87 MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
88 }
89
90 static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
91 {
92 NMIPADDRESS nmip;
93
94 TRACE("(field=%x, value=%d)\n", field, value);
95
96 nmip.hdr.hwndFrom = infoPtr->Self;
97 nmip.hdr.idFrom = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
98 nmip.hdr.code = IPN_FIELDCHANGED;
99
100 nmip.iField = field;
101 nmip.iValue = value;
102
103 SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
104
105 TRACE("<-- %d\n", nmip.iValue);
106
107 return nmip.iValue;
108 }
109
110
111 static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
112 {
113 int i;
114
115 TRACE("(hwnd=%p)\n", hwnd);
116
117 for (i = 0; i < 4; i++)
118 if (infoPtr->Part[i].EditHwnd == hwnd) return i;
119
120 ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
121 return -1;
122 }
123
124
125 static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
126 {
127 static const WCHAR dotW[] = { '.', 0 };
128 RECT rect, rcPart;
129 POINT pt;
130 COLORREF bgCol, fgCol;
131 int i;
132
133 TRACE("\n");
134
135 GetClientRect (infoPtr->Self, &rect);
136
137 if (infoPtr->Enabled) {
138 bgCol = COLOR_WINDOW;
139 fgCol = COLOR_WINDOWTEXT;
140 } else {
141 bgCol = COLOR_3DFACE;
142 fgCol = COLOR_GRAYTEXT;
143 }
144
145 FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
146 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
147
148 SetBkColor (hdc, GetSysColor(bgCol));
149 SetTextColor(hdc, GetSysColor(fgCol));
150
151 for (i = 0; i < 3; i++) {
152 GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
153 pt.x = rcPart.right;
154 ScreenToClient(infoPtr->Self, &pt);
155 rect.left = pt.x;
156 GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
157 pt.x = rcPart.left;
158 ScreenToClient(infoPtr->Self, &pt);
159 rect.right = pt.x;
160 DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
161 }
162
163 return 0;
164 }
165
166
167 static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
168 {
169 static const WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
170 IPADDRESS_INFO *infoPtr;
171 RECT rcClient, edit;
172 int i, fieldsize;
173
174 TRACE("\n");
175
176 SetWindowLongW (hwnd, GWL_STYLE,
177 GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
178
179 infoPtr = (IPADDRESS_INFO *)Alloc (sizeof(IPADDRESS_INFO));
180 if (!infoPtr) return -1;
181 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
182
183 GetClientRect (hwnd, &rcClient);
184
185 fieldsize = (rcClient.right - rcClient.left) / 4;
186
187 edit.top = rcClient.top + 2;
188 edit.bottom = rcClient.bottom - 2;
189
190 infoPtr->Self = hwnd;
191 infoPtr->Enabled = TRUE;
192 infoPtr->Notify = lpCreate->hwndParent;
193
194 for (i = 0; i < 4; i++) {
195 IPPART_INFO* part = &infoPtr->Part[i];
196
197 part->LowerLimit = 0;
198 part->UpperLimit = 255;
199 edit.left = rcClient.left + i*fieldsize + 6;
200 edit.right = rcClient.left + (i+1)*fieldsize - 2;
201 part->EditHwnd =
202 CreateWindowW (EDIT, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
203 edit.left, edit.top, edit.right - edit.left,
204 edit.bottom - edit.top, hwnd, (HMENU) 1,
205 (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
206 SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
207 part->OrigProc = (WNDPROC)
208 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
209 (DWORD_PTR)IPADDRESS_SubclassProc);
210 EnableWindow(part->EditHwnd, infoPtr->Enabled);
211 }
212
213 return 0;
214 }
215
216
217 static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
218 {
219 int i;
220
221 TRACE("\n");
222
223 for (i = 0; i < 4; i++) {
224 IPPART_INFO* part = &infoPtr->Part[i];
225 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
226 }
227
228 SetWindowLongPtrW (infoPtr->Self, 0, 0);
229 Free (infoPtr);
230 return 0;
231 }
232
233
234 static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
235 {
236 int i;
237
238 infoPtr->Enabled = enabled;
239
240 for (i = 0; i < 4; i++)
241 EnableWindow(infoPtr->Part[i].EditHwnd, enabled);
242
243 InvalidateRgn(infoPtr->Self, NULL, FALSE);
244 return 0;
245 }
246
247
248 static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
249 {
250 PAINTSTRUCT ps;
251
252 TRACE("\n");
253
254 if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
255
256 hdc = BeginPaint (infoPtr->Self, &ps);
257 IPADDRESS_Draw (infoPtr, hdc);
258 EndPaint (infoPtr->Self, &ps);
259 return 0;
260 }
261
262
263 static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
264 {
265 int i;
266
267 TRACE("\n");
268
269 for (i = 0; i < 4; i++)
270 if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
271
272 return TRUE;
273 }
274
275
276 static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
277 {
278 WCHAR field[5];
279 int i, invalid = 0;
280 DWORD ip_addr = 0;
281
282 TRACE("\n");
283
284 for (i = 0; i < 4; i++) {
285 ip_addr *= 256;
286 if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
287 ip_addr += atolW(field);
288 else
289 invalid++;
290 }
291 *ip_address = ip_addr;
292
293 return 4 - invalid;
294 }
295
296
297 static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
298 {
299 TRACE("\n");
300
301 if ( (index < 0) || (index > 3) ) return FALSE;
302
303 infoPtr->Part[index].LowerLimit = range & 0xFF;
304 infoPtr->Part[index].UpperLimit = (range >> 8) & 0xFF;
305
306 return TRUE;
307 }
308
309
310 static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
311 {
312 WCHAR nil[1] = { 0 };
313 int i;
314
315 TRACE("\n");
316
317 for (i = 0; i < 4; i++)
318 SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
319 }
320
321
322 static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
323 {
324 WCHAR buf[20];
325 static const WCHAR fmt[] = { '%', 'd', 0 };
326 int i;
327
328 TRACE("\n");
329
330 for (i = 3; i >= 0; i--) {
331 const IPPART_INFO* part = &infoPtr->Part[i];
332 int value = ip_address & 0xff;
333 if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
334 wsprintfW (buf, fmt, value);
335 SetWindowTextW (part->EditHwnd, buf);
336 IPADDRESS_Notify (infoPtr, EN_CHANGE);
337 }
338 ip_address >>= 8;
339 }
340
341 return TRUE;
342 }
343
344
345 static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
346 {
347 TRACE("(index=%d)\n", index);
348
349 if (index > 3 || index < 0) index=0;
350
351 SetFocus (infoPtr->Part[index].EditHwnd);
352 }
353
354
355 static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
356 {
357 const IPPART_INFO *part = &infoPtr->Part[currentfield];
358 WCHAR field[10];
359 static const WCHAR fmt[] = { '%', 'd', 0 };
360 int curValue, newValue;
361
362 TRACE("(currentfield=%d)\n", currentfield);
363
364 if (currentfield < 0 || currentfield > 3) return FALSE;
365
366 if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
367
368 curValue = atoiW(field);
369 TRACE(" curValue=%d\n", curValue);
370
371 newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
372 TRACE(" newValue=%d\n", newValue);
373
374 if (newValue < part->LowerLimit) newValue = part->LowerLimit;
375 if (newValue > part->UpperLimit) newValue = part->UpperLimit;
376
377 if (newValue == curValue) return FALSE;
378
379 wsprintfW (field, fmt, newValue);
380 TRACE(" field=%s\n", debugstr_w(field));
381 return SetWindowTextW (part->EditHwnd, field);
382 }
383
384
385 static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
386 {
387 TRACE("\n");
388
389 if(cur >= -1 && cur < 4) {
390 IPADDRESS_ConstrainField(infoPtr, cur);
391
392 if(cur < 3) {
393 const IPPART_INFO *next = &infoPtr->Part[cur + 1];
394 int start = 0, end = 0;
395 SetFocus (next->EditHwnd);
396 if (sel != POS_DEFAULT) {
397 if (sel == POS_RIGHT)
398 start = end = GetWindowTextLengthW(next->EditHwnd);
399 else if (sel == POS_SELALL)
400 end = -1;
401 SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
402 }
403 return TRUE;
404 }
405
406 }
407 return FALSE;
408 }
409
410
411 /*
412 * period: move and select the text in the next field to the right if
413 * the current field is not empty(l!=0), we are not in the
414 * left most position, and nothing is selected(startsel==endsel)
415 *
416 * spacebar: same behavior as period
417 *
418 * alpha characters: completely ignored
419 *
420 * digits: accepted when field text length < 2 ignored otherwise.
421 * when 3 numbers have been entered into the field the value
422 * of the field is checked, if the field value exceeds the
423 * maximum value and is changed the field remains the current
424 * field, otherwise focus moves to the field to the right
425 *
426 * tab: change focus from the current ipaddress control to the next
427 * control in the tab order
428 *
429 * right arrow: move to the field on the right to the left most
430 * position in that field if no text is selected,
431 * we are in the right most position in the field,
432 * we are not in the right most field
433 *
434 * left arrow: move to the field on the left to the right most
435 * position in that field if no text is selected,
436 * we are in the left most position in the current field
437 * and we are not in the left most field
438 *
439 * backspace: delete the character to the left of the cursor position,
440 * if none are present move to the field on the left if
441 * we are not in the left most field and delete the right
442 * most digit in that field while keeping the cursor
443 * on the right side of the field
444 */
445 LRESULT CALLBACK
446 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
447 {
448 HWND Self = (HWND)GetPropW (hwnd, IP_SUBCLASS_PROP);
449 IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
450 CHAR c = (CHAR)wParam;
451 INT index, len = 0, startsel, endsel;
452 IPPART_INFO *part;
453
454 TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
455
456 if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
457 part = &infoPtr->Part[index];
458
459 if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
460 len = GetWindowTextLengthW (hwnd);
461 SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
462 }
463 switch (uMsg) {
464 case WM_CHAR:
465 if(isdigit(c)) {
466 if(len == 2 && startsel==endsel && endsel==len) {
467 /* process the digit press before we check the field */
468 int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
469
470 /* if the field value was changed stay at the current field */
471 if(!IPADDRESS_ConstrainField(infoPtr, index))
472 IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
473
474 return return_val;
475 } else if (len == 3 && startsel==endsel && endsel==len)
476 IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
477 else if (len < 3) break;
478 } else if(c == '.' || c == ' ') {
479 if(len && startsel==endsel && startsel != 0) {
480 IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
481 }
482 } else if (c == VK_BACK) break;
483 return 0;
484
485 case WM_KEYDOWN:
486 switch(c) {
487 case VK_RIGHT:
488 if(startsel==endsel && startsel==len) {
489 IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
490 return 0;
491 }
492 break;
493 case VK_LEFT:
494 if(startsel==0 && startsel==endsel && index > 0) {
495 IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
496 return 0;
497 }
498 break;
499 case VK_BACK:
500 if(startsel==endsel && startsel==0 && index > 0) {
501 IPPART_INFO *prev = &infoPtr->Part[index-1];
502 WCHAR val[10];
503
504 if(GetWindowTextW(prev->EditHwnd, val, 5)) {
505 val[lstrlenW(val) - 1] = 0;
506 SetWindowTextW(prev->EditHwnd, val);
507 }
508
509 IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
510 return 0;
511 }
512 break;
513 }
514 break;
515 case WM_KILLFOCUS:
516 if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
517 IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
518 break;
519 case WM_SETFOCUS:
520 if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
521 IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
522 break;
523 }
524 return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
525 }
526
527
528 static LRESULT WINAPI
529 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
530 {
531 IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
532
533 TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
534
535 if (!infoPtr && (uMsg != WM_CREATE))
536 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
537
538 switch (uMsg)
539 {
540 case WM_CREATE:
541 return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
542
543 case WM_DESTROY:
544 return IPADDRESS_Destroy (infoPtr);
545
546 case WM_ENABLE:
547 return IPADDRESS_Enable (infoPtr, (BOOL)wParam);
548
549 case WM_PAINT:
550 return IPADDRESS_Paint (infoPtr, (HDC)wParam);
551
552 case WM_COMMAND:
553 switch(wParam >> 16) {
554 case EN_CHANGE:
555 IPADDRESS_Notify(infoPtr, EN_CHANGE);
556 break;
557 case EN_KILLFOCUS:
558 IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
559 break;
560 }
561 break;
562
563 case IPM_CLEARADDRESS:
564 IPADDRESS_ClearAddress (infoPtr);
565 break;
566
567 case IPM_SETADDRESS:
568 return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
569
570 case IPM_GETADDRESS:
571 return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
572
573 case IPM_SETRANGE:
574 return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
575
576 case IPM_SETFOCUS:
577 IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
578 break;
579
580 case IPM_ISBLANK:
581 return IPADDRESS_IsBlank (infoPtr);
582
583 default:
584 if ((uMsg >= WM_USER) && (uMsg < WM_APP))
585 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
586 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
587 }
588 return 0;
589 }
590
591
592 void IPADDRESS_Register (void)
593 {
594 WNDCLASSW wndClass;
595
596 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
597 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
598 wndClass.lpfnWndProc = IPADDRESS_WindowProc;
599 wndClass.cbClsExtra = 0;
600 wndClass.cbWndExtra = sizeof(IPADDRESS_INFO *);
601 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
602 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
603 wndClass.lpszClassName = WC_IPADDRESSW;
604
605 RegisterClassW (&wndClass);
606 }
607
608
609 void IPADDRESS_Unregister (void)
610 {
611 UnregisterClassW (WC_IPADDRESSW, NULL);
612 }
613
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.