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