ipaddress.c 18.4 KB
Newer Older
1 2
/*
 * IP Address control
3
 *
4 5 6
 * Copyright 2002 Dimitrie O. Paun
 * Copyright 1999 Chris Morgan<cmorgan@wpi.edu>
 * Copyright 1999 James Abbatiello<abbeyj@wpi.edu>
7
 * Copyright 1998, 1999 Eric Kohl
8
 * Copyright 1998 Alex Priem <alexp@sci.kun.nl>
9
 *
10 11 12 13 14 15 16 17 18 19 20 21
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 26 27 28
 * NOTE
 * 
 * This code was audited for completeness against the documented features
 * of Comctl32.dll version 6.0 on Sep. 9, 2002, by Dimitrie O. Paun.
 * 
Robert Shearman's avatar
Robert Shearman committed
29
 * Unless otherwise noted, we believe this code to be complete, as per
30 31 32
 * the specification mentioned above.
 * If you discover missing features, or bugs, please note them below.
 * 
33 34
 */

35 36
#include <ctype.h>
#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 44 45
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
46
#include "commctrl.h"
47
#include "comctl32.h"
48 49 50
#include "uxtheme.h"
#include "vsstyle.h"
#include "vssym32.h"
51
#include "wine/unicode.h"
52
#include "wine/debug.h"
53

54
WINE_DEFAULT_DEBUG_CHANNEL(ipaddress);
55

56 57
typedef struct
{
58 59 60 61 62
    HWND     EditHwnd;
    INT      LowerLimit;
    INT      UpperLimit;
    WNDPROC  OrigProc;
} IPPART_INFO;
63 64 65

typedef struct
{
66
    HWND	Self;
67
    HWND	Notify;
Felix Nawothnig's avatar
Felix Nawothnig committed
68
    BOOL	Enabled;
69 70
    IPPART_INFO	Part[4];
} IPADDRESS_INFO;
71

72 73 74
static const WCHAR IP_SUBCLASS_PROP[] = 
    { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };

75 76 77 78
#define POS_DEFAULT	0
#define POS_LEFT	1
#define POS_RIGHT	2
#define POS_SELALL	3
79 80

static LRESULT CALLBACK
81
IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
82

83 84
static void IPADDRESS_UpdateText (const IPADDRESS_INFO *infoPtr)
{
85 86
    static const WCHAR zero[] = {'0', 0};
    static const WCHAR dot[]  = {'.', 0};
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
    WCHAR field[4];
    WCHAR ip[16];
    INT i;

    ip[0] = 0;

    for (i = 0; i < 4; i++) {
        if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
            strcatW(ip, field);
        else
            /* empty edit treated as zero */
            strcatW(ip, zero);
        if (i != 3)
            strcatW(ip, dot);
    }

    SetWindowTextW(infoPtr->Self, ip);
}

