controls/combo.c

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