git.oblomov.eu Git - wine/blob - 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 static const WCHAR IP_SUBCLASS_PROP[] =
  69     { 'C', 'C', 'I', 'P', '3', '2', 'S', 'u', 'b', 'c', 'l', 'a', 's', 's', 'I', 'n', 'f', 'o', 0 };
  70
  71 #define POS_DEFAULT     0
  72 #define POS_LEFT        1
  73 #define POS_RIGHT       2
  74 #define POS_SELALL      3
  75
  76 static LRESULT CALLBACK
  77 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  78
  79 static LRESULT IPADDRESS_Notify (IPADDRESS_INFO *infoPtr, UINT command)
  80 {
  81     HWND hwnd = infoPtr->Self;
  82
  83     TRACE("(command=%x)\n", command);
  84
  85     return SendMessageW (infoPtr->Notify, WM_COMMAND,
  86              MAKEWPARAM (GetWindowLongPtrW (hwnd, GWLP_ID), command), (LPARAM)hwnd);
  87 }
  88
  89 static INT IPADDRESS_IPNotify (IPADDRESS_INFO *infoPtr, INT field, INT value)
  90 {
  91     NMIPADDRESS nmip;
  92
  93     TRACE("(field=%x, value=%d)\n", field, value);
  94
  95     nmip.hdr.hwndFrom = infoPtr->Self;
  96     nmip.hdr.idFrom   = GetWindowLongPtrW (infoPtr->Self, GWLP_ID);
  97     nmip.hdr.code     = IPN_FIELDCHANGED;
  98
  99     nmip.iField = field;
 100     nmip.iValue = value;
 101
 102     SendMessageW (infoPtr->Notify, WM_NOTIFY,
 103                   (WPARAM)nmip.hdr.idFrom, (LPARAM)&nmip);
 104
 105     TRACE("<-- %d\n", nmip.iValue);
 106
 107     return nmip.iValue;
 108 }
 109
 110
 111 static int IPADDRESS_GetPartIndex(IPADDRESS_INFO *infoPtr, HWND hwnd)
 112 {
 113     int i;
 114
 115     TRACE("(hwnd=%p)\n", hwnd);
 116
 117     for (i = 0; i < 4; i++)
 118         if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 119
 120     ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
 121     return -1;
 122 }
 123
 124
 125 static LRESULT IPADDRESS_Draw (IPADDRESS_INFO *infoPtr, HDC hdc)
 126 {
 127     static const WCHAR dotW[] = { '.', 0 };
 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         DrawTextW(hdc, dotW, 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     static const WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
 156     IPADDRESS_INFO *infoPtr;
 157     RECT rcClient, edit;
 158     int i, fieldsize;
 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         SetPropW(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)GetPropW (hwnd, IP_SUBCLASS_PROP);
 423     IPADDRESS_INFO *infoPtr = (IPADDRESS_INFO *)GetWindowLongPtrW (Self, 0);
 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_INFO *)GetWindowLongPtrW (hwnd, 0);
 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 }