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