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