dlls/user32/combo.c

   1 /*
   2  * Combo controls
   3  *
   4  * Copyright 1997 Alex Korobka
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTES
  21  *
  22  * This code was audited for completeness against the documented features
  23  * of Comctl32.dll version 6.0 on Oct. 4, 2004, by Dimitrie O. Paun.
  24  *
  25  * Unless otherwise noted, we believe this code to be complete, as per
  26  * the specification mentioned above.
  27  * If you discover missing features, or bugs, please note them below.
  28  *
  29  * TODO:
  30  *   - ComboBox_[GS]etMinVisible()
  31  *   - CB_GETMINVISIBLE, CB_SETMINVISIBLE
  32  *   - CB_SETTOPINDEX
  33  */
  34
  35 #include <stdarg.h>
  36 #include <string.h>
  37
  38 #define OEMRESOURCE
  39
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "wingdi.h"
  43 #include "winuser.h"
  44 #include "wine/unicode.h"
  45 #include "user_private.h"
  46 #include "win.h"
  47 #include "controls.h"
  48 #include "winternl.h"
  49 #include "wine/debug.h"
  50
  51 WINE_DEFAULT_DEBUG_CHANNEL(combo);
  52
  53   /* bits in the dwKeyData */
  54 #define KEYDATA_ALT             0x2000
  55 #define KEYDATA_PREVSTATE       0x4000
  56
  57 /*
  58  * Additional combo box definitions
  59  */
  60
  61 #define CB_NOTIFY( lphc, code ) \
  62     (SendMessageW((lphc)->owner, WM_COMMAND, \
  63                   MAKEWPARAM(GetWindowLongPtrW((lphc)->self,GWLP_ID), (code)), (LPARAM)(lphc)->self))
  64
  65 #define CB_DISABLED( lphc )   (!IsWindowEnabled((lphc)->self))
  66 #define CB_OWNERDRAWN( lphc ) ((lphc)->dwStyle & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE))
  67 #define CB_HASSTRINGS( lphc ) ((lphc)->dwStyle & CBS_HASSTRINGS)
  68 #define CB_HWND( lphc )       ((lphc)->self)
  69 #define CB_GETTYPE( lphc )    ((lphc)->dwStyle & (CBS_DROPDOWNLIST))
  70
  71 #define ISWIN31 (LOWORD(GetVersion()) == 0x0a03)
  72
  73 /*
  74  * Drawing globals
  75  */
  76 static HBITMAP  hComboBmp = 0;
  77 static UINT     CBitHeight, CBitWidth;
  78
  79 /*
  80  * Look and feel dependent "constants"
  81  */
  82
  83 #define COMBO_YBORDERGAP         5
  84 #define COMBO_XBORDERSIZE()      2
  85 #define COMBO_YBORDERSIZE()      2
  86 #define COMBO_EDITBUTTONSPACE()  0
  87 #define EDIT_CONTROL_PADDING()   1
  88
  89 /*********************************************************************
  90  * combo class descriptor
  91  */
  92 static const WCHAR comboboxW[] = {'C','o','m','b','o','B','o','x',0};
  93 const struct builtin_class_descr COMBO_builtin_class =
  94 {
  95     comboboxW,            /* name */
  96     CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW, /* style  */
  97     WINPROC_COMBO,        /* proc */
  98     sizeof(HEADCOMBO *),  /* extra */
  99     IDC_ARROW,            /* cursor */
 100     0                     /* brush */
 101 };
 102
 103
 104 /***********************************************************************
 105  *           COMBO_Init
 106  *
 107  * Load combo button bitmap.
 108  */
 109 static BOOL COMBO_Init(void)
 110 {
 111   HDC           hDC;
 112
 113   if( hComboBmp ) return TRUE;
 114   if( (hDC = CreateCompatibleDC(0)) )
 115   {
 116     BOOL        bRet = FALSE;
 117     if( (hComboBmp = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_COMBO))) )
 118     {
 119       BITMAP      bm;
 120       HBITMAP     hPrevB;
 121       RECT        r;
 122
 123       GetObjectW( hComboBmp, sizeof(bm), &bm );
 124       CBitHeight = bm.bmHeight;
 125       CBitWidth  = bm.bmWidth;
 126
 127       TRACE("combo bitmap [%i,%i]\n", CBitWidth, CBitHeight );
 128
 129       hPrevB = SelectObject( hDC, hComboBmp);
 130       SetRect( &r, 0, 0, CBitWidth, CBitHeight );
 131       InvertRect( hDC, &r );
 132       SelectObject( hDC, hPrevB );
 133       bRet = TRUE;
 134     }
 135     DeleteDC( hDC );
 136     return bRet;
 137   }
 138   return FALSE;
 139 }
 140
 141 /***********************************************************************
 142  *           COMBO_NCCreate
 143  */
 144 static LRESULT COMBO_NCCreate(HWND hwnd, LONG style)
 145 {
 146     LPHEADCOMBO lphc;
 147
 148     if (COMBO_Init() && (lphc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HEADCOMBO))) )
 149     {
 150         lphc->self = hwnd;
 151         SetWindowLongPtrW( hwnd, 0, (LONG_PTR)lphc );
 152
 153        /* some braindead apps do try to use scrollbar/border flags */
 154
 155         lphc->dwStyle = style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL);
 156         SetWindowLongW( hwnd, GWL_STYLE, style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL) );
 157
 158         /*
 159          * We also have to remove the client edge style to make sure
 160          * we don't end-up with a non client area.
 161          */
 162         SetWindowLongW( hwnd, GWL_EXSTYLE,
 163                         GetWindowLongW( hwnd, GWL_EXSTYLE ) & ~WS_EX_CLIENTEDGE );
 164
 165         if( !(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) )
 166               lphc->dwStyle |= CBS_HASSTRINGS;
 167         if( !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) )
 168               lphc->wState |= CBF_NOTIFY;
 169
 170         TRACE("[%p], style = %08x\n", lphc, lphc->dwStyle );
 171         return TRUE;
 172     }
 173     return FALSE;
 174 }
 175
 176 /***********************************************************************
 177  *           COMBO_NCDestroy
 178  */
 179 static LRESULT COMBO_NCDestroy( LPHEADCOMBO lphc )
 180 {
 181
 182    if( lphc )
 183    {
 184        TRACE("[%p]: freeing storage\n", lphc->self);
 185
 186        if( (CB_GETTYPE(lphc) != CBS_SIMPLE) && lphc->hWndLBox )
 187            DestroyWindow( lphc->hWndLBox );
 188
 189        SetWindowLongPtrW( lphc->self, 0, 0 );
 190        HeapFree( GetProcessHeap(), 0, lphc );
 191    }
 192    return 0;
 193 }
 194
 195 /***********************************************************************
 196  *           CBGetTextAreaHeight
 197  *
 198  * This method will calculate the height of the text area of the
 199  * combobox.
 200  * The height of the text area is set in two ways.
 201  * It can be set explicitly through a combobox message or through a
 202  * WM_MEASUREITEM callback.
 203  * If this is not the case, the height is set to font height + 4px
 204  * This height was determined through experimentation.
 205  * CBCalcPlacement will add 2*COMBO_YBORDERSIZE pixels for the border
 206  */
 207 static INT CBGetTextAreaHeight(
 208   HWND        hwnd,
 209   LPHEADCOMBO lphc)
 210 {
 211   INT iTextItemHeight;
 212
 213   if( lphc->editHeight ) /* explicitly set height */
 214   {
 215     iTextItemHeight = lphc->editHeight;
 216   }
 217   else
 218   {
 219     TEXTMETRICW tm;
 220     HDC         hDC       = GetDC(hwnd);
 221     HFONT       hPrevFont = 0;
 222     INT         baseUnitY;
 223
 224     if (lphc->hFont)
 225       hPrevFont = SelectObject( hDC, lphc->hFont );
 226
 227     GetTextMetricsW(hDC, &tm);
 228
 229     baseUnitY = tm.tmHeight;
 230
 231     if( hPrevFont )
 232       SelectObject( hDC, hPrevFont );
 233
 234     ReleaseDC(hwnd, hDC);
 235
 236     iTextItemHeight = baseUnitY + 4;
 237   }
 238
 239   /*
 240    * Check the ownerdraw case if we haven't asked the parent the size
 241    * of the item yet.
 242    */
 243   if ( CB_OWNERDRAWN(lphc) &&
 244        (lphc->wState & CBF_MEASUREITEM) )
 245   {
 246     MEASUREITEMSTRUCT measureItem;
 247     RECT              clientRect;
 248     INT               originalItemHeight = iTextItemHeight;
 249     UINT id = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
 250
 251     /*
 252      * We use the client rect for the width of the item.
 253      */
 254     GetClientRect(hwnd, &clientRect);
 255
 256     lphc->wState &= ~CBF_MEASUREITEM;
 257
 258     /*
 259      * Send a first one to measure the size of the text area
 260      */
 261     measureItem.CtlType    = ODT_COMBOBOX;
 262     measureItem.CtlID      = id;
 263     measureItem.itemID     = -1;
 264     measureItem.itemWidth  = clientRect.right;
 265     measureItem.itemHeight = iTextItemHeight - 6; /* ownerdrawn cb is taller */
 266     measureItem.itemData   = 0;
 267     SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
 268     iTextItemHeight = 6 + measureItem.itemHeight;
 269
 270     /*
 271      * Send a second one in the case of a fixed ownerdraw list to calculate the
 272      * size of the list items. (we basically do this on behalf of the listbox)
 273      */
 274     if (lphc->dwStyle & CBS_OWNERDRAWFIXED)
 275     {
 276       measureItem.CtlType    = ODT_COMBOBOX;
 277       measureItem.CtlID      = id;
 278       measureItem.itemID     = 0;
 279       measureItem.itemWidth  = clientRect.right;
 280       measureItem.itemHeight = originalItemHeight;
 281       measureItem.itemData   = 0;
 282       SendMessageW(lphc->owner, WM_MEASUREITEM, id, (LPARAM)&measureItem);
 283       lphc->fixedOwnerDrawHeight = measureItem.itemHeight;
 284     }
 285
 286     /*
 287      * Keep the size for the next time
 288      */
 289     lphc->editHeight = iTextItemHeight;
 290   }
 291
 292   return iTextItemHeight;
 293 }
 294
 295 /***********************************************************************
 296  *           CBForceDummyResize
 297  *
 298  * The dummy resize is used for listboxes that have a popup to trigger
 299  * a re-arranging of the contents of the combobox and the recalculation
 300  * of the size of the "real" control window.
 301  */
 302 static void CBForceDummyResize(
 303   LPHEADCOMBO lphc)
 304 {
 305   RECT windowRect;
 306   int newComboHeight;
 307
 308   newComboHeight = CBGetTextAreaHeight(lphc->self,lphc) + 2*COMBO_YBORDERSIZE();
 309
 310   GetWindowRect(lphc->self, &windowRect);
 311
 312   /*
 313    * We have to be careful, resizing a combobox also has the meaning that the
 314    * dropped rect will be resized. In this case, we want to trigger a resize
 315    * to recalculate layout but we don't want to change the dropped rectangle
 316    * So, we pass the height of text area of control as the height.
 317    * this will cancel-out in the processing of the WM_WINDOWPOSCHANGING
 318    * message.
 319    */
 320   SetWindowPos( lphc->self,
 321                 NULL,
 322                 0, 0,
 323                 windowRect.right  - windowRect.left,
 324                 newComboHeight,
 325                 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
 326 }
 327
 328 /***********************************************************************
 329  *           CBCalcPlacement
 330  *
 331  * Set up component coordinates given valid lphc->RectCombo.
 332  */
 333 static void CBCalcPlacement(
 334   HWND        hwnd,
 335   LPHEADCOMBO lphc,
 336   LPRECT      lprEdit,
 337   LPRECT      lprButton,
 338   LPRECT      lprLB)
 339 {
 340   /*
 341    * Again, start with the client rectangle.
 342    */
 343   GetClientRect(hwnd, lprEdit);
 344
 345   /*
 346    * Remove the borders
 347    */
 348   InflateRect(lprEdit, -COMBO_XBORDERSIZE(), -COMBO_YBORDERSIZE());
 349
 350   /*
 351    * Chop off the bottom part to fit with the height of the text area.
 352    */
 353   lprEdit->bottom = lprEdit->top + CBGetTextAreaHeight(hwnd, lphc);
 354
 355   /*
 356    * The button starts the same vertical position as the text area.
 357    */
 358   CopyRect(lprButton, lprEdit);
 359
 360   /*
 361    * If the combobox is "simple" there is no button.
 362    */
 363   if( CB_GETTYPE(lphc) == CBS_SIMPLE )
 364     lprButton->left = lprButton->right = lprButton->bottom = 0;
 365   else
 366   {
 367     /*
 368      * Let's assume the combobox button is the same width as the
 369      * scrollbar button.
 370      * size the button horizontally and cut-off the text area.
 371      */
 372     lprButton->left = lprButton->right - GetSystemMetrics(SM_CXVSCROLL);
 373     lprEdit->right  = lprButton->left;
 374   }
 375
 376   /*
 377    * In the case of a dropdown, there is an additional spacing between the
 378    * text area and the button.
 379    */
 380   if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
 381   {
 382     lprEdit->right -= COMBO_EDITBUTTONSPACE();
 383   }
 384
 385   /*
 386    * If we have an edit control, we space it away from the borders slightly.
 387    */
 388   if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
 389   {
 390     InflateRect(lprEdit, -EDIT_CONTROL_PADDING(), -EDIT_CONTROL_PADDING());
 391   }
 392
 393   /*
 394    * Adjust the size of the listbox popup.
 395    */
 396   if( CB_GETTYPE(lphc) == CBS_SIMPLE )
 397   {
 398     /*
 399      * Use the client rectangle to initialize the listbox rectangle
 400      */
 401     GetClientRect(hwnd, lprLB);
 402
 403     /*
 404      * Then, chop-off the top part.
 405      */
 406     lprLB->top = lprEdit->bottom + COMBO_YBORDERSIZE();
 407   }
 408   else
 409   {
 410     /*
 411      * Make sure the dropped width is as large as the combobox itself.
 412      */
 413     if (lphc->droppedWidth < (lprButton->right + COMBO_XBORDERSIZE()))
 414     {
 415       lprLB->right  = lprLB->left + (lprButton->right + COMBO_XBORDERSIZE());
 416
 417       /*
 418        * In the case of a dropdown, the popup listbox is offset to the right.
 419        * so, we want to make sure it's flush with the right side of the
 420        * combobox
 421        */
 422       if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
 423         lprLB->right -= COMBO_EDITBUTTONSPACE();
 424     }
 425     else
 426        lprLB->right = lprLB->left + lphc->droppedWidth;
 427   }
 428
 429   /* don't allow negative window width */
 430   if (lprEdit->right < lprEdit->left)
 431     lprEdit->right = lprEdit->left;
 432
 433   TRACE("\ttext\t= (%s)\n", wine_dbgstr_rect(lprEdit));
 434
 435   TRACE("\tbutton\t= (%s)\n", wine_dbgstr_rect(lprButton));
 436
 437   TRACE("\tlbox\t= (%s)\n", wine_dbgstr_rect(lprLB));
 438 }
 439
 440 /***********************************************************************
 441  *           CBGetDroppedControlRect
 442  */
 443 static void CBGetDroppedControlRect( LPHEADCOMBO lphc, LPRECT lpRect)
 444 {
 445     /* In windows, CB_GETDROPPEDCONTROLRECT returns the upper left corner
 446      of the combo box and the lower right corner of the listbox */
 447
 448     GetWindowRect(lphc->self, lpRect);
 449
 450     lpRect->right =  lpRect->left + lphc->droppedRect.right - lphc->droppedRect.left;
 451     lpRect->bottom = lpRect->top + lphc->droppedRect.bottom - lphc->droppedRect.top;
 452
 453 }
 454
 455 /***********************************************************************
 456  *           COMBO_Create
 457  */
 458 static LRESULT COMBO_Create( HWND hwnd, LPHEADCOMBO lphc, HWND hwndParent, LONG style,
 459                              BOOL unicode )
 460 {
 461   static const WCHAR clbName[] = {'C','o','m','b','o','L','B','o','x',0};
 462   static const WCHAR editName[] = {'E','d','i','t',0};
 463
 464   if( !CB_GETTYPE(lphc) ) lphc->dwStyle |= CBS_SIMPLE;
 465   if( CB_GETTYPE(lphc) != CBS_DROPDOWNLIST ) lphc->wState |= CBF_EDIT;
 466
 467   lphc->owner = hwndParent;
 468
 469   /*
 470    * The item height and dropped width are not set when the control
 471    * is created.
 472    */
 473   lphc->droppedWidth = lphc->editHeight = 0;
 474
 475   /*
 476    * The first time we go through, we want to measure the ownerdraw item
 477    */
 478   lphc->wState |= CBF_MEASUREITEM;
 479
 480   /* M$ IE 3.01 actually creates (and rapidly destroys) an ownerless combobox */
 481
 482   if( lphc->owner || !(style & WS_VISIBLE) )
 483   {
 484       UINT lbeStyle   = 0;
 485       UINT lbeExStyle = 0;
 486
 487       /*
 488        * Initialize the dropped rect to the size of the client area of the
 489        * control and then, force all the areas of the combobox to be
 490        * recalculated.
 491        */
 492       GetClientRect( hwnd, &lphc->droppedRect );
 493       CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
 494
 495       /*
 496        * Adjust the position of the popup listbox if it's necessary
 497        */
 498       if ( CB_GETTYPE(lphc) != CBS_SIMPLE )
 499       {
 500         lphc->droppedRect.top   = lphc->textRect.bottom + COMBO_YBORDERSIZE();
 501
 502         /*
 503          * If it's a dropdown, the listbox is offset
 504          */
 505         if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
 506           lphc->droppedRect.left += COMBO_EDITBUTTONSPACE();
 507
 508         if (lphc->droppedRect.bottom < lphc->droppedRect.top)
 509             lphc->droppedRect.bottom = lphc->droppedRect.top;
 510         if (lphc->droppedRect.right < lphc->droppedRect.left)
 511             lphc->droppedRect.right = lphc->droppedRect.left;
 512         MapWindowPoints( hwnd, 0, (LPPOINT)&lphc->droppedRect, 2 );
 513       }
 514
 515       /* create listbox popup */
 516
 517       lbeStyle = (LBS_NOTIFY | LBS_COMBOBOX | WS_BORDER | WS_CLIPSIBLINGS | WS_CHILD) |
 518                  (style & (WS_VSCROLL | CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE));
 519
 520       if( lphc->dwStyle & CBS_SORT )
 521         lbeStyle |= LBS_SORT;
 522       if( lphc->dwStyle & CBS_HASSTRINGS )
 523         lbeStyle |= LBS_HASSTRINGS;
 524       if( lphc->dwStyle & CBS_NOINTEGRALHEIGHT )
 525         lbeStyle |= LBS_NOINTEGRALHEIGHT;
 526       if( lphc->dwStyle & CBS_DISABLENOSCROLL )
 527         lbeStyle |= LBS_DISABLENOSCROLL;
 528
 529       if( CB_GETTYPE(lphc) == CBS_SIMPLE )      /* child listbox */
 530       {
 531         lbeStyle |= WS_VISIBLE;
 532
 533         /*
 534          * In win 95 look n feel, the listbox in the simple combobox has
 535          * the WS_EXCLIENTEDGE style instead of the WS_BORDER style.
 536          */
 537         lbeStyle   &= ~WS_BORDER;
 538         lbeExStyle |= WS_EX_CLIENTEDGE;
 539       }
 540       else
 541       {
 542         lbeExStyle |= (WS_EX_TOPMOST | WS_EX_TOOLWINDOW);
 543       }
 544
 545       if (unicode)
 546           lphc->hWndLBox = CreateWindowExW(lbeExStyle, clbName, NULL, lbeStyle,
 547                                            lphc->droppedRect.left,
 548                                            lphc->droppedRect.top,
 549                                            lphc->droppedRect.right - lphc->droppedRect.left,
 550                                            lphc->droppedRect.bottom - lphc->droppedRect.top,
 551                                            hwnd, (HMENU)ID_CB_LISTBOX,
 552                                            (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), lphc );
 553       else
 554           lphc->hWndLBox = CreateWindowExA(lbeExStyle, "ComboLBox", NULL, lbeStyle,
 555                                            lphc->droppedRect.left,
 556                                            lphc->droppedRect.top,
 557                                            lphc->droppedRect.right - lphc->droppedRect.left,
 558                                            lphc->droppedRect.bottom - lphc->droppedRect.top,
 559                                            hwnd, (HMENU)ID_CB_LISTBOX,
 560                                            (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), lphc );
 561
 562       if( lphc->hWndLBox )
 563       {
 564           BOOL  bEdit = TRUE;
 565           lbeStyle = WS_CHILD | WS_VISIBLE | ES_NOHIDESEL | ES_LEFT | ES_COMBO;
 566
 567           if( lphc->wState & CBF_EDIT )
 568           {
 569               if( lphc->dwStyle & CBS_OEMCONVERT )
 570                   lbeStyle |= ES_OEMCONVERT;
 571               if( lphc->dwStyle & CBS_AUTOHSCROLL )
 572                   lbeStyle |= ES_AUTOHSCROLL;
 573               if( lphc->dwStyle & CBS_LOWERCASE )
 574                   lbeStyle |= ES_LOWERCASE;
 575               else if( lphc->dwStyle & CBS_UPPERCASE )
 576                   lbeStyle |= ES_UPPERCASE;
 577
 578               if (!IsWindowEnabled(hwnd)) lbeStyle |= WS_DISABLED;
 579
 580               if (unicode)
 581                   lphc->hWndEdit = CreateWindowExW(0, editName, NULL, lbeStyle,
 582                                                    lphc->textRect.left, lphc->textRect.top,
 583                                                    lphc->textRect.right - lphc->textRect.left,
 584                                                    lphc->textRect.bottom - lphc->textRect.top,
 585                                                    hwnd, (HMENU)ID_CB_EDIT,
 586                                                    (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), NULL );
 587               else
 588                   lphc->hWndEdit = CreateWindowExA(0, "Edit", NULL, lbeStyle,
 589                                                    lphc->textRect.left, lphc->textRect.top,
 590                                                    lphc->textRect.right - lphc->textRect.left,
 591                                                    lphc->textRect.bottom - lphc->textRect.top,
 592                                                    hwnd, (HMENU)ID_CB_EDIT,
 593                                                    (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE ), NULL );
 594
 595               if( !lphc->hWndEdit )
 596                 bEdit = FALSE;
 597           }
 598
 599           if( bEdit )
 600           {
 601             if( CB_GETTYPE(lphc) != CBS_SIMPLE )
 602             {
 603               /* Now do the trick with parent */
 604               SetParent(lphc->hWndLBox, HWND_DESKTOP);
 605               /*
 606                * If the combo is a dropdown, we must resize the control
 607                * to fit only the text area and button. To do this,
 608                * we send a dummy resize and the WM_WINDOWPOSCHANGING message
 609                * will take care of setting the height for us.
 610                */
 611               CBForceDummyResize(lphc);
 612             }
 613
 614             TRACE("init done\n");
 615             return 0;
 616           }
 617           ERR("edit control failure.\n");
 618       } else ERR("listbox failure.\n");
 619   } else ERR("no owner for visible combo.\n");
 620
 621   /* CreateWindow() will send WM_NCDESTROY to cleanup */
 622
 623   return -1;
 624 }
 625
 626 /***********************************************************************
 627  *           CBPaintButton
 628  *
 629  * Paint combo button (normal, pressed, and disabled states).
 630  */
 631 static void CBPaintButton( LPHEADCOMBO lphc, HDC hdc, RECT rectButton)
 632 {
 633     UINT buttonState = DFCS_SCROLLCOMBOBOX;
 634
 635     if( lphc->wState & CBF_NOREDRAW )
 636       return;
 637
 638
 639     if (lphc->wState & CBF_BUTTONDOWN)
 640         buttonState |= DFCS_PUSHED;
 641
 642     if (CB_DISABLED(lphc))
 643         buttonState |= DFCS_INACTIVE;
 644
 645     DrawFrameControl(hdc, &rectButton, DFC_SCROLL, buttonState);
 646 }
 647
 648 /***********************************************************************
 649  *           COMBO_PrepareColors
 650  *
 651  * This method will sent the appropriate WM_CTLCOLOR message to
 652  * prepare and setup the colors for the combo's DC.
 653  *
 654  * It also returns the brush to use for the background.
 655  */
 656 static HBRUSH COMBO_PrepareColors(
 657         LPHEADCOMBO lphc,
 658         HDC         hDC)
 659 {
 660     HBRUSH  hBkgBrush;
 661
 662     /*
 663      * Get the background brush for this control.
 664      */
 665     if (CB_DISABLED(lphc))
 666     {
 667         hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLORSTATIC,
 668                 (WPARAM)hDC, (LPARAM)lphc->self );
 669
 670         /*
 671          * We have to change the text color since WM_CTLCOLORSTATIC will
 672          * set it to the "enabled" color. This is the same behavior as the
 673          * edit control
 674          */
 675         SetTextColor(hDC, GetSysColor(COLOR_GRAYTEXT));
 676     }
 677     else
 678     {
 679         /* FIXME: In which cases WM_CTLCOLORLISTBOX should be sent? */
 680         hBkgBrush = (HBRUSH)SendMessageW(lphc->owner, WM_CTLCOLOREDIT,
 681                 (WPARAM)hDC, (LPARAM)lphc->self );
 682     }
 683
 684     /*
 685      * Catch errors.
 686      */
 687     if( !hBkgBrush )
 688         hBkgBrush = GetSysColorBrush(COLOR_WINDOW);
 689
 690     return hBkgBrush;
 691 }
 692
 693 /***********************************************************************
 694  *           CBPaintText
 695  *
 696  * Paint CBS_DROPDOWNLIST text field / update edit control contents.
 697  */
 698 static void CBPaintText(
 699   LPHEADCOMBO lphc,
 700   HDC         hdc_paint)
 701 {
 702    RECT rectEdit = lphc->textRect;
 703    INT  id, size = 0;
 704    LPWSTR pText = NULL;
 705
 706    if( lphc->wState & CBF_NOREDRAW ) return;
 707
 708    TRACE("\n");
 709
 710    /* follow Windows combobox that sends a bunch of text
 711     * inquiries to its listbox while processing WM_PAINT. */
 712
 713    if( (id = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0) ) != LB_ERR )
 714    {
 715         size = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, id, 0);
 716         if (size == LB_ERR)
 717           FIXME("LB_ERR probably not handled yet\n");
 718         if( (pText = HeapAlloc( GetProcessHeap(), 0, (size + 1) * sizeof(WCHAR))) )
 719         {
 720             /* size from LB_GETTEXTLEN may be too large, from LB_GETTEXT is accurate */
 721            size=SendMessageW(lphc->hWndLBox, LB_GETTEXT, id, (LPARAM)pText);
 722             pText[size] = '\0'; /* just in case */
 723         } else return;
 724    }
 725    else
 726        if( !CB_OWNERDRAWN(lphc) )
 727            return;
 728
 729    if( lphc->wState & CBF_EDIT )
 730    {
 731         static const WCHAR empty_stringW[] = { 0 };
 732         if( CB_HASSTRINGS(lphc) ) SetWindowTextW( lphc->hWndEdit, pText ? pText : empty_stringW );
 733         if( lphc->wState & CBF_FOCUSED )
 734            SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
 735    }
 736    else /* paint text field ourselves */
 737    {
 738      HDC hdc = hdc_paint ? hdc_paint : GetDC(lphc->self);
 739      UINT itemState = ODS_COMBOBOXEDIT;
 740      HFONT hPrevFont = (lphc->hFont) ? SelectObject(hdc, lphc->hFont) : 0;
 741      HBRUSH hPrevBrush, hBkgBrush;
 742
 743      /*
 744       * Give ourselves some space.
 745       */
 746      InflateRect( &rectEdit, -1, -1 );
 747
 748      hBkgBrush = COMBO_PrepareColors( lphc, hdc );
 749      hPrevBrush = SelectObject( hdc, hBkgBrush );
 750      FillRect( hdc, &rectEdit, hBkgBrush );
 751
 752      if( CB_OWNERDRAWN(lphc) )
 753      {
 754        DRAWITEMSTRUCT dis;
 755        HRGN           clipRegion;
 756        UINT ctlid = (UINT)GetWindowLongPtrW( lphc->self, GWLP_ID );
 757
 758        /* setup state for DRAWITEM message. Owner will highlight */
 759        if ( (lphc->wState & CBF_FOCUSED) &&
 760             !(lphc->wState & CBF_DROPPED) )
 761            itemState |= ODS_SELECTED | ODS_FOCUS;
 762
 763        if (!IsWindowEnabled(lphc->self)) itemState |= ODS_DISABLED;
 764
 765        dis.CtlType      = ODT_COMBOBOX;
 766        dis.CtlID        = ctlid;
 767        dis.hwndItem     = lphc->self;
 768        dis.itemAction   = ODA_DRAWENTIRE;
 769        dis.itemID       = id;
 770        dis.itemState    = itemState;
 771        dis.hDC          = hdc;
 772        dis.rcItem       = rectEdit;
 773        dis.itemData     = SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, id, 0);
 774
 775        /*
 776         * Clip the DC and have the parent draw the item.
 777         */
 778        clipRegion = set_control_clipping( hdc, &rectEdit );
 779
 780        SendMessageW(lphc->owner, WM_DRAWITEM, ctlid, (LPARAM)&dis );
 781
 782        SelectClipRgn( hdc, clipRegion );
 783        if (clipRegion) DeleteObject( clipRegion );
 784      }
 785      else
 786      {
 787        static const WCHAR empty_stringW[] = { 0 };
 788
 789        if ( (lphc->wState & CBF_FOCUSED) &&
 790             !(lphc->wState & CBF_DROPPED) ) {
 791
 792            /* highlight */
 793            FillRect( hdc, &rectEdit, GetSysColorBrush(COLOR_HIGHLIGHT) );
 794            SetBkColor( hdc, GetSysColor( COLOR_HIGHLIGHT ) );
 795            SetTextColor( hdc, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
 796        }
 797
 798        ExtTextOutW( hdc,
 799                     rectEdit.left + 1,
 800                     rectEdit.top + 1,
 801                     ETO_OPAQUE | ETO_CLIPPED,
 802                     &rectEdit,
 803                     pText ? pText : empty_stringW , size, NULL );
 804
 805        if(lphc->wState & CBF_FOCUSED && !(lphc->wState & CBF_DROPPED))
 806          DrawFocusRect( hdc, &rectEdit );
 807      }
 808
 809      if( hPrevFont )
 810        SelectObject(hdc, hPrevFont );
 811
 812     if( hPrevBrush )
 813         SelectObject( hdc, hPrevBrush );
 814
 815      if( !hdc_paint )
 816        ReleaseDC( lphc->self, hdc );
 817    }
 818    HeapFree( GetProcessHeap(), 0, pText );
 819 }
 820
 821 /***********************************************************************
 822  *           CBPaintBorder
 823  */
 824 static void CBPaintBorder(
 825   HWND            hwnd,
 826   const HEADCOMBO *lphc,
 827   HDC             hdc)
 828 {
 829   RECT clientRect;
 830
 831   if (CB_GETTYPE(lphc) != CBS_SIMPLE)
 832   {
 833     GetClientRect(hwnd, &clientRect);
 834   }
 835   else
 836   {
 837     clientRect = lphc->textRect;
 838
 839     InflateRect(&clientRect, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
 840     InflateRect(&clientRect, COMBO_XBORDERSIZE(), COMBO_YBORDERSIZE());
 841   }
 842
 843   DrawEdge(hdc, &clientRect, EDGE_SUNKEN, BF_RECT);
 844 }
 845
 846 /***********************************************************************
 847  *           COMBO_Paint
 848  */
 849 static LRESULT COMBO_Paint(LPHEADCOMBO lphc, HDC hParamDC)
 850 {
 851   PAINTSTRUCT ps;
 852   HDC   hDC;
 853
 854   hDC = (hParamDC) ? hParamDC
 855                    : BeginPaint( lphc->self, &ps);
 856
 857   TRACE("hdc=%p\n", hDC);
 858
 859   if( hDC && !(lphc->wState & CBF_NOREDRAW) )
 860   {
 861       HBRUSH    hPrevBrush, hBkgBrush;
 862
 863       /*
 864        * Retrieve the background brush and select it in the
 865        * DC.
 866        */
 867       hBkgBrush = COMBO_PrepareColors(lphc, hDC);
 868
 869       hPrevBrush = SelectObject( hDC, hBkgBrush );
 870       if (!(lphc->wState & CBF_EDIT))
 871         FillRect(hDC, &lphc->textRect, hBkgBrush);
 872
 873       /*
 874        * In non 3.1 look, there is a sunken border on the combobox
 875        */
 876       CBPaintBorder(lphc->self, lphc, hDC);
 877
 878       if( !IsRectEmpty(&lphc->buttonRect) )
 879       {
 880         CBPaintButton(lphc, hDC, lphc->buttonRect);
 881       }
 882
 883       /* paint the edit control padding area */
 884       if (CB_GETTYPE(lphc) != CBS_DROPDOWNLIST)
 885       {
 886           RECT rPadEdit = lphc->textRect;
 887
 888           InflateRect(&rPadEdit, EDIT_CONTROL_PADDING(), EDIT_CONTROL_PADDING());
 889
 890           FrameRect( hDC, &rPadEdit, GetSysColorBrush(COLOR_WINDOW) );
 891       }
 892
 893       if( !(lphc->wState & CBF_EDIT) )
 894         CBPaintText( lphc, hDC );
 895
 896       if( hPrevBrush )
 897         SelectObject( hDC, hPrevBrush );
 898   }
 899
 900   if( !hParamDC )
 901     EndPaint(lphc->self, &ps);
 902
 903   return 0;
 904 }
 905
 906 /***********************************************************************
 907  *           CBUpdateLBox
 908  *
 909  * Select listbox entry according to the contents of the edit control.
 910  */
 911 static INT CBUpdateLBox( LPHEADCOMBO lphc, BOOL bSelect )
 912 {
 913    INT  length, idx;
 914    LPWSTR pText = NULL;
 915
 916    idx = LB_ERR;
 917    length = SendMessageW( lphc->hWndEdit, WM_GETTEXTLENGTH, 0, 0 );
 918
 919    if( length > 0 )
 920        pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
 921
 922    TRACE("\t edit text length %i\n", length );
 923
 924    if( pText )
 925    {
 926        GetWindowTextW( lphc->hWndEdit, pText, length + 1);
 927        idx = SendMessageW(lphc->hWndLBox, LB_FINDSTRING, -1, (LPARAM)pText);
 928        HeapFree( GetProcessHeap(), 0, pText );
 929    }
 930
 931    SendMessageW(lphc->hWndLBox, LB_SETCURSEL, bSelect ? idx : -1, 0);
 932
 933    /* probably superfluous but Windows sends this too */
 934    SendMessageW(lphc->hWndLBox, LB_SETCARETINDEX, idx < 0 ? 0 : idx, 0);
 935    SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, idx < 0 ? 0 : idx, 0);
 936
 937    return idx;
 938 }
 939
 940 /***********************************************************************
 941  *           CBUpdateEdit
 942  *
 943  * Copy a listbox entry to the edit control.
 944  */
 945 static void CBUpdateEdit( LPHEADCOMBO lphc , INT index )
 946 {
 947    INT  length;
 948    LPWSTR pText = NULL;
 949    static const WCHAR empty_stringW[] = { 0 };
 950
 951    TRACE("\t %i\n", index );
 952
 953    if( index >= 0 ) /* got an entry */
 954    {
 955        length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, index, 0);
 956        if( length != LB_ERR)
 957        {
 958            if( (pText = HeapAlloc( GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR))) )
 959            {
 960                SendMessageW(lphc->hWndLBox, LB_GETTEXT, index, (LPARAM)pText);
 961            }
 962        }
 963    }
 964
 965    if( CB_HASSTRINGS(lphc) )
 966    {
 967       lphc->wState |= (CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
 968       SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, pText ? (LPARAM)pText : (LPARAM)empty_stringW);
 969       lphc->wState &= ~(CBF_NOEDITNOTIFY | CBF_NOLBSELECT);
 970    }
 971
 972    if( lphc->wState & CBF_FOCUSED )
 973       SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
 974
 975    HeapFree( GetProcessHeap(), 0, pText );
 976 }
 977
 978 /***********************************************************************
 979  *           CBDropDown
 980  *
 981  * Show listbox popup.
 982  */
 983 static void CBDropDown( LPHEADCOMBO lphc )
 984 {
 985     HMONITOR monitor;
 986     MONITORINFO mon_info;
 987    RECT rect,r;
 988    int nItems;
 989    int nDroppedHeight;
 990
 991    TRACE("[%p]: drop down\n", lphc->self);
 992
 993    CB_NOTIFY( lphc, CBN_DROPDOWN );
 994
 995    /* set selection */
 996
 997    lphc->wState |= CBF_DROPPED;
 998    if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
 999    {
1000        lphc->droppedIndex = CBUpdateLBox( lphc, TRUE );
1001
1002        /* Update edit only if item is in the list */
1003        if( !(lphc->wState & CBF_CAPTURE) && lphc->droppedIndex >= 0)
1004          CBUpdateEdit( lphc, lphc->droppedIndex );
1005    }
1006    else
1007    {
1008        lphc->droppedIndex = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1009
1010        SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX,
1011                     lphc->droppedIndex == LB_ERR ? 0 : lphc->droppedIndex, 0);
1012        SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1013    }
1014
1015    /* now set popup position */
1016    GetWindowRect( lphc->self, &rect );
1017
1018    /*
1019     * If it's a dropdown, the listbox is offset
1020     */
1021    if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1022      rect.left += COMBO_EDITBUTTONSPACE();
1023
1024   /* if the dropped height is greater than the total height of the dropped
1025      items list, then force the drop down list height to be the total height
1026      of the items in the dropped list */
1027
1028   /* And Remove any extra space (Best Fit) */
1029    nDroppedHeight = lphc->droppedRect.bottom - lphc->droppedRect.top;
1030   /* if listbox length has been set directly by its handle */
1031    GetWindowRect(lphc->hWndLBox, &r);
1032    if (nDroppedHeight < r.bottom - r.top)
1033        nDroppedHeight = r.bottom - r.top;
1034    nItems = (int)SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
1035
1036    if (nItems > 0)
1037    {
1038       int nHeight;
1039       int nIHeight;
1040
1041       nIHeight = (int)SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, 0, 0);
1042
1043       nHeight = nIHeight*nItems;
1044
1045       if (nHeight < nDroppedHeight - COMBO_YBORDERSIZE())
1046          nDroppedHeight = nHeight + COMBO_YBORDERSIZE();
1047    }
1048
1049    r.left = rect.left;
1050    r.top = rect.bottom;
1051    r.right = r.left + lphc->droppedRect.right - lphc->droppedRect.left;
1052    r.bottom = r.top + nDroppedHeight;
1053
1054    /*If height of dropped rectangle gets beyond a screen size it should go up, otherwise down.*/
1055    monitor = MonitorFromRect( &rect, MONITOR_DEFAULTTOPRIMARY );
1056    mon_info.cbSize = sizeof(mon_info);
1057    GetMonitorInfoW( monitor, &mon_info );
1058
1059    if (r.bottom > mon_info.rcWork.bottom)
1060    {
1061        r.top = max( rect.top - nDroppedHeight, mon_info.rcWork.top );
1062        r.bottom = min( r.top + nDroppedHeight, mon_info.rcWork.bottom );
1063    }
1064
1065    SetWindowPos( lphc->hWndLBox, HWND_TOPMOST, r.left, r.top, r.right - r.left, r.bottom - r.top,
1066                  SWP_NOACTIVATE | SWP_SHOWWINDOW );
1067
1068
1069    if( !(lphc->wState & CBF_NOREDRAW) )
1070      RedrawWindow( lphc->self, NULL, 0, RDW_INVALIDATE |
1071                            RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1072
1073    EnableWindow( lphc->hWndLBox, TRUE );
1074    if (GetCapture() != lphc->self)
1075       SetCapture(lphc->hWndLBox);
1076 }
1077
1078 /***********************************************************************
1079  *           CBRollUp
1080  *
1081  * Hide listbox popup.
1082  */
1083 static void CBRollUp( LPHEADCOMBO lphc, BOOL ok, BOOL bButton )
1084 {
1085    HWND hWnd = lphc->self;
1086
1087    TRACE("[%p]: sel ok? [%i] dropped? [%i]\n",
1088          lphc->self, ok, (INT)(lphc->wState & CBF_DROPPED));
1089
1090    CB_NOTIFY( lphc, (ok) ? CBN_SELENDOK : CBN_SELENDCANCEL );
1091
1092    if( IsWindow( hWnd ) && CB_GETTYPE(lphc) != CBS_SIMPLE )
1093    {
1094
1095        if( lphc->wState & CBF_DROPPED )
1096        {
1097            RECT rect;
1098
1099            lphc->wState &= ~CBF_DROPPED;
1100            ShowWindow( lphc->hWndLBox, SW_HIDE );
1101
1102            if(GetCapture() == lphc->hWndLBox)
1103            {
1104                ReleaseCapture();
1105            }
1106
1107            if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1108            {
1109                rect = lphc->buttonRect;
1110            }
1111            else
1112            {
1113                if( bButton )
1114                {
1115                  UnionRect( &rect,
1116                             &lphc->buttonRect,
1117                             &lphc->textRect);
1118                }
1119                else
1120                  rect = lphc->textRect;
1121
1122                bButton = TRUE;
1123            }
1124
1125            if( bButton && !(lphc->wState & CBF_NOREDRAW) )
1126                RedrawWindow( hWnd, &rect, 0, RDW_INVALIDATE |
1127                                RDW_ERASE | RDW_UPDATENOW | RDW_NOCHILDREN );
1128            CB_NOTIFY( lphc, CBN_CLOSEUP );
1129        }
1130    }
1131 }
1132
1133 /***********************************************************************
1134  *           COMBO_FlipListbox
1135  *
1136  * Used by the ComboLBox to show/hide itself in response to VK_F4, etc...
1137  */
1138 BOOL COMBO_FlipListbox( LPHEADCOMBO lphc, BOOL ok, BOOL bRedrawButton )
1139 {
1140    if( lphc->wState & CBF_DROPPED )
1141    {
1142        CBRollUp( lphc, ok, bRedrawButton );
1143        return FALSE;
1144    }
1145
1146    CBDropDown( lphc );
1147    return TRUE;
1148 }
1149
1150 /***********************************************************************
1151  *           CBRepaintButton
1152  */
1153 static void CBRepaintButton( LPHEADCOMBO lphc )
1154    {
1155   InvalidateRect(lphc->self, &lphc->buttonRect, TRUE);
1156   UpdateWindow(lphc->self);
1157 }
1158
1159 /***********************************************************************
1160  *           COMBO_SetFocus
1161  */
1162 static void COMBO_SetFocus( LPHEADCOMBO lphc )
1163 {
1164    if( !(lphc->wState & CBF_FOCUSED) )
1165    {
1166        if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1167            SendMessageW(lphc->hWndLBox, LB_CARETON, 0, 0);
1168
1169        /* This is wrong. Message sequences seem to indicate that this
1170           is set *after* the notify. */
1171        /* lphc->wState |= CBF_FOCUSED;  */
1172
1173        if( !(lphc->wState & CBF_EDIT) )
1174          InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1175
1176        CB_NOTIFY( lphc, CBN_SETFOCUS );
1177        lphc->wState |= CBF_FOCUSED;
1178    }
1179 }
1180
1181 /***********************************************************************
1182  *           COMBO_KillFocus
1183  */
1184 static void COMBO_KillFocus( LPHEADCOMBO lphc )
1185 {
1186    HWND hWnd = lphc->self;
1187
1188    if( lphc->wState & CBF_FOCUSED )
1189    {
1190        CBRollUp( lphc, FALSE, TRUE );
1191        if( IsWindow( hWnd ) )
1192        {
1193            if( CB_GETTYPE(lphc) == CBS_DROPDOWNLIST )
1194                SendMessageW(lphc->hWndLBox, LB_CARETOFF, 0, 0);
1195
1196            lphc->wState &= ~CBF_FOCUSED;
1197
1198            /* redraw text */
1199            if( !(lphc->wState & CBF_EDIT) )
1200              InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1201
1202            CB_NOTIFY( lphc, CBN_KILLFOCUS );
1203        }
1204    }
1205 }
1206
1207 /***********************************************************************
1208  *           COMBO_Command
1209  */
1210 static LRESULT COMBO_Command( LPHEADCOMBO lphc, WPARAM wParam, HWND hWnd )
1211 {
1212    if ( lphc->wState & CBF_EDIT && lphc->hWndEdit == hWnd )
1213    {
1214        /* ">> 8" makes gcc generate jump-table instead of cmp ladder */
1215
1216        switch( HIWORD(wParam) >> 8 )
1217        {
1218            case (EN_SETFOCUS >> 8):
1219
1220                TRACE("[%p]: edit [%p] got focus\n", lphc->self, lphc->hWndEdit );
1221
1222                 COMBO_SetFocus( lphc );
1223                 break;
1224
1225            case (EN_KILLFOCUS >> 8):
1226
1227                TRACE("[%p]: edit [%p] lost focus\n", lphc->self, lphc->hWndEdit );
1228
1229                 /* NOTE: it seems that Windows' edit control sends an
1230                  * undocumented message WM_USER + 0x1B instead of this
1231                  * notification (only when it happens to be a part of
1232                  * the combo). ?? - AK.
1233                  */
1234
1235                 COMBO_KillFocus( lphc );
1236                 break;
1237
1238
1239            case (EN_CHANGE >> 8):
1240                /*
1241                 * In some circumstances (when the selection of the combobox
1242                 * is changed for example) we don't want the EN_CHANGE notification
1243                 * to be forwarded to the parent of the combobox. This code
1244                 * checks a flag that is set in these occasions and ignores the
1245                 * notification.
1246                 */
1247                 if (lphc->wState & CBF_NOLBSELECT)
1248                 {
1249                   lphc->wState &= ~CBF_NOLBSELECT;
1250                 }
1251                 else
1252                 {
1253                   CBUpdateLBox( lphc, lphc->wState & CBF_DROPPED );
1254                 }
1255
1256                 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1257                   CB_NOTIFY( lphc, CBN_EDITCHANGE );
1258                 break;
1259
1260            case (EN_UPDATE >> 8):
1261                 if (!(lphc->wState & CBF_NOEDITNOTIFY))
1262                   CB_NOTIFY( lphc, CBN_EDITUPDATE );
1263                 break;
1264
1265            case (EN_ERRSPACE >> 8):
1266                 CB_NOTIFY( lphc, CBN_ERRSPACE );
1267        }
1268    }
1269    else if( lphc->hWndLBox == hWnd )
1270    {
1271        switch( (short)HIWORD(wParam) )
1272        {
1273            case LBN_ERRSPACE:
1274                 CB_NOTIFY( lphc, CBN_ERRSPACE );
1275                 break;
1276
1277            case LBN_DBLCLK:
1278                 CB_NOTIFY( lphc, CBN_DBLCLK );
1279                 break;
1280
1281            case LBN_SELCHANGE:
1282            case LBN_SELCANCEL:
1283
1284                 TRACE("[%p]: lbox selection change [%x]\n", lphc->self, lphc->wState );
1285
1286                 /* do not roll up if selection is being tracked
1287                  * by arrow keys in the dropdown listbox */
1288                 if (!(lphc->wState & CBF_NOROLLUP))
1289                 {
1290                     CBRollUp( lphc, (HIWORD(wParam) == LBN_SELCHANGE), TRUE );
1291                 }
1292                 else lphc->wState &= ~CBF_NOROLLUP;
1293
1294                 CB_NOTIFY( lphc, CBN_SELCHANGE );
1295
1296                 if( HIWORD(wParam) == LBN_SELCHANGE)
1297                 {
1298                    if( lphc->wState & CBF_EDIT )
1299                        lphc->wState |= CBF_NOLBSELECT;
1300                    CBPaintText( lphc, NULL );
1301                 }
1302                 break;
1303
1304            case LBN_SETFOCUS:
1305            case LBN_KILLFOCUS:
1306                 /* nothing to do here since ComboLBox always resets the focus to its
1307                  * combo/edit counterpart */
1308                  break;
1309        }
1310    }
1311    return 0;
1312 }
1313
1314 /***********************************************************************
1315  *           COMBO_ItemOp
1316  *
1317  * Fixup an ownerdrawn item operation and pass it up to the combobox owner.
1318  */
1319 static LRESULT COMBO_ItemOp( LPHEADCOMBO lphc, UINT msg, LPARAM lParam )
1320 {
1321    HWND hWnd = lphc->self;
1322    UINT id = (UINT)GetWindowLongPtrW( hWnd, GWLP_ID );
1323
1324    TRACE("[%p]: ownerdraw op %04x\n", lphc->self, msg );
1325
1326    switch( msg )
1327    {
1328    case WM_DELETEITEM:
1329        {
1330            DELETEITEMSTRUCT *lpIS = (DELETEITEMSTRUCT *)lParam;
1331            lpIS->CtlType  = ODT_COMBOBOX;
1332            lpIS->CtlID    = id;
1333            lpIS->hwndItem = hWnd;
1334            break;
1335        }
1336    case WM_DRAWITEM:
1337        {
1338            DRAWITEMSTRUCT *lpIS = (DRAWITEMSTRUCT *)lParam;
1339            lpIS->CtlType  = ODT_COMBOBOX;
1340            lpIS->CtlID    = id;
1341            lpIS->hwndItem = hWnd;
1342            break;
1343        }
1344    case WM_COMPAREITEM:
1345        {
1346            COMPAREITEMSTRUCT *lpIS = (COMPAREITEMSTRUCT *)lParam;
1347            lpIS->CtlType  = ODT_COMBOBOX;
1348            lpIS->CtlID    = id;
1349            lpIS->hwndItem = hWnd;
1350            break;
1351        }
1352    case WM_MEASUREITEM:
1353        {
1354            MEASUREITEMSTRUCT *lpIS = (MEASUREITEMSTRUCT *)lParam;
1355            lpIS->CtlType  = ODT_COMBOBOX;
1356            lpIS->CtlID    = id;
1357            break;
1358        }
1359    }
1360    return SendMessageW(lphc->owner, msg, id, lParam);
1361 }
1362
1363
1364 /***********************************************************************
1365  *           COMBO_GetTextW
1366  */
1367 static LRESULT COMBO_GetTextW( LPHEADCOMBO lphc, INT count, LPWSTR buf )
1368 {
1369     INT length;
1370
1371     if( lphc->wState & CBF_EDIT )
1372         return SendMessageW( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1373
1374     /* get it from the listbox */
1375
1376     if (!count || !buf) return 0;
1377     if( lphc->hWndLBox )
1378     {
1379         INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1380         if (idx == LB_ERR) goto error;
1381         length = SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1382         if (length == LB_ERR) goto error;
1383
1384         /* 'length' is without the terminating character */
1385         if (length >= count)
1386         {
1387             LPWSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) * sizeof(WCHAR));
1388             if (!lpBuffer) goto error;
1389             length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1390
1391             /* truncate if buffer is too short */
1392             if (length != LB_ERR)
1393             {
1394                 lstrcpynW( buf, lpBuffer, count );
1395                 length = count;
1396             }
1397             HeapFree( GetProcessHeap(), 0, lpBuffer );
1398         }
1399         else length = SendMessageW(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1400
1401         if (length == LB_ERR) return 0;
1402         return length;
1403     }
1404
1405  error:  /* error - truncate string, return zero */
1406     buf[0] = 0;
1407     return 0;
1408 }
1409
1410
1411 /***********************************************************************
1412  *           COMBO_GetTextA
1413  *
1414  * NOTE! LB_GETTEXT does not count terminating \0, WM_GETTEXT does.
1415  *       also LB_GETTEXT might return values < 0, WM_GETTEXT doesn't.
1416  */
1417 static LRESULT COMBO_GetTextA( LPHEADCOMBO lphc, INT count, LPSTR buf )
1418 {
1419     INT length;
1420
1421     if( lphc->wState & CBF_EDIT )
1422         return SendMessageA( lphc->hWndEdit, WM_GETTEXT, count, (LPARAM)buf );
1423
1424     /* get it from the listbox */
1425
1426     if (!count || !buf) return 0;
1427     if( lphc->hWndLBox )
1428     {
1429         INT idx = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1430         if (idx == LB_ERR) goto error;
1431         length = SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, idx, 0 );
1432         if (length == LB_ERR) goto error;
1433
1434         /* 'length' is without the terminating character */
1435         if (length >= count)
1436         {
1437             LPSTR lpBuffer = HeapAlloc(GetProcessHeap(), 0, (length + 1) );
1438             if (!lpBuffer) goto error;
1439             length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)lpBuffer);
1440
1441             /* truncate if buffer is too short */
1442             if (length != LB_ERR)
1443             {
1444                 lstrcpynA( buf, lpBuffer, count );
1445                 length = count;
1446             }
1447             HeapFree( GetProcessHeap(), 0, lpBuffer );
1448         }
1449         else length = SendMessageA(lphc->hWndLBox, LB_GETTEXT, idx, (LPARAM)buf);
1450
1451         if (length == LB_ERR) return 0;
1452         return length;
1453     }
1454
1455  error:  /* error - truncate string, return zero */
1456     buf[0] = 0;
1457     return 0;
1458 }
1459
1460
1461 /***********************************************************************
1462  *           CBResetPos
1463  *
1464  * This function sets window positions according to the updated
1465  * component placement struct.
1466  */
1467 static void CBResetPos(
1468   LPHEADCOMBO lphc,
1469   const RECT  *rectEdit,
1470   const RECT  *rectLB,
1471   BOOL        bRedraw)
1472 {
1473    BOOL bDrop = (CB_GETTYPE(lphc) != CBS_SIMPLE);
1474
1475    /* NOTE: logs sometimes have WM_LBUTTONUP before a cascade of
1476     * sizing messages */
1477
1478    if( lphc->wState & CBF_EDIT )
1479      SetWindowPos( lphc->hWndEdit, 0,
1480                    rectEdit->left, rectEdit->top,
1481                    rectEdit->right - rectEdit->left,
1482                    rectEdit->bottom - rectEdit->top,
1483                        SWP_NOZORDER | SWP_NOACTIVATE | ((bDrop) ? SWP_NOREDRAW : 0) );
1484
1485    SetWindowPos( lphc->hWndLBox, 0,
1486                  rectLB->left, rectLB->top,
1487                  rectLB->right - rectLB->left,
1488                  rectLB->bottom - rectLB->top,
1489                    SWP_NOACTIVATE | SWP_NOZORDER | ((bDrop) ? SWP_NOREDRAW : 0) );
1490
1491    if( bDrop )
1492    {
1493        if( lphc->wState & CBF_DROPPED )
1494        {
1495            lphc->wState &= ~CBF_DROPPED;
1496            ShowWindow( lphc->hWndLBox, SW_HIDE );
1497        }
1498
1499        if( bRedraw && !(lphc->wState & CBF_NOREDRAW) )
1500            RedrawWindow( lphc->self, NULL, 0,
1501                            RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW );
1502    }
1503 }
1504
1505
1506 /***********************************************************************
1507  *           COMBO_Size
1508  */
1509 static void COMBO_Size( LPHEADCOMBO lphc )
1510 {
1511   /*
1512    * Those controls are always the same height. So we have to make sure
1513    * they are not resized to another value.
1514    */
1515   if( CB_GETTYPE(lphc) != CBS_SIMPLE )
1516   {
1517     int newComboHeight, curComboHeight, curComboWidth;
1518     RECT rc;
1519
1520     GetWindowRect(lphc->self, &rc);
1521     curComboHeight = rc.bottom - rc.top;
1522     curComboWidth = rc.right - rc.left;
1523     newComboHeight = CBGetTextAreaHeight(lphc->self, lphc) + 2*COMBO_YBORDERSIZE();
1524
1525     /*
1526      * Resizing a combobox has another side effect, it resizes the dropped
1527      * rectangle as well. However, it does it only if the new height for the
1528      * combobox is more than the height it should have. In other words,
1529      * if the application resizing the combobox only had the intention to resize
1530      * the actual control, for example, to do the layout of a dialog that is
1531      * resized, the height of the dropdown is not changed.
1532      */
1533     if( curComboHeight > newComboHeight )
1534     {
1535       TRACE("oldComboHeight=%d, newComboHeight=%d, oldDropBottom=%d, oldDropTop=%d\n",
1536             curComboHeight, newComboHeight, lphc->droppedRect.bottom,
1537             lphc->droppedRect.top);
1538       lphc->droppedRect.bottom = lphc->droppedRect.top + curComboHeight - newComboHeight;
1539     }
1540     /*
1541      * Restore original height
1542      */
1543     if( curComboHeight != newComboHeight )
1544       SetWindowPos(lphc->self, 0, 0, 0, curComboWidth, newComboHeight,
1545             SWP_NOZORDER|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOREDRAW);
1546   }
1547
1548   CBCalcPlacement(lphc->self,
1549                   lphc,
1550                   &lphc->textRect,
1551                   &lphc->buttonRect,
1552                   &lphc->droppedRect);
1553
1554   CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1555 }
1556
1557
1558 /***********************************************************************
1559  *           COMBO_Font
1560  */
1561 static void COMBO_Font( LPHEADCOMBO lphc, HFONT hFont, BOOL bRedraw )
1562 {
1563   /*
1564    * Set the font
1565    */
1566   lphc->hFont = hFont;
1567
1568   /*
1569    * Propagate to owned windows.
1570    */
1571   if( lphc->wState & CBF_EDIT )
1572       SendMessageW(lphc->hWndEdit, WM_SETFONT, (WPARAM)hFont, bRedraw);
1573   SendMessageW(lphc->hWndLBox, WM_SETFONT, (WPARAM)hFont, bRedraw);
1574
1575   /*
1576    * Redo the layout of the control.
1577    */
1578   if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1579   {
1580     CBCalcPlacement(lphc->self,
1581                     lphc,
1582                     &lphc->textRect,
1583                     &lphc->buttonRect,
1584                     &lphc->droppedRect);
1585
1586     CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1587   }
1588   else
1589   {
1590     CBForceDummyResize(lphc);
1591   }
1592 }
1593
1594
1595 /***********************************************************************
1596  *           COMBO_SetItemHeight
1597  */
1598 static LRESULT COMBO_SetItemHeight( LPHEADCOMBO lphc, INT index, INT height )
1599 {
1600    LRESULT      lRet = CB_ERR;
1601
1602    if( index == -1 ) /* set text field height */
1603    {
1604        if( height < 32768 )
1605        {
1606            lphc->editHeight = height + 2;  /* Is the 2 for 2*EDIT_CONTROL_PADDING? */
1607
1608          /*
1609           * Redo the layout of the control.
1610           */
1611          if ( CB_GETTYPE(lphc) == CBS_SIMPLE)
1612          {
1613            CBCalcPlacement(lphc->self,
1614                            lphc,
1615                            &lphc->textRect,
1616                            &lphc->buttonRect,
1617                            &lphc->droppedRect);
1618
1619            CBResetPos( lphc, &lphc->textRect, &lphc->droppedRect, TRUE );
1620          }
1621          else
1622          {
1623            CBForceDummyResize(lphc);
1624          }
1625
1626            lRet = height;
1627        }
1628    }
1629    else if ( CB_OWNERDRAWN(lphc) )      /* set listbox item height */
1630        lRet = SendMessageW(lphc->hWndLBox, LB_SETITEMHEIGHT, index, height);
1631    return lRet;
1632 }
1633
1634 /***********************************************************************
1635  *           COMBO_SelectString
1636  */
1637 static LRESULT COMBO_SelectString( LPHEADCOMBO lphc, INT start, LPARAM pText, BOOL unicode )
1638 {
1639    INT index = unicode ? SendMessageW(lphc->hWndLBox, LB_SELECTSTRING, start, pText) :
1640                          SendMessageA(lphc->hWndLBox, LB_SELECTSTRING, start, pText);
1641    if( index >= 0 )
1642    {
1643      if( lphc->wState & CBF_EDIT )
1644        CBUpdateEdit( lphc, index );
1645      else
1646      {
1647        InvalidateRect(lphc->self, &lphc->textRect, TRUE);
1648      }
1649    }
1650    return (LRESULT)index;
1651 }
1652
1653 /***********************************************************************
1654  *           COMBO_LButtonDown
1655  */
1656 static void COMBO_LButtonDown( LPHEADCOMBO lphc, LPARAM lParam )
1657 {
1658    POINT     pt;
1659    BOOL      bButton;
1660    HWND      hWnd = lphc->self;
1661
1662    pt.x = (short)LOWORD(lParam);
1663    pt.y = (short)HIWORD(lParam);
1664    bButton = PtInRect(&lphc->buttonRect, pt);
1665
1666    if( (CB_GETTYPE(lphc) == CBS_DROPDOWNLIST) ||
1667        (bButton && (CB_GETTYPE(lphc) == CBS_DROPDOWN)) )
1668    {
1669        lphc->wState |= CBF_BUTTONDOWN;
1670        if( lphc->wState & CBF_DROPPED )
1671        {
1672            /* got a click to cancel selection */
1673
1674            lphc->wState &= ~CBF_BUTTONDOWN;
1675            CBRollUp( lphc, TRUE, FALSE );
1676            if( !IsWindow( hWnd ) ) return;
1677
1678            if( lphc->wState & CBF_CAPTURE )
1679            {
1680                lphc->wState &= ~CBF_CAPTURE;
1681                ReleaseCapture();
1682            }
1683        }
1684        else
1685        {
1686            /* drop down the listbox and start tracking */
1687
1688            lphc->wState |= CBF_CAPTURE;
1689            SetCapture( hWnd );
1690            CBDropDown( lphc );
1691        }
1692        if( bButton ) CBRepaintButton( lphc );
1693    }
1694 }
1695
1696 /***********************************************************************
1697  *           COMBO_LButtonUp
1698  *
1699  * Release capture and stop tracking if needed.
1700  */
1701 static void COMBO_LButtonUp( LPHEADCOMBO lphc )
1702 {
1703    if( lphc->wState & CBF_CAPTURE )
1704    {
1705        lphc->wState &= ~CBF_CAPTURE;
1706        if( CB_GETTYPE(lphc) == CBS_DROPDOWN )
1707        {
1708            INT index = CBUpdateLBox( lphc, TRUE );
1709            /* Update edit only if item is in the list */
1710            if(index >= 0)
1711            {
1712                lphc->wState |= CBF_NOLBSELECT;
1713                CBUpdateEdit( lphc, index );
1714                lphc->wState &= ~CBF_NOLBSELECT;
1715            }
1716        }
1717        ReleaseCapture();
1718        SetCapture(lphc->hWndLBox);
1719    }
1720
1721    if( lphc->wState & CBF_BUTTONDOWN )
1722    {
1723        lphc->wState &= ~CBF_BUTTONDOWN;
1724        CBRepaintButton( lphc );
1725    }
1726 }
1727
1728 /***********************************************************************
1729  *           COMBO_MouseMove
1730  *
1731  * Two things to do - track combo button and release capture when
1732  * pointer goes into the listbox.
1733  */
1734 static void COMBO_MouseMove( LPHEADCOMBO lphc, WPARAM wParam, LPARAM lParam )
1735 {
1736    POINT  pt;
1737    RECT   lbRect;
1738
1739    pt.x = (short)LOWORD(lParam);
1740    pt.y = (short)HIWORD(lParam);
1741
1742    if( lphc->wState & CBF_BUTTONDOWN )
1743    {
1744      BOOL bButton;
1745
1746      bButton = PtInRect(&lphc->buttonRect, pt);
1747
1748      if( !bButton )
1749      {
1750        lphc->wState &= ~CBF_BUTTONDOWN;
1751        CBRepaintButton( lphc );
1752      }
1753    }
1754
1755    GetClientRect( lphc->hWndLBox, &lbRect );
1756    MapWindowPoints( lphc->self, lphc->hWndLBox, &pt, 1 );
1757    if( PtInRect(&lbRect, pt) )
1758    {
1759        lphc->wState &= ~CBF_CAPTURE;
1760        ReleaseCapture();
1761        if( CB_GETTYPE(lphc) == CBS_DROPDOWN ) CBUpdateLBox( lphc, TRUE );
1762
1763        /* hand over pointer tracking */
1764        SendMessageW(lphc->hWndLBox, WM_LBUTTONDOWN, wParam, lParam);
1765    }
1766 }
1767
1768 static LRESULT COMBO_GetComboBoxInfo(const HEADCOMBO *lphc, COMBOBOXINFO *pcbi)
1769 {
1770     if (!pcbi || (pcbi->cbSize < sizeof(COMBOBOXINFO)))
1771         return FALSE;
1772
1773     pcbi->rcItem = lphc->textRect;
1774     pcbi->rcButton = lphc->buttonRect;
1775     pcbi->stateButton = 0;
1776     if (lphc->wState & CBF_BUTTONDOWN)
1777         pcbi->stateButton |= STATE_SYSTEM_PRESSED;
1778     if (IsRectEmpty(&lphc->buttonRect))
1779         pcbi->stateButton |= STATE_SYSTEM_INVISIBLE;
1780     pcbi->hwndCombo = lphc->self;
1781     pcbi->hwndItem = lphc->hWndEdit;
1782     pcbi->hwndList = lphc->hWndLBox;
1783     return TRUE;
1784 }
1785
1786 static char *strdupA(LPCSTR str)
1787 {
1788     char *ret;
1789     DWORD len;
1790
1791     if(!str) return NULL;
1792
1793     len = strlen(str);
1794     ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
1795     memcpy(ret, str, len + 1);
1796     return ret;
1797 }
1798
1799 /***********************************************************************
1800  *           ComboWndProc_common
1801  */
1802 LRESULT ComboWndProc_common( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode )
1803 {
1804       LPHEADCOMBO lphc = (LPHEADCOMBO)GetWindowLongPtrW( hwnd, 0 );
1805
1806       TRACE("[%p]: msg %s wp %08lx lp %08lx\n",
1807             hwnd, SPY_GetMsgName(message, hwnd), wParam, lParam );
1808
1809       if (!IsWindow(hwnd)) return 0;
1810
1811       if( lphc || message == WM_NCCREATE )
1812       switch(message)
1813       {
1814
1815         /* System messages */
1816
1817         case WM_NCCREATE:
1818         {
1819                 LONG style = unicode ? ((LPCREATESTRUCTW)lParam)->style :
1820                                        ((LPCREATESTRUCTA)lParam)->style;
1821                 return COMBO_NCCreate(hwnd, style);
1822         }
1823         case WM_NCDESTROY:
1824                 COMBO_NCDestroy(lphc);
1825                 break;/* -> DefWindowProc */
1826
1827         case WM_CREATE:
1828         {
1829                 HWND hwndParent;
1830                 LONG style;
1831                 if(unicode)
1832                 {
1833                     hwndParent = ((LPCREATESTRUCTW)lParam)->hwndParent;
1834                     style = ((LPCREATESTRUCTW)lParam)->style;
1835                 }
1836                 else
1837                 {
1838                     hwndParent = ((LPCREATESTRUCTA)lParam)->hwndParent;
1839                     style = ((LPCREATESTRUCTA)lParam)->style;
1840                 }
1841                 return COMBO_Create(hwnd, lphc, hwndParent, style, unicode);
1842         }
1843
1844         case WM_PRINTCLIENT:
1845                 /* Fallthrough */
1846         case WM_PAINT:
1847                 /* wParam may contain a valid HDC! */
1848                 return  COMBO_Paint(lphc, (HDC)wParam);
1849
1850         case WM_ERASEBKGND:
1851                 /* do all painting in WM_PAINT like Windows does */
1852                 return 1;
1853
1854         case WM_GETDLGCODE:
1855         {
1856                 LRESULT result = DLGC_WANTARROWS | DLGC_WANTCHARS;
1857                 if (lParam && (((LPMSG)lParam)->message == WM_KEYDOWN))
1858                 {
1859                    int vk = (int)((LPMSG)lParam)->wParam;
1860
1861                    if ((vk == VK_RETURN || vk == VK_ESCAPE) && (lphc->wState & CBF_DROPPED))
1862                        result |= DLGC_WANTMESSAGE;
1863                 }
1864                 return  result;
1865         }
1866         case WM_SIZE:
1867                 if( lphc->hWndLBox &&
1868                   !(lphc->wState & CBF_NORESIZE) ) COMBO_Size( lphc );
1869                 return  TRUE;
1870         case WM_SETFONT:
1871                 COMBO_Font( lphc, (HFONT)wParam, (BOOL)lParam );
1872                 return  TRUE;
1873         case WM_GETFONT:
1874                 return  (LRESULT)lphc->hFont;
1875         case WM_SETFOCUS:
1876                if( lphc->wState & CBF_EDIT ) {
1877                    SetFocus( lphc->hWndEdit );
1878                    /* The first time focus is received, select all the text */
1879                    if( !(lphc->wState & CBF_BEENFOCUSED) ) {
1880                        SendMessageW(lphc->hWndEdit, EM_SETSEL, 0, -1);
1881                        lphc->wState |= CBF_BEENFOCUSED;
1882                    }
1883                }
1884                 else
1885                     COMBO_SetFocus( lphc );
1886                 return  TRUE;
1887         case WM_KILLFOCUS:
1888             {
1889                 HWND hwndFocus = WIN_GetFullHandle( (HWND)wParam );
1890                 if( !hwndFocus ||
1891                     (hwndFocus != lphc->hWndEdit && hwndFocus != lphc->hWndLBox ))
1892                     COMBO_KillFocus( lphc );
1893                 return  TRUE;
1894             }
1895         case WM_COMMAND:
1896                 return  COMBO_Command( lphc, wParam, WIN_GetFullHandle( (HWND)lParam ) );
1897         case WM_GETTEXT:
1898             return unicode ? COMBO_GetTextW( lphc, wParam, (LPWSTR)lParam )
1899                            : COMBO_GetTextA( lphc, wParam, (LPSTR)lParam );
1900         case WM_SETTEXT:
1901         case WM_GETTEXTLENGTH:
1902         case WM_CLEAR:
1903                 if ((message == WM_GETTEXTLENGTH) && !ISWIN31 && !(lphc->wState & CBF_EDIT))
1904                 {
1905                     int j = SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
1906                     if (j == -1) return 0;
1907                     return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, j, 0) :
1908                                      SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, j, 0);
1909                 }
1910                 else if( lphc->wState & CBF_EDIT )
1911                 {
1912                     LRESULT ret;
1913                     lphc->wState |= CBF_NOEDITNOTIFY;
1914                     ret = unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1915                                     SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1916                     lphc->wState &= ~CBF_NOEDITNOTIFY;
1917                     return ret;
1918                 }
1919                 else return CB_ERR;
1920         case WM_CUT:
1921         case WM_PASTE:
1922         case WM_COPY:
1923                 if( lphc->wState & CBF_EDIT )
1924                 {
1925                     return unicode ? SendMessageW(lphc->hWndEdit, message, wParam, lParam) :
1926                                      SendMessageA(lphc->hWndEdit, message, wParam, lParam);
1927                 }
1928                 else return  CB_ERR;
1929
1930         case WM_DRAWITEM:
1931         case WM_DELETEITEM:
1932         case WM_COMPAREITEM:
1933         case WM_MEASUREITEM:
1934                 return COMBO_ItemOp(lphc, message, lParam);
1935         case WM_ENABLE:
1936                 if( lphc->wState & CBF_EDIT )
1937                     EnableWindow( lphc->hWndEdit, (BOOL)wParam );
1938                 EnableWindow( lphc->hWndLBox, (BOOL)wParam );
1939
1940                 /* Force the control to repaint when the enabled state changes. */
1941                 InvalidateRect(lphc->self, NULL, TRUE);
1942                 return  TRUE;
1943         case WM_SETREDRAW:
1944                 if( wParam )
1945                     lphc->wState &= ~CBF_NOREDRAW;
1946                 else
1947                     lphc->wState |= CBF_NOREDRAW;
1948
1949                 if( lphc->wState & CBF_EDIT )
1950                     SendMessageW(lphc->hWndEdit, message, wParam, lParam);
1951                 SendMessageW(lphc->hWndLBox, message, wParam, lParam);
1952                 return  0;
1953         case WM_SYSKEYDOWN:
1954                 if( KEYDATA_ALT & HIWORD(lParam) )
1955                     if( wParam == VK_UP || wParam == VK_DOWN )
1956                         COMBO_FlipListbox( lphc, FALSE, FALSE );
1957                 return  0;
1958
1959         case WM_KEYDOWN:
1960                 if ((wParam == VK_RETURN || wParam == VK_ESCAPE) &&
1961                      (lphc->wState & CBF_DROPPED))
1962                 {
1963                    CBRollUp( lphc, wParam == VK_RETURN, FALSE );
1964                    return TRUE;
1965                 }
1966                else if ((wParam == VK_F4) && !(lphc->wState & CBF_EUI))
1967                {
1968                   COMBO_FlipListbox( lphc, FALSE, FALSE );
1969                   return TRUE;
1970                }
1971                /* fall through */
1972         case WM_CHAR:
1973         case WM_IME_CHAR:
1974         {
1975                 HWND hwndTarget;
1976
1977                 if( lphc->wState & CBF_EDIT )
1978                     hwndTarget = lphc->hWndEdit;
1979                 else
1980                     hwndTarget = lphc->hWndLBox;
1981
1982                 return unicode ? SendMessageW(hwndTarget, message, wParam, lParam) :
1983                                  SendMessageA(hwndTarget, message, wParam, lParam);
1984         }
1985         case WM_LBUTTONDOWN:
1986                 if( !(lphc->wState & CBF_FOCUSED) ) SetFocus( lphc->self );
1987                 if( lphc->wState & CBF_FOCUSED ) COMBO_LButtonDown( lphc, lParam );
1988                 return  TRUE;
1989         case WM_LBUTTONUP:
1990                 COMBO_LButtonUp( lphc );
1991                 return  TRUE;
1992         case WM_MOUSEMOVE:
1993                 if( lphc->wState & CBF_CAPTURE )
1994                     COMBO_MouseMove( lphc, wParam, lParam );
1995                 return  TRUE;
1996
1997         case WM_MOUSEWHEEL:
1998                 if (wParam & (MK_SHIFT | MK_CONTROL))
1999                     return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2000                                      DefWindowProcA(hwnd, message, wParam, lParam);
2001
2002                 if (GET_WHEEL_DELTA_WPARAM(wParam) > 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_UP, 0);
2003                 if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) return SendMessageW(hwnd, WM_KEYDOWN, VK_DOWN, 0);
2004                 return TRUE;
2005
2006         /* Combo messages */
2007
2008         case CB_ADDSTRING:
2009                 if( unicode )
2010                 {
2011                     if( lphc->dwStyle & CBS_LOWERCASE )
2012                         CharLowerW((LPWSTR)lParam);
2013                     else if( lphc->dwStyle & CBS_UPPERCASE )
2014                         CharUpperW((LPWSTR)lParam);
2015                     return SendMessageW(lphc->hWndLBox, LB_ADDSTRING, 0, lParam);
2016                 }
2017                 else /* unlike the unicode version, the ansi version does not overwrite
2018                         the string if converting case */
2019                 {
2020                     char *string = NULL;
2021                     LRESULT ret;
2022                     if( lphc->dwStyle & CBS_LOWERCASE )
2023                     {
2024                         string = strdupA((LPSTR)lParam);
2025                         CharLowerA(string);
2026                     }
2027
2028                     else if( lphc->dwStyle & CBS_UPPERCASE )
2029                     {
2030                         string = strdupA((LPSTR)lParam);
2031                         CharUpperA(string);
2032                     }
2033
2034                     ret = SendMessageA(lphc->hWndLBox, LB_ADDSTRING, 0, string ? (LPARAM)string : lParam);
2035                     HeapFree(GetProcessHeap(), 0, string);
2036                     return ret;
2037                 }
2038         case CB_INSERTSTRING:
2039                 if( unicode )
2040                 {
2041                     if( lphc->dwStyle & CBS_LOWERCASE )
2042                         CharLowerW((LPWSTR)lParam);
2043                     else if( lphc->dwStyle & CBS_UPPERCASE )
2044                         CharUpperW((LPWSTR)lParam);
2045                     return SendMessageW(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2046                 }
2047                 else
2048                 {
2049                     if( lphc->dwStyle & CBS_LOWERCASE )
2050                         CharLowerA((LPSTR)lParam);
2051                     else if( lphc->dwStyle & CBS_UPPERCASE )
2052                         CharUpperA((LPSTR)lParam);
2053
2054                     return SendMessageA(lphc->hWndLBox, LB_INSERTSTRING, wParam, lParam);
2055                 }
2056         case CB_DELETESTRING:
2057                 return unicode ? SendMessageW(lphc->hWndLBox, LB_DELETESTRING, wParam, 0) :
2058                                  SendMessageA(lphc->hWndLBox, LB_DELETESTRING, wParam, 0);
2059         case CB_SELECTSTRING:
2060                 return COMBO_SelectString(lphc, (INT)wParam, lParam, unicode);
2061         case CB_FINDSTRING:
2062                 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam) :
2063                                  SendMessageA(lphc->hWndLBox, LB_FINDSTRING, wParam, lParam);
2064         case CB_FINDSTRINGEXACT:
2065                 return unicode ? SendMessageW(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam) :
2066                                  SendMessageA(lphc->hWndLBox, LB_FINDSTRINGEXACT, wParam, lParam);
2067         case CB_SETITEMHEIGHT:
2068                 return  COMBO_SetItemHeight( lphc, (INT)wParam, (INT)lParam);
2069         case CB_GETITEMHEIGHT:
2070                 if( (INT)wParam >= 0 )  /* listbox item */
2071                     return SendMessageW(lphc->hWndLBox, LB_GETITEMHEIGHT, wParam, 0);
2072                 return  CBGetTextAreaHeight(hwnd, lphc);
2073         case CB_RESETCONTENT:
2074                 SendMessageW(lphc->hWndLBox, LB_RESETCONTENT, 0, 0);
2075                 if( (lphc->wState & CBF_EDIT) && CB_HASSTRINGS(lphc) )
2076                 {
2077                     static const WCHAR empty_stringW[] = { 0 };
2078                     SendMessageW(lphc->hWndEdit, WM_SETTEXT, 0, (LPARAM)empty_stringW);
2079                 }
2080                 else
2081                     InvalidateRect(lphc->self, NULL, TRUE);
2082                 return  TRUE;
2083         case CB_INITSTORAGE:
2084                 return SendMessageW(lphc->hWndLBox, LB_INITSTORAGE, wParam, lParam);
2085         case CB_GETHORIZONTALEXTENT:
2086                 return SendMessageW(lphc->hWndLBox, LB_GETHORIZONTALEXTENT, 0, 0);
2087         case CB_SETHORIZONTALEXTENT:
2088                 return SendMessageW(lphc->hWndLBox, LB_SETHORIZONTALEXTENT, wParam, 0);
2089         case CB_GETTOPINDEX:
2090                 return SendMessageW(lphc->hWndLBox, LB_GETTOPINDEX, 0, 0);
2091         case CB_GETLOCALE:
2092                 return SendMessageW(lphc->hWndLBox, LB_GETLOCALE, 0, 0);
2093         case CB_SETLOCALE:
2094                 return SendMessageW(lphc->hWndLBox, LB_SETLOCALE, wParam, 0);
2095         case CB_SETDROPPEDWIDTH:
2096                 if( (CB_GETTYPE(lphc) == CBS_SIMPLE) ||
2097                     (INT)wParam >= 32768 )
2098                     return CB_ERR;
2099                 /* new value must be higher than combobox width */
2100                 if((INT)wParam >= lphc->droppedRect.right - lphc->droppedRect.left)
2101                     lphc->droppedWidth = wParam;
2102                 else if(wParam)
2103                     lphc->droppedWidth = 0;
2104
2105                 /* recalculate the combobox area */
2106                 CBCalcPlacement(hwnd, lphc, &lphc->textRect, &lphc->buttonRect, &lphc->droppedRect );
2107
2108                 /* fall through */
2109         case CB_GETDROPPEDWIDTH:
2110                 if( lphc->droppedWidth )
2111                     return  lphc->droppedWidth;
2112                 return  lphc->droppedRect.right - lphc->droppedRect.left;
2113         case CB_GETDROPPEDCONTROLRECT:
2114                 if( lParam ) CBGetDroppedControlRect(lphc, (LPRECT)lParam );
2115                 return  CB_OKAY;
2116         case CB_GETDROPPEDSTATE:
2117                 return (lphc->wState & CBF_DROPPED) != 0;
2118         case CB_DIR:
2119                 return unicode ? SendMessageW(lphc->hWndLBox, LB_DIR, wParam, lParam) :
2120                                  SendMessageA(lphc->hWndLBox, LB_DIR, wParam, lParam);
2121
2122         case CB_SHOWDROPDOWN:
2123                 if( CB_GETTYPE(lphc) != CBS_SIMPLE )
2124                 {
2125                     if( wParam )
2126                     {
2127                         if( !(lphc->wState & CBF_DROPPED) )
2128                             CBDropDown( lphc );
2129                     }
2130                     else
2131                         if( lphc->wState & CBF_DROPPED )
2132                             CBRollUp( lphc, FALSE, TRUE );
2133                 }
2134                 return  TRUE;
2135         case CB_GETCOUNT:
2136                 return SendMessageW(lphc->hWndLBox, LB_GETCOUNT, 0, 0);
2137         case CB_GETCURSEL:
2138                 return SendMessageW(lphc->hWndLBox, LB_GETCURSEL, 0, 0);
2139         case CB_SETCURSEL:
2140                 lParam = SendMessageW(lphc->hWndLBox, LB_SETCURSEL, wParam, 0);
2141                 if( lParam >= 0 )
2142                     SendMessageW(lphc->hWndLBox, LB_SETTOPINDEX, wParam, 0);
2143
2144                 /* no LBN_SELCHANGE in this case, update manually */
2145                 CBPaintText( lphc, NULL );
2146                 lphc->wState &= ~CBF_SELCHANGE;
2147                 return  lParam;
2148         case CB_GETLBTEXT:
2149                 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXT, wParam, lParam) :
2150                                  SendMessageA(lphc->hWndLBox, LB_GETTEXT, wParam, lParam);
2151         case CB_GETLBTEXTLEN:
2152                 return unicode ? SendMessageW(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0) :
2153                                  SendMessageA(lphc->hWndLBox, LB_GETTEXTLEN, wParam, 0);
2154         case CB_GETITEMDATA:
2155                 return SendMessageW(lphc->hWndLBox, LB_GETITEMDATA, wParam, 0);
2156         case CB_SETITEMDATA:
2157                 return SendMessageW(lphc->hWndLBox, LB_SETITEMDATA, wParam, lParam);
2158         case CB_GETEDITSEL:
2159                 /* Edit checks passed parameters itself */
2160                 if( lphc->wState & CBF_EDIT )
2161                     return SendMessageW(lphc->hWndEdit, EM_GETSEL, wParam, lParam);
2162                 return  CB_ERR;
2163         case CB_SETEDITSEL:
2164                 if( lphc->wState & CBF_EDIT )
2165                     return SendMessageW(lphc->hWndEdit, EM_SETSEL,
2166                           (INT)(SHORT)LOWORD(lParam), (INT)(SHORT)HIWORD(lParam) );
2167                 return  CB_ERR;
2168         case CB_SETEXTENDEDUI:
2169                 if( CB_GETTYPE(lphc) == CBS_SIMPLE )
2170                     return  CB_ERR;
2171                 if( wParam )
2172                     lphc->wState |= CBF_EUI;
2173                 else lphc->wState &= ~CBF_EUI;
2174                 return  CB_OKAY;
2175         case CB_GETEXTENDEDUI:
2176                 return (lphc->wState & CBF_EUI) != 0;
2177         case CB_GETCOMBOBOXINFO:
2178                 return COMBO_GetComboBoxInfo(lphc, (COMBOBOXINFO *)lParam);
2179         case CB_LIMITTEXT:
2180                 if( lphc->wState & CBF_EDIT )
2181                         return SendMessageW(lphc->hWndEdit, EM_LIMITTEXT, wParam, lParam);
2182                 return  TRUE;
2183         default:
2184                 if (message >= WM_USER)
2185                     WARN("unknown msg WM_USER+%04x wp=%04lx lp=%08lx\n",
2186                         message - WM_USER, wParam, lParam );
2187                 break;
2188       }
2189       return unicode ? DefWindowProcW(hwnd, message, wParam, lParam) :
2190                        DefWindowProcA(hwnd, message, wParam, lParam);
2191 }
2192
2193 /*************************************************************************
2194  *           GetComboBoxInfo   (USER32.@)
2195  */
2196 BOOL WINAPI GetComboBoxInfo(HWND hwndCombo,      /* [in] handle to combo box */
2197                             PCOMBOBOXINFO pcbi   /* [in/out] combo box information */)
2198 {
2199     TRACE("(%p, %p)\n", hwndCombo, pcbi);
2200     return SendMessageW(hwndCombo, CB_GETCOMBOBOXINFO, 0, (LPARAM)pcbi);
2201 }