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