reactos/lib/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 = FALSE;
 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     }
 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 (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 (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 (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 (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 (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         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 (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 (IPADDRESS_INFO *infoPtr, int currentfield)
 356 {
 357     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 (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             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%x 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%x 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             break;
 549
 550         case WM_PAINT:
 551             return IPADDRESS_Paint (infoPtr, (HDC)wParam);
 552
 553         case WM_COMMAND:
 554             switch(wParam >> 16) {
 555                 case EN_CHANGE:
 556                     IPADDRESS_Notify(infoPtr, EN_CHANGE);
 557                     break;
 558                 case EN_KILLFOCUS:
 559                     IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
 560                     break;
 561             }
 562             break;
 563
 564         case IPM_CLEARADDRESS:
 565             IPADDRESS_ClearAddress (infoPtr);
 566             break;
 567
 568         case IPM_SETADDRESS:
 569             return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
 570
 571         case IPM_GETADDRESS:
 572             return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
 573
 574         case IPM_SETRANGE:
 575             return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
 576
 577         case IPM_SETFOCUS:
 578             IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
 579             break;
 580
 581         case IPM_ISBLANK:
 582             return IPADDRESS_IsBlank (infoPtr);
 583
 584         default:
 585             if ((uMsg >= WM_USER) && (uMsg < WM_APP))
 586                 ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
 587             return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 588     }
 589     return 0;
 590 }
 591
 592
 593 void IPADDRESS_Register (void)
 594 {
 595     WNDCLASSW wndClass;
 596
 597     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
 598     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
 599     wndClass.lpfnWndProc   = IPADDRESS_WindowProc;
 600     wndClass.cbClsExtra    = 0;
 601     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
 602     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
 603     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 604     wndClass.lpszClassName = WC_IPADDRESSW;
 605
 606     RegisterClassW (&wndClass);
 607 }
 608
 609
 610 void IPADDRESS_Unregister (void)
 611 {
 612     UnregisterClassW (WC_IPADDRESSW, NULL);
 613 }