106
static LRESULT IPADDRESS_Notify (const IPADDRESS_INFO *infoPtr, UINT command)
107
{
108
    HWND hwnd = infoPtr->Self;
109

110
    TRACE("(command=%x)\n", command);
111

112
    return SendMessageW (infoPtr->Notify, WM_COMMAND,
113
             MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
114 115
}

116
static INT IPADDRESS_IPNotify (const IPADDRESS_INFO *infoPtr, INT field, INT value)
117
{
118
    NMIPADDRESS nmip;
119

120
    TRACE("(field=%x, value=%d)\n", field, value);
121

122
    nmip.hdr.hwndFrom = infoPtr->Self;
123
    nmip.hdr.idFrom   = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
124
    nmip.hdr.code     = IPN_FIELDCHANGED;
125

126 127
    nmip.iField = field;
    nmip.iValue = value;
128

129
    SendMessageW (infoPtr->Notify, WM_NOTIFY, nmip.hdr.idFrom, (LPARAM)&nmip);
130

131
    TRACE("<-- %d\n", nmip.iValue);
132

133
    return nmip.iValue;
134
}
135 136


137
static int IPADDRESS_GetPartIndex(const IPADDRESS_INFO *infoPtr, HWND hwnd)
138
{
139
    int i;
140

141
    TRACE("(hwnd=%p)\n", hwnd);
142 143

    for (i = 0; i < 4; i++)
144
        if (infoPtr->Part[i].EditHwnd == hwnd) return i;
145

146
    ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
147
    return -1;
148 149 150
}


151
static LRESULT IPADDRESS_Draw (const IPADDRESS_INFO *infoPtr, HDC hdc)
152
{
153
    static const WCHAR dotW[] = { '.', 0 };
154
    RECT rect, rcPart;
Felix Nawothnig's avatar
Felix Nawothnig committed
155
    COLORREF bgCol, fgCol;
156 157
    HTHEME theme;
    int i, state = ETS_NORMAL;
158

159
    TRACE("\n");
160

161
    GetClientRect (infoPtr->Self, &rect);
Felix Nawothnig's avatar
Felix Nawothnig committed
162

163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
    theme = OpenThemeData(infoPtr->Self, WC_EDITW);

    if (theme) {
        DWORD dwStyle = GetWindowLongW (infoPtr->Self, GWL_STYLE);

        if (!infoPtr->Enabled)
            state = ETS_DISABLED;
        else if (dwStyle & ES_READONLY)
            state = ETS_READONLY;
        else if (GetFocus() == infoPtr->Self)
            state = ETS_FOCUSED;

        GetThemeColor(theme, EP_EDITTEXT, state, TMT_FILLCOLOR, &bgCol);
        GetThemeColor(theme, EP_EDITTEXT, state, TMT_TEXTCOLOR, &fgCol);

        if (IsThemeBackgroundPartiallyTransparent (theme, EP_EDITTEXT, state))
            DrawThemeParentBackground(infoPtr->Self, hdc, &rect);
        DrawThemeBackground (theme, hdc, EP_EDITTEXT, state, &rect, 0);
Felix Nawothnig's avatar
Felix Nawothnig committed
181
    } else {
182 183 184 185 186 187 188 189 190 191
        if (infoPtr->Enabled) {
            bgCol = comctl32_color.clrWindow;
            fgCol = comctl32_color.clrWindowText;
        } else {
            bgCol = comctl32_color.clr3dFace;
            fgCol = comctl32_color.clrGrayText;
        }

        FillRect (hdc, &rect, (HBRUSH)(DWORD_PTR)(bgCol+1));
        DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
Felix Nawothnig's avatar
Felix Nawothnig committed
192 193
    }
    
194 195
    SetBkColor  (hdc, bgCol);
    SetTextColor(hdc, fgCol);
196 197 198

    for (i = 0; i < 3; i++) {
        GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
199
        MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
200 201
        rect.left = rcPart.right;
        GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
202
        MapWindowPoints( 0, infoPtr->Self, (POINT *)&rcPart, 2 );
203 204 205 206 207 208
        rect.right = rcPart.left;

        if (theme)
            DrawThemeText(theme, hdc, EP_EDITTEXT, state, dotW, 1, DT_SINGLELINE | DT_CENTER | DT_BOTTOM, 0, &rect);
        else
            DrawTextW(hdc, dotW, 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
209
    }
210

211 212 213
    if (theme)
        CloseThemeData(theme);

214
    return 0;
215
}
216 217


218
static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
219
{
220 221 222
    IPADDRESS_INFO *infoPtr;
    RECT rcClient, edit;
    int i, fieldsize;
223 224
    HFONT hFont, hSysFont;
    LOGFONTW logFont, logSysFont;
225 226

    TRACE("\n");
227

228 229
    SetWindowLongW (hwnd, GWL_STYLE,
		    GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
230

231
    infoPtr = Alloc (sizeof(IPADDRESS_INFO));
232
    if (!infoPtr) return -1;
233
    SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
234

235
    GetClientRect (hwnd, &rcClient);
236

237
    fieldsize = (rcClient.right - rcClient.left) / 4;
238

239 240
    edit.top    = rcClient.top + 2;
    edit.bottom = rcClient.bottom - 2;
241

242
    infoPtr->Self = hwnd;
243
    infoPtr->Enabled = TRUE;
244
    infoPtr->Notify = lpCreate->hwndParent;
245

246
    hSysFont = GetStockObject(ANSI_VAR_FONT);
247 248 249 250 251
    GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
    SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
    strcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
    hFont = CreateFontIndirectW(&logFont);

252 253
    for (i = 0; i < 4; i++) {
	IPPART_INFO* part = &infoPtr->Part[i];
254

255 256 257 258 259
	part->LowerLimit = 0;
	part->UpperLimit = 255;
        edit.left = rcClient.left + i*fieldsize + 6;
        edit.right = rcClient.left + (i+1)*fieldsize - 2;
        part->EditHwnd =
260
		CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
261 262
                               edit.left, edit.top, edit.right - edit.left,
			       edit.bottom - edit.top, hwnd, (HMENU) 1,
263
			       (HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
264
        SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
265
	SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
266
        part->OrigProc = (WNDPROC)
267 268
		SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
				(DWORD_PTR)IPADDRESS_SubclassProc);
269
        EnableWindow(part->EditHwnd, infoPtr->Enabled);
270
    }
271

272 273
    IPADDRESS_UpdateText (infoPtr);

274
    return 0;
275
}
276 277


278
static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
279
{
280
    int i;
281

282
    TRACE("\n");
283

284 285
    for (i = 0; i < 4; i++) {
	IPPART_INFO* part = &infoPtr->Part[i];
286
        SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC, (DWORD_PTR)part->OrigProc);
287
    }
288

289
    SetWindowLongPtrW (infoPtr->Self, 0, 0);
290
    Free (infoPtr);
291
    return 0;
292 293 294
}


Felix Nawothnig's avatar
Felix Nawothnig committed
295 296 297 298 299 300 301 302 303 304 305 306 307 308
static LRESULT IPADDRESS_Enable (IPADDRESS_INFO *infoPtr, BOOL enabled)
{
    int i;

    infoPtr->Enabled = enabled;

    for (i = 0; i < 4; i++)
        EnableWindow(infoPtr->Part[i].EditHwnd, enabled);

    InvalidateRgn(infoPtr->Self, NULL, FALSE);
    return 0;
}


309
static LRESULT IPADDRESS_Paint (const IPADDRESS_INFO *infoPtr, HDC hdc)
310
{
311
    PAINTSTRUCT ps;
312

313
    TRACE("\n");
314

315
    if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
316

317 318 319 320
    hdc = BeginPaint (infoPtr->Self, &ps);
    IPADDRESS_Draw (infoPtr, hdc);
    EndPaint (infoPtr->Self, &ps);
    return 0;
321 322 323
}


324
static BOOL IPADDRESS_IsBlank (const IPADDRESS_INFO *infoPtr)
325
{
326
    int i;
327

328
    TRACE("\n");
329

330 331 332 333
    for (i = 0; i < 4; i++)
        if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;

    return TRUE;
334 335
}

336

337
static int IPADDRESS_GetAddress (const IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
338
{
339 340 341
    WCHAR field[5];
    int i, invalid = 0;
    DWORD ip_addr = 0;
342

343
    TRACE("\n");
344

345 346
    for (i = 0; i < 4; i++) {
        ip_addr *= 256;
347
        if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
348
  	    ip_addr += atolW(field);
349 350 351 352
	else
	    invalid++;
    }
    *ip_address = ip_addr;
353

354
    return 4 - invalid;
355 356
}

357

358
static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
359
{
360
    TRACE("\n");
361

362
    if ( (index < 0) || (index > 3) ) return FALSE;
363

364 365 366 367
    infoPtr->Part[index].LowerLimit = range & 0xFF;
    infoPtr->Part[index].UpperLimit = (range >> 8)  & 0xFF;

    return TRUE;
368 369 370
}


371
static void IPADDRESS_ClearAddress (const IPADDRESS_INFO *infoPtr)
372
{
373
    static const WCHAR nil[] = { 0 };
374
    int i;
375

376
    TRACE("\n");
377

378
    for (i = 0; i < 4; i++)
379
        SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
380 381
}

382

383
static LRESULT IPADDRESS_SetAddress (const IPADDRESS_INFO *infoPtr, DWORD ip_address)
384
{
385 386
    WCHAR buf[20];
    static const WCHAR fmt[] = { '%', 'd', 0 };
387 388 389
    int i;

    TRACE("\n");
390

391
    for (i = 3; i >= 0; i--) {
392
	const IPPART_INFO* part = &infoPtr->Part[i];
393 394
        int value = ip_address & 0xff;
	if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
395
	    wsprintfW (buf, fmt, value);
396 397 398 399 400
	    SetWindowTextW (part->EditHwnd, buf);
	    IPADDRESS_Notify (infoPtr, EN_CHANGE);
        }
        ip_address >>= 8;
    }
401

402
    return TRUE;
403
}
404 405


406
static void IPADDRESS_SetFocusToField (const IPADDRESS_INFO *infoPtr, INT index)
407
{
408
    TRACE("(index=%d)\n", index);
409

Alex Zorach's avatar
Alex Zorach committed
410
    if (index > 3 || index < 0) index=0;
411

412
    SetFocus (infoPtr->Part[index].EditHwnd);
413 414 415
}


416
static BOOL IPADDRESS_ConstrainField (const IPADDRESS_INFO *infoPtr, int currentfield)
417
{
418
    static const WCHAR fmt[] = { '%', 'd', 0 };
419
    const IPPART_INFO *part;
420
    int curValue, newValue;
421
    WCHAR field[10];
422

423
    TRACE("(currentfield=%d)\n", currentfield);
424

425
    if (currentfield < 0 || currentfield > 3) return FALSE;
426

427
    part = &infoPtr->Part[currentfield];
428
    if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
429

430
    curValue = atoiW(field);
431
    TRACE("  curValue=%d\n", curValue);
432

433 434 435 436 437
    newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
    TRACE("  newValue=%d\n", newValue);

    if (newValue < part->LowerLimit) newValue = part->LowerLimit;
    if (newValue > part->UpperLimit) newValue = part->UpperLimit;
438

439
    if (newValue == curValue) return FALSE;
440

441
    wsprintfW (field, fmt, newValue);
442
    TRACE("  field=%s\n", debugstr_w(field));
443
    return SetWindowTextW (part->EditHwnd, field);
444
}
445 446


447
static BOOL IPADDRESS_GotoNextField (const IPADDRESS_INFO *infoPtr, int cur, int sel)
448
{
449 450 451 452
    TRACE("\n");

    if(cur >= -1 && cur < 4) {
	IPADDRESS_ConstrainField(infoPtr, cur);
453

454
	if(cur < 3) {
455
	    const IPPART_INFO *next = &infoPtr->Part[cur + 1];
456 457 458 459 460 461 462 463 464 465 466
	    int start = 0, end = 0;
            SetFocus (next->EditHwnd);
	    if (sel != POS_DEFAULT) {
		if (sel == POS_RIGHT)
		    start = end = GetWindowTextLengthW(next->EditHwnd);
		else if (sel == POS_SELALL)
		    end = -1;
	        SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
	    }
	    return TRUE;
	}
467

468
    }
469
    return FALSE;
470 471 472
}


473 474 475 476 477 478 479 480 481
/*
 * period: move and select the text in the next field to the right if
 *         the current field is not empty(l!=0), we are not in the
 *         left most position, and nothing is selected(startsel==endsel)
 *
 * spacebar: same behavior as period
 *
 * alpha characters: completely ignored
 *
482 483 484 485 486
 * digits: accepted when field text length < 2 ignored otherwise.
 *         when 3 numbers have been entered into the field the value
 *         of the field is checked, if the field value exceeds the
 *         maximum value and is changed the field remains the current
 *         field, otherwise focus moves to the field to the right
487
 *
488 489
 * tab: change focus from the current ipaddress control to the next
 *      control in the tab order
490
 *
491 492 493 494
 * right arrow: move to the field on the right to the left most
 *              position in that field if no text is selected,
 *              we are in the right most position in the field,
 *              we are not in the right most field
495
 *
496 497 498 499
 * left arrow: move to the field on the left to the right most
 *             position in that field if no text is selected,
 *             we are in the left most position in the current field
 *             and we are not in the left most field
500
 *
501 502 503 504 505
 * backspace: delete the character to the left of the cursor position,
 *            if none are present move to the field on the left if
 *            we are not in the left most field and delete the right
 *            most digit in that field while keeping the cursor
 *            on the right side of the field
506
 */
507
LRESULT CALLBACK
508
IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
509
{
510
    HWND Self = GetPropW (hwnd, IP_SUBCLASS_PROP);
511
    IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
512 513 514
    CHAR c = (CHAR)wParam;
    INT index, len = 0, startsel, endsel;
    IPPART_INFO *part;
515

516
    TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
517

518 519
    if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
    part = &infoPtr->Part[index];
520

521 522 523
    if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
	len = GetWindowTextLengthW (hwnd);
	SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
524
    }
525
    switch (uMsg) {
526
 	case WM_CHAR:
527 528 529 530
 	    if(isdigit(c)) {
		if(len == 2 && startsel==endsel && endsel==len) {
		    /* process the digit press before we check the field */
		    int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
531

532 533 534 535 536 537 538
		    /* if the field value was changed stay at the current field */
		    if(!IPADDRESS_ConstrainField(infoPtr, index))
			IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);

		    return return_val;
		} else if (len == 3 && startsel==endsel && endsel==len)
		    IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
539
		else if (len < 3 || startsel != endsel) break;
540 541
	    } else if(c == '.' || c == ' ') {
		if(len && startsel==endsel && startsel != 0) {
542
		    IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
543 544 545
		}
 	    } else if (c == VK_BACK) break;
	    return 0;
546

547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
	case WM_KEYDOWN:
	    switch(c) {
		case VK_RIGHT:
		    if(startsel==endsel && startsel==len) {
			IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
			return 0;
		    }
		    break;
		case VK_LEFT:
		    if(startsel==0 && startsel==endsel && index > 0) {
			IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
			return 0;
		    }
		    break;
		case VK_BACK:
		    if(startsel==endsel && startsel==0 && index > 0) {
			IPPART_INFO *prev = &infoPtr->Part[index-1];
			WCHAR val[10];
565

566 567 568 569
			if(GetWindowTextW(prev->EditHwnd, val, 5)) {
			    val[lstrlenW(val) - 1] = 0;
			    SetWindowTextW(prev->EditHwnd, val);
			}
570

571 572 573 574
			IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
			return 0;
		    }
		    break;
575
	    }
576 577 578 579 580 581 582 583 584 585 586
	    break;
	case WM_KILLFOCUS:
	    if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
		IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
	    break;
	case WM_SETFOCUS:
	    if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
		IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
	    break;
    }
    return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
587
}
588

