1 /*
   2  * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #include <windowsx.h>
  27 
  28 #include "awt_Toolkit.h"
  29 #include "awt_Choice.h"
  30 #include "awt_Canvas.h"
  31 
  32 #include "awt_Dimension.h"
  33 #include "awt_Container.h"
  34 
  35 #include "ComCtl32Util.h"
  36 
  37 #include <java_awt_Toolkit.h>
  38 #include <java_awt_FontMetrics.h>
  39 #include <java_awt_event_InputEvent.h>
  40 
  41 /* IMPORTANT! Read the README.JNI file for notes on JNI converted AWT code.
  42  */
  43 
  44 /************************************************************************/
  45 // Struct for _Reshape() method
  46 struct ReshapeStruct {
  47     jobject choice;
  48     jint x, y;
  49     jint width, height;
  50 };
  51 // Struct for _Select() method
  52 struct SelectStruct {
  53     jobject choice;
  54     jint index;
  55 };
  56 // Struct for _AddItems() method
  57 struct AddItemsStruct {
  58     jobject choice;
  59     jobjectArray items;
  60     jint index;
  61 };
  62 // Struct for _Remove() method
  63 struct RemoveStruct {
  64     jobject choice;
  65     jint index;
  66 };
  67 
  68 /************************************************************************/
  69 
  70 /* Bug #4509045: set if SetDragCapture captured mouse */
  71 
  72 BOOL AwtChoice::mouseCapture = FALSE;
  73 
  74 /* Bug #4338368: consume the spurious MouseUp when the choice loses focus */
  75 
  76 BOOL AwtChoice::skipNextMouseUp = FALSE;
  77 
  78 BOOL AwtChoice::sm_isMouseMoveInList = FALSE;
  79 
  80 static const UINT MINIMUM_NUMBER_OF_VISIBLE_ITEMS = 8;
  81 
  82 namespace {
  83     jfieldID selectedIndexID;
  84 }
  85 
  86 /*************************************************************************
  87  * AwtChoice class methods
  88  */
  89 
  90 AwtChoice::AwtChoice() {
  91     m_hList = NULL;
  92     m_listDefWindowProc = NULL;

  93 }
  94 
  95 LPCTSTR AwtChoice::GetClassName() {
  96     return TEXT("COMBOBOX");  /* System provided combobox class */
  97 }
  98 
  99 void AwtChoice::Dispose() {
 100     if (m_hList != NULL && m_listDefWindowProc != NULL) {
 101         ComCtl32Util::GetInstance().UnsubclassHWND(m_hList, ListWindowProc, m_listDefWindowProc);
 102     }
 103     AwtComponent::Dispose();
 104 }
 105 
 106 AwtChoice* AwtChoice::Create(jobject peer, jobject parent) {
 107 

 108     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 109 
 110     jobject target = NULL;
 111     AwtChoice* c = NULL;
 112     RECT rc;
 113 
 114     try {
 115         if (env->EnsureLocalCapacity(1) < 0) {
 116             return NULL;
 117         }
 118         AwtCanvas* awtParent;
 119 
 120         JNI_CHECK_NULL_GOTO(parent, "null parent", done);
 121 
 122         awtParent = (AwtCanvas*)JNI_GET_PDATA(parent);
 123         JNI_CHECK_NULL_GOTO(awtParent, "null awtParent", done);
 124 
 125         target = env->GetObjectField(peer, AwtObject::targetID);
 126         JNI_CHECK_NULL_GOTO(target, "null target", done);
 127 
 128         c = new AwtChoice();
 129 
 130         {
 131             DWORD style = WS_CHILD | WS_CLIPSIBLINGS | WS_VSCROLL |
 132                           CBS_DROPDOWNLIST | CBS_OWNERDRAWFIXED;
 133             DWORD exStyle = 0;
 134             if (GetRTL()) {
 135                 exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
 136                 if (GetRTLReadingOrder())
 137                     exStyle |= WS_EX_RTLREADING;
 138             }
 139 
 140             /*
 141              * In OWNER_DRAW, the size of the edit control part of the
 142              * choice must be determinded in its creation, when the parent
 143              * cannot get the choice's instance from its handle.  So
 144              * record the pair of the ID and the instance of the choice.
 145              */
 146             UINT myId = awtParent->CreateControlID();
 147             DASSERT(myId > 0);
 148             c->m_myControlID = myId;
 149             awtParent->PushChild(myId, c);
 150 
 151             jint x = env->GetIntField(target, AwtComponent::xID);
 152             jint y = env->GetIntField(target, AwtComponent::yID);
 153             jint width = env->GetIntField(target, AwtComponent::widthID);
 154             jint height = env->GetIntField(target, AwtComponent::heightID);
 155 
 156             jobject dimension = JNU_CallMethodByName(env, NULL, peer,
 157                                                      "preferredSize",
 158                                                      "()Ljava/awt/Dimension;").l;
 159             DASSERT(!safe_ExceptionOccurred(env));
 160 
 161             if (dimension != NULL && width == 0) {
 162                 width = env->GetIntField(dimension, AwtDimension::widthID);
 163             }
 164             c->CreateHWnd(env, L"", style, exStyle,
 165                           x, y, width, height,
 166                           awtParent->GetHWnd(),
 167                           reinterpret_cast<HMENU>(static_cast<INT_PTR>(myId)),
 168                           ::GetSysColor(COLOR_WINDOWTEXT),
 169                           ::GetSysColor(COLOR_WINDOW),
 170                           peer);
 171 
 172             /* suppress inheriting parent's color. */
 173             c->m_backgroundColorSet = TRUE;
 174             c->UpdateBackground(env, target);
 175 
 176             /* Bug 4255631 Solaris: Size returned by Choice.getSize() does not match
 177              * actual size
 178              * Fix: Set the Choice to its actual size in the component.
 179              */
 180             ::GetClientRect(c->GetHWnd(), &rc);
 181             env->SetIntField(target, AwtComponent::widthID,  (jint) rc.right);
 182             env->SetIntField(target, AwtComponent::heightID, (jint) rc.bottom);
 183 
 184             if (IS_WINXP) {
 185                 ::SendMessage(c->GetHWnd(), CB_SETMINVISIBLE, (WPARAM) MINIMUM_NUMBER_OF_VISIBLE_ITEMS, 0);
 186             }
 187 
 188             env->DeleteLocalRef(dimension);
 189         }
 190     } catch (...) {
 191         env->DeleteLocalRef(target);
 192         throw;
 193     }
 194 
 195 done:
 196     env->DeleteLocalRef(target);
 197 
 198     return c;
 199 }
 200 
 201 // calculate height of drop-down list part of the combobox
 202 // to show all the items up to a maximum of eight
 203 int AwtChoice::GetDropDownHeight()
 204 {
 205     int itemHeight =(int)::SendMessage(GetHWnd(), CB_GETITEMHEIGHT, (UINT)0,0);
 206     int numItemsToShow = (int)::SendMessage(GetHWnd(), CB_GETCOUNT, 0,0);
 207     numItemsToShow = min(MINIMUM_NUMBER_OF_VISIBLE_ITEMS, numItemsToShow);
 208     // drop-down height snaps to nearest line, so add a
 209     // fudge factor of 1/2 line to ensure last line shows
 210     return itemHeight*numItemsToShow + itemHeight/2;
 211 }
 212 
 213 // get the height of the field portion of the combobox
 214 int AwtChoice::GetFieldHeight()
 215 {
 216     int fieldHeight;
 217     int borderHeight;
 218     fieldHeight =(int)::SendMessage(GetHWnd(), CB_GETITEMHEIGHT, (UINT)-1, 0);
 219     // add top and bottom border lines; border size is different for
 220     // Win 4.x (3d edge) vs 3.x (1 pixel line)
 221     borderHeight = ::GetSystemMetrics(SM_CYEDGE);
 222     fieldHeight += borderHeight*2;
 223     return fieldHeight;
 224 }
 225 
 226 // gets the total height of the combobox, including drop down
 227 int AwtChoice::GetTotalHeight()
 228 {
 229     int dropHeight = GetDropDownHeight();
 230     int fieldHeight = GetFieldHeight();
 231     int totalHeight;
 232 
 233     // border on drop-down portion is always non-3d (so don't use SM_CYEDGE)
 234     int borderHeight = ::GetSystemMetrics(SM_CYBORDER);
 235     // total height = drop down height + field height + top+bottom drop down border lines
 236     totalHeight = dropHeight + fieldHeight +borderHeight*2;
 237     return totalHeight;
 238 }
 239 
 240 // Recalculate and set the drop-down height for the Choice.
 241 void AwtChoice::ResetDropDownHeight()
 242 {
 243     RECT    rcWindow;
 244 
 245     ::GetWindowRect(GetHWnd(), &rcWindow);
 246     // resize the drop down to accomodate added/removed items
 247     int     totalHeight = GetTotalHeight();
 248     ::SetWindowPos(GetHWnd(), NULL,
 249                     0, 0, rcWindow.right - rcWindow.left, totalHeight,
 250                     SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
 251 }
 252 
 253 /* Fix for the bug 4327666: set the capture for middle
 254    and right mouse buttons, but leave left button alone */
 255 void AwtChoice::SetDragCapture(UINT flags)
 256 {
 257     if ((flags & MK_LBUTTON) != 0) {
 258         if ((::GetCapture() == GetHWnd()) && mouseCapture) {
 259             /* On MK_LBUTTON ComboBox captures mouse itself
 260                so we should release capture and clear flag to
 261                prevent releasing capture by ReleaseDragCapture
 262              */
 263             ::ReleaseCapture();
 264             mouseCapture = FALSE;
 265         }
 266         return;
 267     }
 268 
 269     // don't want to interfere with other controls
 270     if (::GetCapture() == NULL) {
 271         ::SetCapture(GetHWnd());
 272         mouseCapture = TRUE;
 273     }
 274 }
 275 
 276 /* Fix for Bug 4509045: should release capture only if it is set by SetDragCapture */
 277 void AwtChoice::ReleaseDragCapture(UINT flags)
 278 {
 279     if ((::GetCapture() == GetHWnd()) && ((flags & ALL_MK_BUTTONS) == 0) && mouseCapture) {
 280         ::ReleaseCapture();
 281         mouseCapture = FALSE;
 282     }
 283 }
 284 
 285 void AwtChoice::Reshape(int x, int y, int w, int h)
 286 {
 287     // Choice component height is fixed (when rolled up)
 288     // so vertically center the choice in it's bounding box
 289     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 290     jobject target = GetTarget(env);
 291     jobject parent = env->GetObjectField(target, AwtComponent::parentID);
 292     RECT rc;
 293 
 294     int fieldHeight = GetFieldHeight();
 295     if ((parent != NULL && env->GetObjectField(parent, AwtContainer::layoutMgrID) != NULL) &&
 296         fieldHeight > 0 && fieldHeight < h) {
 297         y += (h - fieldHeight) / 2;
 298     }
 299 
 300     /* Fix for 4783342
 301      * Choice should ignore reshape on height changes,
 302      * as height is dependent on Font size only.
 303      */
 304     AwtComponent* awtParent = GetParent();
 305     BOOL bReshape = true;
 306     if (awtParent != NULL) {
 307         ::GetWindowRect(GetHWnd(), &rc);
 308         int oldW = rc.right - rc.left;
 309         RECT parentRc;
 310         ::GetWindowRect(awtParent->GetHWnd(), &parentRc);
 311         int oldX = rc.left - parentRc.left;
 312         int oldY = rc.top - parentRc.top;
 313         bReshape = (x != oldX || y != oldY || w != oldW);
 314     }
 315 
 316     if (bReshape)
 317     {
 318         int totalHeight = GetTotalHeight();
 319         AwtComponent::Reshape(x, y, w, totalHeight);
 320     }
 321 
 322     /* Bug 4255631 Solaris: Size returned by Choice.getSize() does not match
 323      * actual size
 324      * Fix: Set the Choice to its actual size in the component.
 325      */
 326     ::GetClientRect(GetHWnd(), &rc);
 327     env->SetIntField(target, AwtComponent::widthID,  (jint)rc.right);
 328     env->SetIntField(target, AwtComponent::heightID, (jint)rc.bottom);
 329 
 330     env->DeleteLocalRef(target);
 331     env->DeleteLocalRef(parent);
 332 }
 333 
 334 jobject AwtChoice::PreferredItemSize(JNIEnv *env)
 335 {
 336     jobject dimension = JNU_CallMethodByName(env, NULL, GetPeer(env),
 337                                              "preferredSize",
 338                                              "()Ljava/awt/Dimension;").l;
 339     DASSERT(!safe_ExceptionOccurred(env));
 340     if (dimension == NULL) {
 341         return NULL;
 342     }
 343     /* This size is window size of choice and it's too big for each
 344      * drop down item height.
 345      */
 346     env->SetIntField(dimension, AwtDimension::heightID,
 347                        GetFontHeight(env));
 348     return dimension;
 349 }
 350 
 351 void AwtChoice::SetFont(AwtFont* font)
 352 {
 353     AwtComponent::SetFont(font);
 354 
 355     //Get the text metrics and change the height of each item.
 356     HDC hDC = ::GetDC(GetHWnd());
 357     DASSERT(hDC != NULL);
 358     TEXTMETRIC tm;
 359 
 360     HANDLE hFont = font->GetHFont();
 361     VERIFY(::SelectObject(hDC, hFont) != NULL);
 362     VERIFY(::GetTextMetrics(hDC, &tm));
 363     long h = tm.tmHeight + tm.tmExternalLeading;
 364     VERIFY(::ReleaseDC(GetHWnd(), hDC) != 0);
 365 
 366     int nCount = (int)::SendMessage(GetHWnd(), CB_GETCOUNT, 0, 0);
 367     for(int i = 0; i < nCount; ++i) {
 368         VERIFY(::SendMessage(GetHWnd(), CB_SETITEMHEIGHT, i, MAKELPARAM(h, 0)) != CB_ERR);
 369     }
 370     //Change the height of the Edit Box.
 371     VERIFY(::SendMessage(GetHWnd(), CB_SETITEMHEIGHT, (UINT)-1,
 372                          MAKELPARAM(h, 0)) != CB_ERR);
 373 
 374     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 375     jobject target = GetTarget(env);
 376     jint height = env->GetIntField(target, AwtComponent::heightID);
 377 
 378     Reshape(env->GetIntField(target, AwtComponent::xID),
 379             env->GetIntField(target, AwtComponent::yID),
 380             env->GetIntField(target, AwtComponent::widthID),
 381             h);
 382 
 383     env->DeleteLocalRef(target);
 384 }
 385 
 386 static int lastClickX = -1;
 387 static int lastClickY = -1;
 388 
 389 LRESULT CALLBACK AwtChoice::ListWindowProc(HWND hwnd, UINT message,
 390                                            WPARAM wParam, LPARAM lParam)
 391 {
 392     /*
 393      * We don't pass the choice WM_LBUTTONDOWN message. As the result the choice's list
 394      * doesn't forward mouse messages it captures. Below we do forward what we need.
 395      */
 396 
 397     TRY;
 398 
 399     DASSERT(::IsWindow(hwnd));
 400 
 401     switch (message) {
 402         case WM_LBUTTONDOWN: {
 403             DWORD curPos = ::GetMessagePos();
 404             lastClickX = GET_X_LPARAM(curPos);
 405             lastClickY = GET_Y_LPARAM(curPos);
 406             break;
 407         }
 408         case WM_MOUSEMOVE: {
 409             RECT rect;
 410             ::GetClientRect(hwnd, &rect);
 411 
 412             POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
 413             if (::PtInRect(&rect, pt)) {
 414                 sm_isMouseMoveInList = TRUE;
 415             }
 416 
 417             POINT lastPt = {lastClickX, lastClickY};
 418             ::ScreenToClient(hwnd, &lastPt);
 419             if (::PtInRect(&rect, lastPt)) {
 420                 break; // ignore when dragging inside the list
 421             }
 422         }
 423         case WM_LBUTTONUP: {
 424             lastClickX = -1;
 425             lastClickY = -1;
 426 
 427             AwtChoice *c = (AwtChoice *)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
 428             if (c != NULL) {
 429                 // forward the msg to the choice
 430                 c->WindowProc(message, wParam, lParam);
 431             }
 432         }
 433     }
 434     return ComCtl32Util::GetInstance().DefWindowProc(NULL, hwnd, message, wParam, lParam);
 435 
 436     CATCH_BAD_ALLOC_RET(0);
 437 }
 438 
 439 
 440 MsgRouting AwtChoice::WmNotify(UINT notifyCode)
 441 {
 442     if (notifyCode == CBN_SELCHANGE) {
 443         int selectedIndex = (int)SendMessage(CB_GETCURSEL);
 444         
 445         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 446         jobject target = GetTarget(env);
 447         int previousIndex = env->GetIntField(target, selectedIndexID);
 448         
 449         if (selectedIndex != CB_ERR && selectedIndex != previousIndex){
 450             DoCallback("handleAction", "(I)V", selectedIndex);
 451         }
 452     } else if (notifyCode == CBN_DROPDOWN) {
 453 
 454         if (m_hList == NULL) {
 455             COMBOBOXINFO cbi;
 456             cbi.cbSize = sizeof(COMBOBOXINFO);
 457             ::GetComboBoxInfo(GetHWnd(), &cbi);
 458             m_hList = cbi.hwndList;
 459             m_listDefWindowProc = ComCtl32Util::GetInstance().SubclassHWND(m_hList, ListWindowProc);
 460             DASSERT(::GetWindowLongPtr(m_hList, GWLP_USERDATA) == NULL);
 461             ::SetWindowLongPtr(m_hList, GWLP_USERDATA, (LONG_PTR)this);
 462         }
 463         sm_isMouseMoveInList = FALSE;
 464 
 465         // Clicking in the dropdown list steals focus from the proxy.
 466         // So, set the focus-restore flag up.
 467         SetRestoreFocus(TRUE);
 468     } else if (notifyCode == CBN_CLOSEUP) {
 469         SetRestoreFocus(FALSE);
 470     }
 471     return mrDoDefault;
 472 }
 473 
 474 MsgRouting
 475 AwtChoice::OwnerDrawItem(UINT /*ctrlId*/, DRAWITEMSTRUCT& drawInfo)
 476 {
 477     DrawListItem((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), drawInfo);
 478     return mrConsume;
 479 }
 480 
 481 MsgRouting
 482 AwtChoice::OwnerMeasureItem(UINT /*ctrlId*/, MEASUREITEMSTRUCT& measureInfo)
 483 {
 484     MeasureListItem((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2), measureInfo);
 485     return mrConsume;
 486 }
 487 
 488 /* Bug #4338368: when a choice loses focus, it triggers spurious MouseUp event,
 489  * even if the focus was lost due to TAB key pressing
 490  */
 491 
 492 MsgRouting
 493 AwtChoice::WmKillFocus(HWND hWndGotFocus)
 494 {
 495     skipNextMouseUp = TRUE;
 496     return AwtComponent::WmKillFocus(hWndGotFocus);
 497 }
 498 
 499 MsgRouting
 500 AwtChoice::WmMouseUp(UINT flags, int x, int y, int button)
 501 {
 502     if (skipNextMouseUp) {
 503         skipNextMouseUp = FALSE;
 504         return mrDoDefault;
 505     }
 506     return AwtComponent::WmMouseUp(flags, x, y, button);
 507 }
 508 
 509 MsgRouting AwtChoice::HandleEvent(MSG *msg, BOOL synthetic)
 510 {
 511     if (IsFocusingMouseMessage(msg)) {
 512         SendMessage(CB_SHOWDROPDOWN, ~SendMessage(CB_GETDROPPEDSTATE, 0, 0), 0);
 513         delete msg;
 514         return mrConsume;
 515     }
 516     // To simulate the native behavior, we close the list on WM_LBUTTONUP if
 517     // WM_MOUSEMOVE has been dedected on the list since it has been dropped down.
 518     if (msg->message == WM_LBUTTONUP && SendMessage(CB_GETDROPPEDSTATE, 0, 0) &&
 519         sm_isMouseMoveInList)
 520     {
 521         SendMessage(CB_SHOWDROPDOWN, FALSE, 0);
 522     }
 523     return AwtComponent::HandleEvent(msg, synthetic);
 524 }
 525 
 526 BOOL AwtChoice::InheritsNativeMouseWheelBehavior() {return true;}
 527 
 528 void AwtChoice::_Reshape(void *param)
 529 {
 530     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 531 
 532     ReshapeStruct *rs = (ReshapeStruct *)param;
 533     jobject choice = rs->choice;
 534     jint x = rs->x;
 535     jint y = rs->y;
 536     jint width = rs->width;
 537     jint height = rs->height;
 538 
 539     AwtChoice *c = NULL;
 540 
 541     PDATA pData;
 542     JNI_CHECK_PEER_GOTO(choice, done);
 543 
 544     c = (AwtChoice *)pData;
 545     if (::IsWindow(c->GetHWnd()))
 546     {
 547         c->Reshape(x, y, width, height);
 548         c->VerifyState();
 549     }
 550 
 551 done:
 552     env->DeleteGlobalRef(choice);
 553 
 554     delete rs;
 555 }
 556 
 557 void AwtChoice::_Select(void *param)
 558 {
 559     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 560 
 561     SelectStruct *ss = (SelectStruct *)param;
 562     jobject choice = ss->choice;
 563     jint index = ss->index;
 564 
 565     AwtChoice *c = NULL;
 566 
 567     PDATA pData;
 568     JNI_CHECK_PEER_GOTO(choice, done);
 569 
 570     c = (AwtChoice *)pData;
 571     if (::IsWindow(c->GetHWnd()))
 572     {
 573         c->SendMessage(CB_SETCURSEL, index);
 574 //        c->VerifyState();
 575     }
 576 
 577 done:
 578     env->DeleteGlobalRef(choice);
 579 
 580     delete ss;
 581 }
 582 
 583 void AwtChoice::_AddItems(void *param)
 584 {
 585     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 586 
 587     AddItemsStruct *ais = (AddItemsStruct *)param;
 588     jobject choice = ais->choice;
 589     jobjectArray items = ais->items;
 590     jint index = ais->index;
 591 
 592     AwtChoice *c = NULL;
 593 
 594     PDATA pData;
 595     JNI_CHECK_PEER_GOTO(choice, done);
 596     JNI_CHECK_NULL_GOTO(items, "null items", done);
 597 
 598     c = (AwtChoice *)pData;
 599     if (::IsWindow(c->GetHWnd()))
 600     {
 601         jsize i;
 602         int itemCount = env->GetArrayLength(items);
 603         if (itemCount > 0) {
 604            c->SendMessage(WM_SETREDRAW, (WPARAM)FALSE, 0);
 605            for (i = 0; i < itemCount; i++)
 606            {
 607                jstring item = (jstring)env->GetObjectArrayElement(items, i);
 608                JNI_CHECK_NULL_GOTO(item, "null item", next_elem);
 609                c->SendMessage(CB_INSERTSTRING, index + i, JavaStringBuffer(env, item));
 610                env->DeleteLocalRef(item);
 611 next_elem:
 612                ;
 613            }
 614            c->SendMessage(WM_SETREDRAW, (WPARAM)TRUE, 0);
 615            InvalidateRect(c->GetHWnd(), NULL, TRUE);
 616            c->ResetDropDownHeight();
 617            c->VerifyState();
 618         }
 619     }
 620 
 621 done:
 622     env->DeleteGlobalRef(choice);
 623     env->DeleteGlobalRef(items);
 624 
 625     delete ais;
 626 }
 627 
 628 void AwtChoice::_Remove(void *param)
 629 {
 630     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 631 
 632     RemoveStruct *rs = (RemoveStruct *)param;
 633     jobject choice = rs->choice;
 634     jint index = rs->index;
 635 
 636     AwtChoice *c = NULL;
 637 
 638     PDATA pData;
 639     JNI_CHECK_PEER_GOTO(choice, done);
 640 
 641     c = (AwtChoice *)pData;
 642     if (::IsWindow(c->GetHWnd()))
 643     {
 644         c->SendMessage(CB_DELETESTRING, index, 0);
 645         c->ResetDropDownHeight();
 646         c->VerifyState();
 647     }
 648 
 649 done:
 650     env->DeleteGlobalRef(choice);
 651 
 652     delete rs;
 653 }
 654 
 655 void AwtChoice::_RemoveAll(void *param)
 656 {
 657     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 658 
 659     jobject choice = (jobject)param;
 660 
 661     AwtChoice *c = NULL;
 662 
 663     PDATA pData;
 664     JNI_CHECK_PEER_GOTO(choice, done);
 665 
 666     c = (AwtChoice *)pData;
 667     if (::IsWindow(c->GetHWnd()))
 668     {
 669         c->SendMessage(CB_RESETCONTENT, 0, 0);
 670         c->ResetDropDownHeight();
 671         c->VerifyState();
 672     }
 673 
 674 done:
 675     env->DeleteGlobalRef(choice);
 676 }
 677 
 678 void AwtChoice::_CloseList(void *param)
 679 {
 680     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 681 
 682     jobject choice = (jobject)param;
 683 
 684     AwtChoice *c = NULL;
 685 
 686     PDATA pData;
 687     JNI_CHECK_PEER_GOTO(choice, done);
 688 
 689     c = (AwtChoice *)pData;
 690     if (::IsWindow(c->GetHWnd()) && c->SendMessage(CB_GETDROPPEDSTATE, 0, 0)) {
 691         c->SendMessage(CB_SHOWDROPDOWN, FALSE, 0);
 692     }
 693 
 694 done:
 695     env->DeleteGlobalRef(choice);
 696 }
 697 
 698 /************************************************************************
 699  * WChoicePeer native methods
 700  */
 701 
 702 extern "C" {
 703 
 704 JNIEXPORT void JNICALL
 705 Java_java_awt_Choice_initIDs(JNIEnv *env, jclass cls)
 706 {
 707     TRY;
 708     selectedIndexID = env->GetFieldID(cls, "selectedIndex", "I");
 709     DASSERT(selectedIndexID);
 710     CATCH_BAD_ALLOC;
 711 }
 712 
 713 /*
 714  * Class:     sun_awt_windows_WChoicePeer
 715  * Method:    select
 716  * Signature: (I)V
 717  */
 718 JNIEXPORT void JNICALL
 719 Java_sun_awt_windows_WChoicePeer_select(JNIEnv *env, jobject self,
 720                                         jint index)
 721 {
 722     TRY;
 723 
 724     SelectStruct *ss = new SelectStruct;
 725     ss->choice = env->NewGlobalRef(self);
 726     ss->index = index;
 727 
 728     AwtToolkit::GetInstance().SyncCall(AwtChoice::_Select, ss);
 729     // global refs and ss are removed in _Select
 730 
 731     CATCH_BAD_ALLOC;
 732 }
 733 
 734 /*
 735  * Class:     sun_awt_windows_WChoicePeer
 736  * Method:    remove
 737  * Signature: (I)V
 738  */
 739 JNIEXPORT void JNICALL
 740 Java_sun_awt_windows_WChoicePeer_remove(JNIEnv *env, jobject self,
 741                                         jint index)
 742 {
 743     TRY;
 744 
 745     RemoveStruct *rs = new RemoveStruct;
 746     rs->choice = env->NewGlobalRef(self);
 747     rs->index = index;
 748 
 749     AwtToolkit::GetInstance().SyncCall(AwtChoice::_Remove, rs);
 750     // global ref and rs are deleted in _Remove
 751 
 752     CATCH_BAD_ALLOC;
 753 }
 754 
 755 /*
 756  * Class:     sun_awt_windows_WChoicePeer
 757  * Method:    removeAll
 758  * Signature: ()V
 759  */
 760 JNIEXPORT void JNICALL
 761 Java_sun_awt_windows_WChoicePeer_removeAll(JNIEnv *env, jobject self)
 762 {
 763     TRY;
 764 
 765     jobject selfGlobalRef = env->NewGlobalRef(self);
 766 
 767     AwtToolkit::GetInstance().SyncCall(AwtChoice::_RemoveAll, (void *)selfGlobalRef);
 768     // selfGlobalRef is deleted in _RemoveAll
 769 
 770     CATCH_BAD_ALLOC;
 771 }
 772 
 773 /*
 774  * Class:     sun_awt_windows_WChoicePeer
 775  * Method:    addItems
 776  * Signature: ([Ljava/lang/String;I)V
 777  */
 778 JNIEXPORT void JNICALL
 779 Java_sun_awt_windows_WChoicePeer_addItems(JNIEnv *env, jobject self,
 780                                           jobjectArray items, jint index)
 781 {
 782     TRY;
 783 
 784     AddItemsStruct *ais = new AddItemsStruct;
 785     ais->choice = env->NewGlobalRef(self);
 786     ais->items = (jobjectArray)env->NewGlobalRef(items);
 787     ais->index = index;
 788 
 789     AwtToolkit::GetInstance().SyncCall(AwtChoice::_AddItems, ais);
 790     // global refs and ais are deleted in _AddItems
 791 
 792     CATCH_BAD_ALLOC;
 793 }
 794 
 795 /*
 796  * Class:     sun_awt_windows_WChoicePeer
 797  * Method:    reshape
 798  * Signature: (IIII)V
 799  */
 800 JNIEXPORT void JNICALL
 801 Java_sun_awt_windows_WChoicePeer_reshape(JNIEnv *env, jobject self,
 802                                          jint x, jint y,
 803                                          jint width, jint height)
 804 {
 805     TRY;
 806 
 807     ReshapeStruct *rs = new ReshapeStruct;
 808     rs->choice = env->NewGlobalRef(self);
 809     rs->x = x;
 810     rs->y = y;
 811     rs->width = width;
 812     rs->height = height;
 813 
 814     AwtToolkit::GetInstance().SyncCall(AwtChoice::_Reshape, rs);
 815     // global ref and rs are deleted in _Reshape
 816 
 817     CATCH_BAD_ALLOC;
 818 }
 819 
 820 /*
 821  * Class:     sun_awt_windows_WChoicePeer
 822  * Method:    create
 823  * Signature: (Lsun/awt/windows/WComponentPeer;)V
 824  */
 825 JNIEXPORT void JNICALL
 826 Java_sun_awt_windows_WChoicePeer_create(JNIEnv *env, jobject self,
 827                                         jobject parent)
 828 {
 829     TRY;
 830 
 831     PDATA pData;
 832     JNI_CHECK_PEER_RETURN(parent);
 833     AwtToolkit::CreateComponent(self, parent,
 834                                 (AwtToolkit::ComponentFactory)
 835                                 AwtChoice::Create);
 836     JNI_CHECK_PEER_CREATION_RETURN(self);
 837 
 838     CATCH_BAD_ALLOC;
 839 }
 840 
 841 /*
 842  * Class:     sun_awt_windows_WChoicePeer
 843  * Method:    closeList
 844  * Signature: ()V
 845  */
 846 JNIEXPORT void JNICALL
 847 Java_sun_awt_windows_WChoicePeer_closeList(JNIEnv *env, jobject self)
 848 {
 849     TRY;
 850 
 851     jobject selfGlobalRef = env->NewGlobalRef(self);
 852 
 853     AwtToolkit::GetInstance().SyncCall(AwtChoice::_CloseList, (void *)selfGlobalRef);
 854     // global ref is deleted in _CloseList
 855 
 856     CATCH_BAD_ALLOC;
 857 }
 858 } /* extern "C" */
 859 
 860 
 861 /************************************************************************
 862  * Diagnostic routines
 863  */
 864 
 865 #ifdef DEBUG
 866 
 867 void AwtChoice::VerifyState()
 868 {
 869     if (AwtToolkit::GetInstance().VerifyComponents() == FALSE) {
 870         return;
 871     }
 872 
 873     if (m_callbacksEnabled == FALSE) {
 874         /* Component is not fully setup yet. */
 875         return;
 876     }
 877 
 878     AwtComponent::VerifyState();
 879     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 880     if (env->PushLocalFrame(1) < 0)
 881         return;
 882 
 883     jobject target = GetTarget(env);
 884 
 885     // To avoid possibly running client code on the toolkit thread, don't
 886     // do the following checks if we're running on the toolkit thread.
 887     if (AwtToolkit::MainThread() != ::GetCurrentThreadId()) {
 888         // Compare number of items.
 889         int nTargetItems = JNU_CallMethodByName(env, NULL, target,
 890                                                 "countItems", "()I").i;
 891         DASSERT(!safe_ExceptionOccurred(env));
 892         int nPeerItems = (int)::SendMessage(GetHWnd(), CB_GETCOUNT, 0, 0);
 893         DASSERT(nTargetItems == nPeerItems);
 894 
 895         // Compare selection
 896         int targetIndex = JNU_CallMethodByName(env, NULL, target,
 897                                                "getSelectedIndex", "()I").i;
 898         DASSERT(!safe_ExceptionOccurred(env));
 899         int peerCurSel = (int)::SendMessage(GetHWnd(), CB_GETCURSEL, 0, 0);
 900         DASSERT(targetIndex == peerCurSel);
 901     }
 902     env->PopLocalFrame(0);
 903 }
 904 #endif //DEBUG
--- EOF ---