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