589

590
static LRESULT WINAPI
591
IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
592
{
593
    IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (hwnd, 0);
594

595
    TRACE("(hwnd=%p msg=0x%x wparam=0x%lx lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
596

597 598
    if (!infoPtr && (uMsg != WM_CREATE))
        return DefWindowProcW (hwnd, uMsg, wParam, lParam);
599

600 601 602
    switch (uMsg)
    {
	case WM_CREATE:
603
	    return IPADDRESS_Create (hwnd, (LPCREATESTRUCTA)lParam);
604 605 606 607

	case WM_DESTROY:
	    return IPADDRESS_Destroy (infoPtr);

Felix Nawothnig's avatar
Felix Nawothnig committed
608 609 610
	case WM_ENABLE:
	    return IPADDRESS_Enable (infoPtr, (BOOL)wParam);

611 612 613 614 615 616
	case WM_PAINT:
	    return IPADDRESS_Paint (infoPtr, (HDC)wParam);

	case WM_COMMAND:
	    switch(wParam >> 16) {
		case EN_CHANGE:
617
		    IPADDRESS_UpdateText(infoPtr);
618 619 620 621 622 623 624 625
		    IPADDRESS_Notify(infoPtr, EN_CHANGE);
		    break;
		case EN_KILLFOCUS:
		    IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
		    break;
	    }
	    break;

626 627 628 629
        case WM_SYSCOLORCHANGE:
            COMCTL32_RefreshSysColors();
            return 0;

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
        case IPM_CLEARADDRESS:
            IPADDRESS_ClearAddress (infoPtr);
	    break;

        case IPM_SETADDRESS:
            return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);

        case IPM_GETADDRESS:
 	    return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);

	case IPM_SETRANGE:
	    return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);

	case IPM_SETFOCUS:
	    IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
	    break;

	case IPM_ISBLANK:
	    return IPADDRESS_IsBlank (infoPtr);

	default:
651
	    if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
652
		ERR("unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
653
	    return DefWindowProcW (hwnd, uMsg, wParam, lParam);
654 655 656 657 658
    }
    return 0;
}


659
void IPADDRESS_Register (void)
660
{
661 662 663
    WNDCLASSW wndClass;

    ZeroMemory (&wndClass, sizeof(WNDCLASSW));
664 665
    wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc   = IPADDRESS_WindowProc;
666 667
    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
668
    wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_IBEAM);
669
    wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
670
    wndClass.lpszClassName = WC_IPADDRESSW;
671

672
    RegisterClassW (&wndClass);
673 674
}

675

676
void IPADDRESS_Unregister (void)
677
{
678
    UnregisterClassW (WC_IPADDRESSW, NULL);
679
}