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