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
  25 #include <ctype.h>
  26 #include <stdlib.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "winuser.h"
  35 #include "winnls.h"
  36 #include "commctrl.h"
  37 #include "comctl32.h"
  38 #include "uxtheme.h"
  39 #include "vsstyle.h"
  40 #include "vssym32.h"
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43 #include "wine/heap.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(ipaddress);
  46
  47 typedef struct
  48 {
  49     HWND     EditHwnd;
  50     INT      LowerLimit;
  51     INT      UpperLimit;
  52     WNDPROC  OrigProc;
  53 } IPPART_INFO;
  54
  55 typedef struct
  56 {
  57     HWND        Self;
  58     HWND        Notify;
  59     BOOL        Enabled;
  60     IPPART_INFO Part[4];
  61 } IPADDRESS_INFO;
  62
  63 static const WCHAR IP_SUBCLASS_PROP[] =
  64     { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };
  65
  66 #define POS_DEFAULT     0
  67 #define POS_LEFT        1
  68 #define POS_RIGHT       2
  69 #define POS_SELALL      3
  70
  71 static LRESULT CALLBACK
  72 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  73
  74 static void IPADDRESS_UpdateText (const IPADDRESS_INFO *infoPtr)
  75 {
  76     static const WCHAR zero[] = {'0', 0};
  77     static const WCHAR dot[]  = {'.', 0};
  78     WCHAR field[4];
  79     WCHAR ip[16];
  80     INT i;
  81
  82     ip[0] = 0;
  83
  84     for (i = 0; i < 4; i++) {
  85         if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
  86             strcatW(ip, field);
  87         else
  88             /* empty edit treated as zero */
  89             strcatW(ip, zero);
  90         if (i != 3)
  91             strcatW(ip, dot);
  92     }
  93
  94     SetWindowTextW(infoPtr->Self, ip);
  95 }
  96
  97 static LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
  98 {
  99     HWND hwnd = infoPtr->Self;
 100
 101     TRACE("(command=%x)\n", command);
 102
 103     return SendMessageW (infoPtr->Notify, WM_COMMAND,
 104              MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
 105 }
 106
 107 static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
 108 {
 109     NMIPADDRESS nmip;
 110
 111     TRACE("(field=%x, value=%d)\n", field, value);
 112
 113     nmip.hdr.hwndFrom = infoPtr->Self;
 114     nmip.hdr.idFrom   = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
 115     nmip.hdr.code     = IPN_FIELDCHANGED;
 116
 117     nmip.iField = field;
 118     nmip.iValue = value;
 119
 120     SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
 121
 122     TRACE("<-- %d\n", nmip.iValue);
 123
 124     return nmip.iValue;
 125 }
 126
 127
 128 static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
 129 {
 130     int i;
 131
 132     TRACE("(hwnd=%p)\n", hwnd);
 133
 134     for (i = 0; i < 4; i++)
 135         if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 136
 137     ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
 138     return -1;
 139 }
 140
 141
 142 static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
 143 {
 144     static const WCHAR dotW[] = { '.', 0 };
 145     RECT rect, rcPart;
 146     COLORREF bgCol, fgCol;
 147     HTHEME theme;
 148     int i, state = ETS_NORMAL;
 149
 150     TRACE("\n");
 151
 152     GetClientRect (infoPtr->Self, &rect);
 153
 154     theme = OpenThemeData(infoPtr->Self, WC_EDITW);
 155
 156     if (theme) {
 157         DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);
 158
 159         if (!infoPtr->Enabled)
 160             state = ETS_DISABLED;
 161         else if (dwStyle & ES_READONLY)
 162             state = ETS_READONLY;
 163         else if (GetFocus() == infoPtr->Self)
 164             state = ETS_FOCUSED;
 165
 166         GetThemeColor(theme, EP_EDITTEXT, state, TMT_FILLCOLOR, &bgCol);
 167         GetThemeColor(theme, EP_EDITTEXT, state, TMT_TEXTCOLOR, &fgCol);
 168
 169         if (IsThemeBackgroundPartiallyTransparent (theme, EP_EDITTEXT, state))
 170             DrawThemeParentBackground(infoPtr->Self, hdc, &rect);
 171         DrawThemeBackground (theme, hdc, EP_EDITTEXT, state, &rect, 0);
 172     } else {
 173         if (infoPtr->Enabled) {
 174             bgCol = comctl32_color.clrWindow;
 175             fgCol = comctl32_color.clrWindowText;
 176         } else {
 177             bgCol = comctl32_color.clr3dFace;
 178             fgCol = comctl32_color.clrGrayText;
 179         }
 180
 181         FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
 182         DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 183     }
 184
 185     SetBkColor  (hdc, bgCol);
 186     SetTextColor(hdc, fgCol);
 187
 188     for (i = 0; i < 3; i++) {
 189         GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
 190         MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
 191         rect.left = rcPart.right;
 192         GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
 193         MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
 194         rect.right = rcPart.left;
 195
 196         if (theme)
 197             DrawThemeText(theme, hdc, EP_EDITTEXT, state, dotW, 1, DT_SINGLELINE | DT_CENTER | DT_BOTTOM, 0, &rect);
 198         else
 199             DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
 200     }
 201
 202     if (theme)
 203         CloseThemeData(theme);
 204
 205     return 0;
 206 }
 207
 208
 209 static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
 210 {
 211     IPADDRESS_INFO *infoPtr;
 212     RECT rcClient, edit;
 213     int i, fieldsize;
 214     HFONT hFont, hSysFont;
 215     LOGFONTW logFont, logSysFont;
 216
 217     TRACE("\n");
 218
 219     SetWindowLongW (hwnd, GWL_STYLE,
 220                     GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
 221
 222     infoPtr = heap_alloc_zero (sizeof(*infoPtr));
 223     if (!infoPtr) return -1;
 224     SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
 225
 226     GetClientRect (hwnd, &rcClient);
 227
 228     fieldsize = (rcClient.right - rcClient.left) / 4;
 229
 230     edit.top    = rcClient.top + 2;
 231     edit.bottom = rcClient.bottom - 2;
 232
 233     infoPtr->Self = hwnd;
 234     infoPtr->Enabled = TRUE;
 235     infoPtr->Notify = lpCreate->hwndParent;
 236
 237     hSysFont = GetStockObject(ANSI_VAR_FONT);
 238     GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
 239     SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
 240     strcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
 241     hFont = CreateFontIndirectW(&logFont);
 242
 243     for (i = 0; i < 4; i++) {
 244         IPPART_INFO* part = &infoPtr->Part[i];
 245
 246         part->LowerLimit = 0;
 247         part->UpperLimit = 255;
 248         edit.left = rcClient.left + i*fieldsize + 6;
 249         edit.right = rcClient.left + (i+1)*fieldsize - 2;
 250         part->EditHwnd =
 251                 CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
 252                                edit.left, edit.top, edit.right - edit.left,
 253                                edit.bottom - edit.top, hwnd, (HMENU) 1,
 254                                (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
 255         SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
 256         SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
 257         part->OrigProc = (WNDPROC)
 258                 SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
 259                                 (DWORD_PTR)IPADDRESS_SubclassProc);
 260         EnableWindow(part->EditHwnd, infoPtr->Enabled);
 261     }
 262
 263     IPADDRESS_UpdateText (infoPtr);
 264
 265     return 0;
 266 }
 267
 268
 269 static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
 270 {
 271     int i;
 272
 273     TRACE("\n");
 274
 275     for (i = 0; i < 4; i++) {
 276         IPPART_INFO* part = &infoPtr->Part[i];
 277         SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
 278     }
 279
 280     SetWindowLongPtrW (infoPtr->Self, 0, 0);
 281     heap_free (infoPtr);
 282     return 0;
 283 }
 284
 285
 286 static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
 287 {
 288     int i;
 289
 290     infoPtr->Enabled = enabled;
 291
 292     for (i = 0; i < 4; i++)
 293         EnableWindow(infoPtr->Part[i].EditHwnd, enabled);
 294
 295     InvalidateRgn(infoPtr->Self, NULL, FALSE);
 296     return 0;
 297 }
 298
 299
 300 static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
 301 {
 302     PAINTSTRUCT ps;
 303
 304     TRACE("\n");
 305
 306     if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
 307
 308     hdc = BeginPaint (infoPtr->Self, &ps);
 309     IPADDRESS_Draw (infoPtr, hdc);
 310     EndPaint (infoPtr->Self, &ps);
 311     return 0;
 312 }
 313
 314
 315 static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
 316 {
 317     int i;
 318
 319     TRACE("\n");
 320
 321     for (i = 0; i < 4; i++)
 322         if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
 323
 324     return TRUE;
 325 }
 326
 327
 328 static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
 329 {
 330     WCHAR field[5];
 331     int i, invalid = 0;
 332     DWORD ip_addr = 0;
 333
 334     TRACE("\n");
 335
 336     for (i = 0; i < 4; i++) {
 337         ip_addr *= 256;
 338         if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
 339             ip_addr += atolW(field);
 340         else
 341             invalid++;
 342     }
 343     *ip_address = ip_addr;
 344
 345     return 4 - invalid;
 346 }
 347
 348
 349 static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
 350 {
 351     TRACE("\n");
 352
 353     if ( (index < 0) || (index > 3) ) return FALSE;
 354
 355     infoPtr->Part[index].LowerLimit = range & 0xFF;
 356     infoPtr->Part[index].UpperLimit = (range >> 8)  & 0xFF;
 357
 358     return TRUE;
 359 }
 360
 361
 362 static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
 363 {
 364     static const WCHAR nil[] = { 0 };
 365     int i;
 366
 367     TRACE("\n");
 368
 369     for (i = 0; i < 4; i++)
 370         SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
 371 }
 372
 373
 374 static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
 375 {
 376     WCHAR buf[20];
 377     static const WCHAR fmt[] = { '%', 'd', 0 };
 378     int i;
 379
 380     TRACE("\n");
 381
 382     for (i = 3; i >= 0; i--) {
 383         const IPPART_INFO* part = &infoPtr->Part[i];
 384         int value = ip_address & 0xff;
 385         if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
 386             wsprintfW (buf, fmt, value);
 387             SetWindowTextW (part->EditHwnd, buf);
 388             IPADDRESS_Notify (infoPtr, EN_CHANGE);
 389         }
 390         ip_address >>= 8;
 391     }
 392
 393     return TRUE;
 394 }
 395
 396
 397 static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
 398 {
 399     TRACE("(index=%d)\n", index);
 400
 401     if (index > 3 || index < 0) index=0;
 402
 403     SetFocus (infoPtr->Part[index].EditHwnd);
 404 }
 405
 406
 407 static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
 408 {
 409     static const WCHAR fmt[] = { '%', 'd', 0 };
 410     const IPPART_INFO *part;
 411     int curValue, newValue;
 412     WCHAR field[10];
 413
 414     TRACE("(currentfield=%d)\n", currentfield);
 415
 416     if (currentfield < 0 || currentfield > 3) return FALSE;
 417
 418     part = &infoPtr->Part[currentfield];
 419     if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
 420
 421     curValue = atoiW(field);
 422     TRACE("  curValue=%d\n", curValue);
 423
 424     newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
 425     TRACE("  newValue=%d\n", newValue);
 426
 427     if (newValue < part->LowerLimit) newValue = part->LowerLimit;
 428     if (newValue > part->UpperLimit) newValue = part->UpperLimit;
 429
 430     if (newValue == curValue) return FALSE;
 431
 432     wsprintfW (field, fmt, newValue);
 433     TRACE("  field=%s\n", debugstr_w(field));
 434     return SetWindowTextW (part->EditHwnd, field);
 435 }
 436
 437
 438 static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
 439 {
 440     TRACE("\n");
 441
 442     if(cur >= -1 && cur < 4) {
 443         IPADDRESS_ConstrainField(infoPtr, cur);
 444
 445         if(cur < 3) {
 446             const IPPART_INFO *next = &infoPtr->Part[cur + 1];
 447             int start = 0, end = 0;
 448             SetFocus (next->EditHwnd);
 449             if (sel != POS_DEFAULT) {
 450                 if (sel == POS_RIGHT)
 451                     start = end = GetWindowTextLengthW(next->EditHwnd);
 452                 else if (sel == POS_SELALL)
 453                     end = -1;
 454                 SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
 455             }
 456             return TRUE;
 457         }
 458
 459     }
 460     return FALSE;
 461 }
 462
 463
 464 /*
 465  * period: move and select the text in the next field to the right if
 466  *         the current field is not empty(l!=0), we are not in the
 467  *         left most position, and nothing is selected(startsel==endsel)
 468  *
 469  * spacebar: same behavior as period
 470  *
 471  * alpha characters: completely ignored
 472  *
 473  * digits: accepted when field text length < 2 ignored otherwise.
 474  *         when 3 numbers have been entered into the field the value
 475  *         of the field is checked, if the field value exceeds the
 476  *         maximum value and is changed the field remains the current
 477  *         field, otherwise focus moves to the field to the right
 478  *
 479  * tab: change focus from the current ipaddress control to the next
 480  *      control in the tab order
 481  *
 482  * right arrow: move to the field on the right to the left most
 483  *              position in that field if no text is selected,
 484  *              we are in the right most position in the field,
 485  *              we are not in the right most field
 486  *
 487  * left arrow: move to the field on the left to the right most
 488  *             position in that field if no text is selected,
 489  *             we are in the left most position in the current field
 490  *             and we are not in the left most field
 491  *
 492  * backspace: delete the character to the left of the cursor position,
 493  *            if none are present move to the field on the left if
 494  *            we are not in the left most field and delete the right
 495  *            most digit in that field while keeping the cursor
 496  *            on the right side of the field
 497  */
 498 LRESULT CALLBACK
 499 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 500 {
 501     HWND Self = GetPropW (hwnd, IP_SUBCLASS_PROP);
 502     IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
 503     CHAR c = (CHAR)wParam;
 504     INT index, len = 0, startsel, endsel;
 505     IPPART_INFO *part;
 506
 507     TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 508
 509     if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
 510     part = &infoPtr->Part[index];
 511
 512     if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
 513         len = GetWindowTextLengthW (hwnd);
 514         SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
 515     }
 516     switch (uMsg) {
 517         case WM_CHAR:
 518             if(isdigit(c)) {
 519                 if(len == 2 && startsel==endsel && endsel==len) {
 520                     /* process the digit press before we check the field */
 521                     int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 522
 523                     /* if the field value was changed stay at the current field */
 524                     if(!IPADDRESS_ConstrainField(infoPtr, index))
 525                         IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
 526
 527                     return return_val;
 528                 } else if (len == 3 && startsel==endsel && endsel==len)
 529                     IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
 530                 else if (len < 3 || startsel != endsel) break;
 531             } else if(c == '.' || c == ' ') {
 532                 if(len && startsel==endsel && startsel != 0) {
 533                     IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
 534                 }
 535             } else if (c == VK_BACK) break;
 536             return 0;
 537
 538         case WM_KEYDOWN:
 539             switch(c) {
 540                 case VK_RIGHT:
 541                     if(startsel==endsel && startsel==len) {
 542                         IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
 543                         return 0;
 544                     }
 545                     break;
 546                 case VK_LEFT:
 547                     if(startsel==0 && startsel==endsel && index > 0) {
 548                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 549                         return 0;
 550                     }
 551                     break;
 552                 case VK_BACK:
 553                     if(startsel==endsel && startsel==0 && index > 0) {
 554                         IPPART_INFO *prev = &infoPtr->Part[index-1];
 555                         WCHAR val[10];
 556
 557                         if(GetWindowTextW(prev->EditHwnd, val, 5)) {
 558                             val[lstrlenW(val) - 1] = 0;
 559                             SetWindowTextW(prev->EditHwnd, val);
 560                         }
 561
 562                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 563                         return 0;
 564                     }
 565                     break;
 566             }
 567             break;
 568         case WM_KILLFOCUS:
 569             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 570                 IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
 571             break;
 572         case WM_SETFOCUS:
 573             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 574                 IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
 575             break;
 576     }
 577     return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 578 }
 579
 580
 581 static LRESULT WINAPI
 582 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 583 {
 584     IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
 585
 586     TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 587
 588     if (!infoPtr && (uMsg != WM_CREATE))
 589         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 590
 591     switch (uMsg)
 592     {
 593         case WM_CREATE:
 594             return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
 595
 596         case WM_DESTROY:
 597             return IPADDRESS_Destroy (infoPtr);
 598
 599         case WM_ENABLE:
 600             return IPADDRESS_Enable (infoPtr, (BOOL)wParam);
 601
 602         case WM_PAINT:
 603             return IPADDRESS_Paint (infoPtr, (HDC)wParam);
 604
 605         case WM_COMMAND:
 606             switch(wParam >> 16) {
 607                 case EN_CHANGE:
 608                     IPADDRESS_UpdateText(infoPtr);
 609                     IPADDRESS_Notify(infoPtr, EN_CHANGE);
 610                     break;
 611                 case EN_KILLFOCUS:
 612                     IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
 613                     break;
 614             }
 615             break;
 616
 617         case WM_SYSCOLORCHANGE:
 618             COMCTL32_RefreshSysColors();
 619             return 0;
 620
 621         case IPM_CLEARADDRESS:
 622             IPADDRESS_ClearAddress (infoPtr);
 623             break;
 624
 625         case IPM_SETADDRESS:
 626             return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
 627
 628         case IPM_GETADDRESS:
 629             return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
 630
 631         case IPM_SETRANGE:
 632             return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
 633
 634         case IPM_SETFOCUS:
 635             IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
 636             break;
 637
 638         case IPM_ISBLANK:
 639             return IPADDRESS_IsBlank (infoPtr);
 640
 641         default:
 642             if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
 643                 ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
 644             return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 645     }
 646     return 0;
 647 }
 648
 649
 650 void IPADDRESS_Register (void)
 651 {
 652     WNDCLASSW wndClass;
 653
 654     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
 655     wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
 656     wndClass.lpfnWndProc   = IPADDRESS_WindowProc;
 657     wndClass.cbClsExtra    = 0;
 658     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
 659     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
 660     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 661     wndClass.lpszClassName = WC_IPADDRESSW;
 662
 663     RegisterClassW (&wndClass);
 664 }
 665
 666
 667 void IPADDRESS_Unregister (void)
 668 {
 669     UnregisterClassW (WC_IPADDRESSW, NULL);
 670 }