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