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 belive 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 <stdio.h>
  38 #include <string.h>
  39
  40 #include "winbase.h"
  41 #include "commctrl.h"
  42 #include "wine/unicode.h"
  43 #include "wine/debug.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     IPPART_INFO Part[4];
  59 } IPADDRESS_INFO;
  60
  61 #define POS_DEFAULT     0
  62 #define POS_LEFT        1
  63 #define POS_RIGHT       2
  64 #define POS_SELALL      3
  65
  66 #define IP_SUBCLASS_PROP "CCIP32SubclassInfo"
  67 #define IPADDRESS_GetInfoPtr(hwnd) ((IPADDRESS_INFO *)GetWindowLongW (hwnd, 0))
  68
  69
  70 static LRESULT CALLBACK
  71 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  72
  73 static LRESULT IPADDRESS_Notify (IPADDRESS_INFO *infoPtr, UINT command)
  74 {
  75     HWND hwnd = infoPtr->Self;
  76
  77     TRACE("(command=%x)\n", command);
  78
  79     return SendMessageW (GetParent (hwnd), WM_COMMAND,
  80              MAKEWPARAM (GetWindowLongW (hwnd, GWL_ID), command), (LPARAM)hwnd);
  81 }
  82
  83 static INT IPADDRESS_IPNotify (IPADDRESS_INFO *infoPtr, INT field, INT value)
  84 {
  85     NMIPADDRESS nmip;
  86
  87     TRACE("(field=%x, value=%d)\n", field, value);
  88
  89     nmip.hdr.hwndFrom = infoPtr->Self;
  90     nmip.hdr.idFrom   = GetWindowLongW (infoPtr->Self, GWL_ID);
  91     nmip.hdr.code     = IPN_FIELDCHANGED;
  92
  93     nmip.iField = field;
  94     nmip.iValue = value;
  95
  96     SendMessageW (GetParent (infoPtr->Self), WM_NOTIFY,
  97                   (WPARAM)nmip.hdr.idFrom, (LPARAM)&nmip);
  98
  99     TRACE("<-- %d\n", nmip.iValue);
 100
 101     return nmip.iValue;
 102 }
 103
 104
 105 static int IPADDRESS_GetPartIndex(IPADDRESS_INFO *infoPtr, HWND hwnd)
 106 {
 107     int i;
 108
 109     TRACE("(hwnd=%p)\n", hwnd);
 110
 111     for (i = 0; i < 4; i++)
 112         if (infoPtr->Part[i].EditHwnd == hwnd) return i;
 113
 114     ERR("We subclassed the wrong window! (hwnd=%p)\n", hwnd);
 115     return -1;
 116 }
 117
 118
 119 static LRESULT IPADDRESS_Draw (IPADDRESS_INFO *infoPtr, HDC hdc)
 120 {
 121     RECT rect, rcPart;
 122     POINT pt;
 123     int i;
 124
 125     TRACE("\n");
 126
 127     GetClientRect (infoPtr->Self, &rect);
 128     DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
 129
 130     for (i = 0; i < 3; i++) {
 131         GetWindowRect (infoPtr->Part[i].EditHwnd, &rcPart);
 132         pt.x = rcPart.right;
 133         ScreenToClient(infoPtr->Self, &pt);
 134         rect.left = pt.x;
 135         GetWindowRect (infoPtr->Part[i+1].EditHwnd, &rcPart);
 136         pt.x = rcPart.left;
 137         ScreenToClient(infoPtr->Self, &pt);
 138         rect.right = pt.x;
 139         DrawTextA(hdc, ".", 1, &rect, DT_SINGLELINE | DT_CENTER | DT_BOTTOM);
 140     }
 141
 142     return 0;
 143 }
 144
 145
 146 static LRESULT IPADDRESS_Create (HWND hwnd)
 147 {
 148     IPADDRESS_INFO *infoPtr;
 149     RECT rcClient, edit;
 150     int i, fieldsize;
 151     WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
 152
 153     TRACE("\n");
 154
 155     SetWindowLongW (hwnd, GWL_STYLE,
 156                     GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
 157
 158     infoPtr = (IPADDRESS_INFO *)COMCTL32_Alloc (sizeof(IPADDRESS_INFO));
 159     if (!infoPtr) return -1;
 160     SetWindowLongW (hwnd, 0, (DWORD)infoPtr);
 161
 162     GetClientRect (hwnd, &rcClient);
 163
 164     fieldsize = (rcClient.right - rcClient.left) / 4;
 165
 166     edit.top    = rcClient.top + 2;
 167     edit.bottom = rcClient.bottom - 2;
 168
 169     infoPtr->Self = hwnd;
 170
 171     for (i = 0; i < 4; i++) {
 172         IPPART_INFO* part = &infoPtr->Part[i];
 173
 174         part->LowerLimit = 0;
 175         part->UpperLimit = 255;
 176         edit.left = rcClient.left + i*fieldsize + 6;
 177         edit.right = rcClient.left + (i+1)*fieldsize - 2;
 178         part->EditHwnd =
 179                 CreateWindowW (EDIT, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
 180                                edit.left, edit.top, edit.right - edit.left,
 181                                edit.bottom - edit.top, hwnd, (HMENU) 1,
 182                                (HINSTANCE)GetWindowLongW(hwnd, GWL_HINSTANCE), NULL);
 183         SetPropA(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
 184         part->OrigProc = (WNDPROC)
 185                 SetWindowLongW (part->EditHwnd, GWL_WNDPROC,
 186                                 (LONG)IPADDRESS_SubclassProc);
 187     }
 188
 189     return 0;
 190 }
 191
 192
 193 static LRESULT IPADDRESS_Destroy (IPADDRESS_INFO *infoPtr)
 194 {
 195     int i;
 196
 197     TRACE("\n");
 198
 199     for (i = 0; i < 4; i++) {
 200         IPPART_INFO* part = &infoPtr->Part[i];
 201         SetWindowLongW (part->EditHwnd, GWL_WNDPROC, (LONG)part->OrigProc);
 202     }
 203
 204     SetWindowLongW (infoPtr->Self, 0, 0);
 205     COMCTL32_Free (infoPtr);
 206     return 0;
 207 }
 208
 209
 210 static LRESULT IPADDRESS_Paint (IPADDRESS_INFO *infoPtr, HDC hdc)
 211 {
 212     PAINTSTRUCT ps;
 213
 214     TRACE("\n");
 215
 216     if (hdc) return IPADDRESS_Draw (infoPtr, hdc);
 217
 218     hdc = BeginPaint (infoPtr->Self, &ps);
 219     IPADDRESS_Draw (infoPtr, hdc);
 220     EndPaint (infoPtr->Self, &ps);
 221     return 0;
 222 }
 223
 224
 225 static BOOL IPADDRESS_IsBlank (IPADDRESS_INFO *infoPtr)
 226 {
 227     int i;
 228
 229     TRACE("\n");
 230
 231     for (i = 0; i < 4; i++)
 232         if (GetWindowTextLengthW (infoPtr->Part[i].EditHwnd)) return FALSE;
 233
 234     return TRUE;
 235 }
 236
 237
 238 static int IPADDRESS_GetAddress (IPADDRESS_INFO *infoPtr, LPDWORD ip_address)
 239 {
 240     WCHAR field[5];
 241     int i, invalid = 0;
 242     DWORD ip_addr = 0;
 243
 244     TRACE("\n");
 245
 246     for (i = 0; i < 4; i++) {
 247         ip_addr *= 256;
 248         if (GetWindowTextW (infoPtr->Part[i].EditHwnd, field, 4))
 249             ip_addr += atolW(field);
 250         else
 251             invalid++;
 252     }
 253     *ip_address = ip_addr;
 254
 255     return 4 - invalid;
 256 }
 257
 258
 259 static BOOL IPADDRESS_SetRange (IPADDRESS_INFO *infoPtr, int index, WORD range)
 260 {
 261     TRACE("\n");
 262
 263     if ( (index < 0) || (index > 3) ) return FALSE;
 264
 265     infoPtr->Part[index].LowerLimit = range & 0xFF;
 266     infoPtr->Part[index].UpperLimit = (range >> 8)  & 0xFF;
 267
 268     return TRUE;
 269 }
 270
 271
 272 static void IPADDRESS_ClearAddress (IPADDRESS_INFO *infoPtr)
 273 {
 274     WCHAR nil[1] = { 0 };
 275     int i;
 276
 277     TRACE("\n");
 278
 279     for (i = 0; i < 4; i++)
 280         SetWindowTextW (infoPtr->Part[i].EditHwnd, nil);
 281 }
 282
 283
 284 static LRESULT IPADDRESS_SetAddress (IPADDRESS_INFO *infoPtr, DWORD ip_address)
 285 {
 286     WCHAR buf[20], fmt[] = { '%', 'd', 0 };
 287     int i;
 288
 289     TRACE("\n");
 290
 291     for (i = 3; i >= 0; i--) {
 292         IPPART_INFO* part = &infoPtr->Part[i];
 293         int value = ip_address & 0xff;
 294         if ( (value >= part->LowerLimit) && (value <= part->UpperLimit) ) {
 295             wsprintfW (buf, fmt, value);
 296             SetWindowTextW (part->EditHwnd, buf);
 297             IPADDRESS_Notify (infoPtr, EN_CHANGE);
 298         }
 299         ip_address >>= 8;
 300     }
 301
 302     return TRUE;
 303 }
 304
 305
 306 static void IPADDRESS_SetFocusToField (IPADDRESS_INFO *infoPtr, INT index)
 307 {
 308     TRACE("(index=%d)\n", index);
 309
 310     if (index > 3) {
 311         for (index = 0; index < 4; index++)
 312             if (!GetWindowTextLengthW(infoPtr->Part[index].EditHwnd)) break;
 313     }
 314     if (index < 9 || index > 3) index = 0;
 315
 316     SetFocus (infoPtr->Part[index].EditHwnd);
 317 }
 318
 319
 320 static BOOL IPADDRESS_ConstrainField (IPADDRESS_INFO *infoPtr, int currentfield)
 321 {
 322     IPPART_INFO *part = &infoPtr->Part[currentfield];
 323     WCHAR field[10], fmt[] = { '%', 'd', 0 };
 324     int curValue, newValue;
 325
 326     TRACE("(currentfield=%d)\n", currentfield);
 327
 328     if (currentfield < 0 || currentfield > 3) return FALSE;
 329
 330     if (!GetWindowTextW (part->EditHwnd, field, 4)) return FALSE;
 331
 332     curValue = atoiW(field);
 333     TRACE("  curValue=%d\n", curValue);
 334
 335     newValue = IPADDRESS_IPNotify(infoPtr, currentfield, curValue);
 336     TRACE("  newValue=%d\n", newValue);
 337
 338     if (newValue < part->LowerLimit) newValue = part->LowerLimit;
 339     if (newValue > part->UpperLimit) newValue = part->UpperLimit;
 340
 341     if (newValue == curValue) return FALSE;
 342
 343     wsprintfW (field, fmt, newValue);
 344     TRACE("  field='%s'\n", debugstr_w(field));
 345     return SetWindowTextW (part->EditHwnd, field);
 346 }
 347
 348
 349 static BOOL IPADDRESS_GotoNextField (IPADDRESS_INFO *infoPtr, int cur, int sel)
 350 {
 351     TRACE("\n");
 352
 353     if(cur >= -1 && cur < 4) {
 354         IPADDRESS_ConstrainField(infoPtr, cur);
 355
 356         if(cur < 3) {
 357             IPPART_INFO *next = &infoPtr->Part[cur + 1];
 358             int start = 0, end = 0;
 359             SetFocus (next->EditHwnd);
 360             if (sel != POS_DEFAULT) {
 361                 if (sel == POS_RIGHT)
 362                     start = end = GetWindowTextLengthW(next->EditHwnd);
 363                 else if (sel == POS_SELALL)
 364                     end = -1;
 365                 SendMessageW(next->EditHwnd, EM_SETSEL, start, end);
 366             }
 367             return TRUE;
 368         }
 369
 370     }
 371     return FALSE;
 372 }
 373
 374
 375 /*
 376  * period: move and select the text in the next field to the right if
 377  *         the current field is not empty(l!=0), we are not in the
 378  *         left most position, and nothing is selected(startsel==endsel)
 379  *
 380  * spacebar: same behavior as period
 381  *
 382  * alpha characters: completely ignored
 383  *
 384  * digits: accepted when field text length < 2 ignored otherwise.
 385  *         when 3 numbers have been entered into the field the value
 386  *         of the field is checked, if the field value exceeds the
 387  *         maximum value and is changed the field remains the current
 388  *         field, otherwise focus moves to the field to the right
 389  *
 390  * tab: change focus from the current ipaddress control to the next
 391  *      control in the tab order
 392  *
 393  * right arrow: move to the field on the right to the left most
 394  *              position in that field if no text is selected,
 395  *              we are in the right most position in the field,
 396  *              we are not in the right most field
 397  *
 398  * left arrow: move to the field on the left to the right most
 399  *             position in that field if no text is selected,
 400  *             we are in the left most position in the current field
 401  *             and we are not in the left most field
 402  *
 403  * backspace: delete the character to the left of the cursor position,
 404  *            if none are present move to the field on the left if
 405  *            we are not in the left most field and delete the right
 406  *            most digit in that field while keeping the cursor
 407  *            on the right side of the field
 408  */
 409 LRESULT CALLBACK
 410 IPADDRESS_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 411 {
 412     HWND Self = (HWND)GetPropA (hwnd, IP_SUBCLASS_PROP);
 413     IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (Self);
 414     CHAR c = (CHAR)wParam;
 415     INT index, len = 0, startsel, endsel;
 416     IPPART_INFO *part;
 417
 418     TRACE("(hwnd=%p msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 419
 420     if ( (index = IPADDRESS_GetPartIndex(infoPtr, hwnd)) < 0) return 0;
 421     part = &infoPtr->Part[index];
 422
 423     if (uMsg == WM_CHAR || uMsg == WM_KEYDOWN) {
 424         len = GetWindowTextLengthW (hwnd);
 425         SendMessageW(hwnd, EM_GETSEL, (WPARAM)&startsel, (LPARAM)&endsel);
 426     }
 427     switch (uMsg) {
 428         case WM_CHAR:
 429             if(isdigit(c)) {
 430                 if(len == 2 && startsel==endsel && endsel==len) {
 431                     /* process the digit press before we check the field */
 432                     int return_val = CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 433
 434                     /* if the field value was changed stay at the current field */
 435                     if(!IPADDRESS_ConstrainField(infoPtr, index))
 436                         IPADDRESS_GotoNextField (infoPtr, index, POS_DEFAULT);
 437
 438                     return return_val;
 439                 } else if (len == 3 && startsel==endsel && endsel==len)
 440                     IPADDRESS_GotoNextField (infoPtr, index, POS_SELALL);
 441                 else if (len < 3) break;
 442             } else if(c == '.' || c == ' ') {
 443                 if(len && startsel==endsel && startsel != 0) {
 444                     IPADDRESS_GotoNextField(infoPtr, index, POS_SELALL);
 445                 }
 446             } else if (c == VK_BACK) break;
 447             return 0;
 448
 449         case WM_KEYDOWN:
 450             switch(c) {
 451                 case VK_RIGHT:
 452                     if(startsel==endsel && startsel==len) {
 453                         IPADDRESS_GotoNextField(infoPtr, index, POS_LEFT);
 454                         return 0;
 455                     }
 456                     break;
 457                 case VK_LEFT:
 458                     if(startsel==0 && startsel==endsel && index > 0) {
 459                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 460                         return 0;
 461                     }
 462                     break;
 463                 case VK_BACK:
 464                     if(startsel==endsel && startsel==0 && index > 0) {
 465                         IPPART_INFO *prev = &infoPtr->Part[index-1];
 466                         WCHAR val[10];
 467
 468                         if(GetWindowTextW(prev->EditHwnd, val, 5)) {
 469                             val[lstrlenW(val) - 1] = 0;
 470                             SetWindowTextW(prev->EditHwnd, val);
 471                         }
 472
 473                         IPADDRESS_GotoNextField(infoPtr, index - 2, POS_RIGHT);
 474                         return 0;
 475                     }
 476                     break;
 477             }
 478             break;
 479         case WM_KILLFOCUS:
 480             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 481                 IPADDRESS_Notify(infoPtr, EN_KILLFOCUS);
 482             break;
 483         case WM_SETFOCUS:
 484             if (IPADDRESS_GetPartIndex(infoPtr, (HWND)wParam) < 0)
 485                 IPADDRESS_Notify(infoPtr, EN_SETFOCUS);
 486             break;
 487     }
 488     return CallWindowProcW (part->OrigProc, hwnd, uMsg, wParam, lParam);
 489 }
 490
 491
 492 static LRESULT WINAPI
 493 IPADDRESS_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 494 {
 495     IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
 496
 497     TRACE("(hwnd=%p msg=0x%x wparam=0x%x lparam=0x%lx)\n", hwnd, uMsg, wParam, lParam);
 498
 499     if (!infoPtr && (uMsg != WM_CREATE))
 500         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 501
 502     switch (uMsg)
 503     {
 504         case WM_CREATE:
 505             return IPADDRESS_Create (hwnd);
 506
 507         case WM_DESTROY:
 508             return IPADDRESS_Destroy (infoPtr);
 509
 510         case WM_PAINT:
 511             return IPADDRESS_Paint (infoPtr, (HDC)wParam);
 512
 513         case WM_COMMAND:
 514             switch(wParam >> 16) {
 515                 case EN_CHANGE:
 516                     IPADDRESS_Notify(infoPtr, EN_CHANGE);
 517                     break;
 518                 case EN_KILLFOCUS:
 519                     IPADDRESS_ConstrainField(infoPtr, IPADDRESS_GetPartIndex(infoPtr, (HWND)lParam));
 520                     break;
 521             }
 522             break;
 523
 524         case IPM_CLEARADDRESS:
 525             IPADDRESS_ClearAddress (infoPtr);
 526             break;
 527
 528         case IPM_SETADDRESS:
 529             return IPADDRESS_SetAddress (infoPtr, (DWORD)lParam);
 530
 531         case IPM_GETADDRESS:
 532             return IPADDRESS_GetAddress (infoPtr, (LPDWORD)lParam);
 533
 534         case IPM_SETRANGE:
 535             return IPADDRESS_SetRange (infoPtr, (int)wParam, (WORD)lParam);
 536
 537         case IPM_SETFOCUS:
 538             IPADDRESS_SetFocusToField (infoPtr, (int)wParam);
 539             break;
 540
 541         case IPM_ISBLANK:
 542             return IPADDRESS_IsBlank (infoPtr);
 543
 544         default:
 545             if ((uMsg >= WM_USER) && (uMsg < WM_APP))
 546                 ERR("unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
 547             return DefWindowProcW (hwnd, uMsg, wParam, lParam);
 548     }
 549     return 0;
 550 }
 551
 552
 553 void IPADDRESS_Register (void)
 554 {
 555     WNDCLASSW wndClass;
 556
 557     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
 558     wndClass.style         = CS_GLOBALCLASS;
 559     wndClass.lpfnWndProc   = (WNDPROC)IPADDRESS_WindowProc;
 560     wndClass.cbClsExtra    = 0;
 561     wndClass.cbWndExtra    = sizeof(IPADDRESS_INFO *);
 562     wndClass.hCursor       = LoadCursorW (0, IDC_IBEAMW);
 563     wndClass.hbrBackground = GetStockObject(WHITE_BRUSH);
 564     wndClass.lpszClassName = WC_IPADDRESSW;
 565
 566     RegisterClassW (&wndClass);
 567 }
 568
 569
 570 void IPADDRESS_Unregister (void)
 571 {
 572     UnregisterClassW (WC_IPADDRESSW, NULL);
 573 }