1 /*

     2  * Copyright 1995-2004 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 #ifdef HEADLESS

    27     #error This file should not be included in headless library

    28 #endif

    29 

    30 #include "awt_p.h"

    31 #include <Xm/Separator.h>

    32 #include "java_awt_MenuItem.h"

    33 #include "sun_awt_motif_MMenuItemPeer.h"

    34 #include "sun_awt_motif_MCheckboxMenuItemPeer.h"

    35 #include "java_awt_Menu.h"

    36 #include "sun_awt_motif_MMenuPeer.h"

    37 

    38 #include "awt_MenuComponent.h"

    39 #include "awt_MenuItem.h"

    40 

    41 #include "multi_font.h"

    42 #include <jni.h>

    43 #include <jni_util.h>

    44 #include <jlong.h>

    45 

    46 extern struct MenuComponentIDs menuComponentIDs;

    47 

    48 /* fieldIDs for MenuItem fields that may be accessed from C */

    49 struct MenuItemIDs menuItemIDs;

    50 

    51 /*

    52  * Class:     java_awt_MenuItem

    53  * Method:    initIDs

    54  * Signature: ()V

    55  */

    56 

    57 /* This function gets called from the static initializer for

    58    MenuItem.java to initialize the fieldIDs for fields that may

    59    be accessed from C */

    60 

    61 JNIEXPORT void JNICALL Java_java_awt_MenuItem_initIDs

    62   (JNIEnv *env, jclass cls)

    63 {

    64     menuItemIDs.label =

    65       (*env)->GetFieldID(env, cls, "label", "Ljava/lang/String;");

    66     menuItemIDs.enabled =

    67       (*env)->GetFieldID(env, cls, "enabled", "Z");

    68     menuItemIDs.shortcut =

    69       (*env)->GetFieldID(env, cls, "shortcut", "Ljava/awt/MenuShortcut;");

    70 }

    71 

    72 /* fieldIDs for MMenuItemPeer fields that may be accessed from C */

    73 struct MMenuItemPeerIDs mMenuItemPeerIDs;

    74 

    75 /*

    76  * Class:     sun_awt_motif_MMenuItemPeer

    77  * Method:    initIDs

    78  * Signature: ()V

    79  */

    80 

    81 /* This function gets called from the static initializer for

    82    MMenuItemPeer.java to initialize the fieldIDs for fields that may

    83    be accessed from C */

    84 

    85 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_initIDs

    86   (JNIEnv *env, jclass cls)

    87 {

    88     mMenuItemPeerIDs.target =

    89       (*env)->GetFieldID(env, cls, "target", "Ljava/awt/MenuItem;");

    90     mMenuItemPeerIDs.pData = (*env)->GetFieldID(env, cls, "pData", "J");

    91     mMenuItemPeerIDs.isCheckbox =

    92       (*env)->GetFieldID(env, cls, "isCheckbox", "Z");

    93     mMenuItemPeerIDs.jniGlobalRef =

    94       (*env)->GetFieldID(env, cls, "jniGlobalRef", "J");

    95 }

    96 

    97 /*

    98  * Class:     sun_awt_motif_MMenuItemPeer

    99  * Method:    getParent_NoClientCode

   100  * Signature: (Ljava/awt/MenuComponent;)Ljava/awt/MenuContainer;

   101  *

   102  * Gets the MenuContainer parent of this object, without executing client

   103  * code (e.g., no code in subclasses will be executed).

   104  */

   105 JNIEXPORT jobject JNICALL Java_sun_awt_motif_MMenuItemPeer_getParent_1NoClientCode

   106   (JNIEnv *env, jclass thisClass, jobject menuComponent)

   107 {

   108     jobject parent = NULL;

   109 

   110     /* getParent is actually getParent_NoClientCode() */

   111     parent = (*env)->CallObjectMethod(

   112                         env,menuComponent,menuComponentIDs.getParent);

   113     DASSERT(!((*env)->ExceptionOccurred(env)));

   114     return parent;

   115 }

   116 

   117 /*

   118  *  client_data is MMenuItemPeer instance pointer

   119  */

   120 static void

   121 MenuItem_selected(Widget w, XtPointer client_data, XmAnyCallbackStruct * s)

   122 {

   123     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   124     jobject this = (jobject) client_data;

   125     ConvertEventTimeAndModifiers converted;

   126 

   127     awt_util_convertEventTimeAndModifiers(s->event, &converted);

   128 

   129     if ((*env)->GetBooleanField(env, this, mMenuItemPeerIDs.isCheckbox)) {

   130         jboolean state;

   131         struct MenuItemData *mdata;

   132 

   133         mdata = (struct MenuItemData *)

   134           JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   135 

   136         if (mdata != NULL) {

   137             XtVaGetValues(mdata->comp.widget, XmNset, &state, NULL);

   138 

   139             JNU_CallMethodByName(env, NULL, this

   140                                  ,"action"

   141                                  ,"(JIZ)V"

   142                                  ,converted.when, converted.modifiers,

   143                                  state);

   144             if ((*env)->ExceptionOccurred(env)) {

   145                 (*env)->ExceptionDescribe(env);

   146                 (*env)->ExceptionClear(env);

   147             }

   148         }

   149     } else {

   150         JNU_CallMethodByName(env, NULL, this, "action", "(JI)V",

   151                              converted.when, converted.modifiers);

   152         if ((*env)->ExceptionOccurred(env)) {

   153             (*env)->ExceptionDescribe(env);

   154             (*env)->ExceptionClear(env);

   155         }

   156     }

   157 }

   158 

   159 /*

   160  * Class:     sun_awt_motif_MMenuItemPeer

   161  * Method:    createMenuItem

   162  * Signature: (Lsun/awt/motif/MMenuPeer;)V

   163  *

   164  * ASSUMES: This function is never called by a privileged thread

   165  */

   166 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_createMenuItem(

   167 JNIEnv *env, jobject this, jobject parent)

   168 {

   169     int32_t argc;

   170 #define MAX_ARGC 20

   171     Arg args[MAX_ARGC];

   172     char *clabel;

   173     struct MenuData *menuData;

   174     struct MenuItemData *mdata;

   175     struct FontData *fdata;

   176     Pixel bg;

   177     Pixel fg;

   178     XmFontList fontlist = NULL;

   179     jobject target;

   180     jobject targetFont;

   181     XmString mfstr = NULL;

   182     XmString shortcut_str = NULL;

   183     XmString str = NULL;

   184     jobject font;

   185     jobject shortcut;

   186     jboolean IsMultiFont;

   187     jboolean isCheckbox;

   188     jstring label;

   189     jobject globalRef = (*env)->NewGlobalRef(env, this);

   190     const jchar *unicodeLabel = NULL;

   191     jsize unicodeLabelLen = 0;

   192     jboolean isCopy = JNI_FALSE;

   193 

   194     // We call client code on this thread, so it must *NOT* be privileged

   195     DASSERT(!awt_currentThreadIsPrivileged(env));

   196 

   197     JNU_SetLongFieldFromPtr(env, this, mMenuItemPeerIDs.jniGlobalRef,

   198                             globalRef);

   199 

   200     fdata = NULL;

   201 

   202     fflush(stderr);

   203     target =

   204       (*env)->GetObjectField(env, this, mMenuItemPeerIDs.target);

   205     if (JNU_IsNull(env, target)) {

   206         JNU_ThrowNullPointerException(env, "NullPointerException");

   207         return;

   208     }

   209     font = JNU_CallMethodByName(env, NULL, target, "getFont_NoClientCode",

   210                                 "()Ljava/awt/Font;").l;

   211 

   212     if (JNU_IsNull(env, parent)) {

   213         JNU_ThrowNullPointerException(env, "NullPointerException");

   214         return;

   215     }

   216     AWT_LOCK();

   217     menuData = (struct MenuData *)

   218       JNU_GetLongFieldAsPtr(env, parent, mMenuItemPeerIDs.pData);

   219 

   220     targetFont =

   221       (*env)->GetObjectField(env, target, menuComponentIDs.font);

   222     if (!JNU_IsNull(env, targetFont) &&

   223         (fdata = awtJNI_GetFontData(env, targetFont, NULL)) != NULL) {

   224         IsMultiFont = awtJNI_IsMultiFont(env, targetFont);

   225     } else {

   226         IsMultiFont = awtJNI_IsMultiFont(env, font);

   227     }

   228 

   229     label = (*env)->GetObjectField(env, target, menuItemIDs.label);

   230     if (JNU_IsNull(env, label) || ((*env)->GetStringLength (env, label) == 0)) {

   231         mfstr = XmStringCreateLocalized("");

   232         clabel = "";

   233     } else {

   234         if (IsMultiFont) {

   235             mfstr = awtJNI_MakeMultiFontString(env, label, font);

   236         } else {

   237             mfstr = XmStringCreateLocalized("");

   238         }

   239         clabel = (char *) JNU_GetStringPlatformChars(env, label, NULL);

   240     }

   241 

   242     mdata = ZALLOC(MenuItemData);

   243     JNU_SetLongFieldFromPtr(env, this, mMenuItemPeerIDs.pData, mdata);

   244 

   245     argc = 0;

   246     XtSetArg(args[argc], XmNbackground, &bg);

   247     argc++;

   248     XtSetArg(args[argc], XmNforeground, &fg);

   249     argc++;

   250     XtGetValues(menuData->itemData.comp.widget, args, argc);

   251 

   252     argc = 0;

   253     XtSetArg(args[argc], XmNbackground, bg);

   254     argc++;

   255     XtSetArg(args[argc], XmNforeground, fg);

   256     argc++;

   257 

   258     /* check if the label is "-" but don't use strcmp(clabel, "-") because

   259      * the high-order bytes in the unicode characters are not present in

   260      * the C string (bugid 4099695)

   261      */

   262     if (!JNU_IsNull(env, label)) {

   263         unicodeLabel = (*env)->GetStringChars(env, label, &isCopy);

   264         unicodeLabelLen = (*env)->GetStringLength(env, label);

   265     }

   266     if ((unicodeLabel != NULL) && (unicodeLabel[0] == '-') &&

   267         (unicodeLabelLen == 1)) {

   268         DASSERT(!(argc > MAX_ARGC));

   269         mdata->comp.widget = XmCreateSeparator(menuData->itemData.comp.widget,

   270                                                "", args, argc);

   271     } else {

   272         if (IsMultiFont) {

   273             XtSetArg(args[argc], XmNlabelString, mfstr);

   274         } else {

   275             str = XmStringCreate(clabel, XmSTRING_DEFAULT_CHARSET);

   276             XtSetArg(args[argc], XmNlabelString, str);

   277         }

   278         argc++;

   279 

   280         shortcut =

   281           (*env)->GetObjectField(env, target, menuItemIDs.shortcut);

   282         if (!JNU_IsNull(env, shortcut)) {

   283             jstring shortcutText;

   284             char *text = "";

   285 

   286             shortcutText = JNU_CallMethodByName(env, NULL, shortcut,

   287                                                 "toString",

   288                                                 "()Ljava/lang/String;").l;

   289 

   290             if (!JNU_IsNull(env, shortcutText)) {

   291                 text = (char *) JNU_GetStringPlatformChars(env, shortcutText, NULL);

   292             }

   293             shortcut_str = XmStringCreate(text, XmSTRING_DEFAULT_CHARSET);

   294             XtSetArg(args[argc], XmNacceleratorText, shortcut_str);

   295 

   296             argc++;

   297 

   298             if (!JNU_IsNull(env, shortcutText)) {

   299                 JNU_ReleaseStringPlatformChars(env, shortcutText, (const char *) text);

   300             }

   301         }

   302         if (!JNU_IsNull(env, targetFont) && (fdata != NULL)) {

   303             if (IsMultiFont) {

   304                 fontlist = awtJNI_GetFontList(env, targetFont);

   305             } else {

   306                 fontlist = XmFontListCreate(fdata->xfont, "labelFont");

   307             }

   308             XtSetArg(args[argc], XmNfontList, fontlist);

   309             argc++;

   310         } else {

   311             if (IsMultiFont) {

   312                 fontlist = awtJNI_GetFontList(env, font);

   313                 XtSetArg(args[argc], XmNfontList, fontlist);

   314                 argc++;

   315             }

   316         }

   317 

   318         isCheckbox =

   319           (*env)->GetBooleanField(env, this, mMenuItemPeerIDs.isCheckbox);

   320         if (isCheckbox) {

   321             /* Fix for 4090493 */

   322             if (IsMultiFont) {

   323                 /* FontData that correspond to XmNfontList we just set */

   324                 struct FontData *fdataForIndSize;

   325                 Dimension indSize;

   326                 if (!JNU_IsNull(env, targetFont) && (fdata != NULL)) {

   327                     fdataForIndSize = fdata;

   328                 }

   329                 else {

   330                 fdataForIndSize = awtJNI_GetFontData(env, font, NULL);

   331                 }

   332                 indSize = awt_adjustIndicatorSizeForMenu(awt_computeIndicatorSize(fdataForIndSize));

   333                 if (indSize != MOTIF_XmINVALID_DIMENSION) {

   334                     XtSetArg(args[argc], XmNindicatorSize, indSize); argc++;

   335                 }

   336             }

   337             /* End of fix for 4090493 */

   338             XtSetArg(args[argc], XmNset, False);

   339             argc++;

   340             XtSetArg(args[argc], XmNvisibleWhenOff, True);

   341             argc++;

   342 

   343             DASSERT(!(argc > MAX_ARGC));

   344             mdata->comp.widget = XmCreateToggleButton(menuData->itemData.comp.widget,

   345                                                       clabel,

   346                                                       args,

   347                                                       argc);

   348         } else {

   349             DASSERT(!(argc > MAX_ARGC));

   350             mdata->comp.widget = XmCreatePushButton(menuData->itemData.comp.widget,

   351                                                     clabel,

   352                                                     args,

   353                                                     argc);

   354         }

   355         XtAddCallback(mdata->comp.widget,

   356                       ((isCheckbox) ? XmNvalueChangedCallback : XmNactivateCallback),

   357                       (XtCallbackProc) MenuItem_selected,

   358                       (XtPointer) globalRef);

   359 

   360         XtSetSensitive(mdata->comp.widget,

   361           (*env)->GetBooleanField(env, target, menuItemIDs.enabled) ?

   362                        True : False);

   363 

   364 

   365         if (!JNU_IsNull(env, targetFont)) {

   366             XmFontListFree(fontlist);

   367         }

   368     }

   369 

   370     if (clabel && (clabel != "")) {

   371         JNU_ReleaseStringPlatformChars(env, label, clabel);

   372     }

   373 

   374     /*

   375      * Free up resources after we have created the widget

   376      */

   377     if (mfstr != NULL) {

   378       XmStringFree(mfstr);

   379       mfstr = NULL;

   380     }

   381     if (str) {

   382       XmStringFree(str);

   383       str = NULL;

   384     }

   385     if (shortcut_str) {

   386       XmStringFree(shortcut_str);

   387       shortcut_str = NULL;

   388     }

   389     if (isCopy == JNI_TRUE) {

   390         (*env)->ReleaseStringChars(env, label, unicodeLabel);

   391     }

   392 

   393     XtManageChild(mdata->comp.widget);

   394     AWT_UNLOCK();

   395 }

   396 

   397 /*

   398  * Class:     sun_awt_motif_MMenuItemPeer

   399  * Method:    pSetLabel

   400  * Signature: (Ljava/lang/String;)V

   401  */

   402 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_pSetLabel

   403 (JNIEnv *env, jobject this, jstring label)

   404 {

   405     struct ComponentData *wdata;

   406     char *clabel;

   407     XmString xim;

   408 

   409     AWT_LOCK();

   410     wdata = (struct ComponentData *)

   411         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   412     if (wdata == NULL) {

   413         JNU_ThrowNullPointerException(env, "NullPointerException");

   414         AWT_UNLOCK();

   415         return;

   416     }

   417     if (JNU_IsNull(env, label) || ((*env)->GetStringLength (env, label) == 0)) {

   418         xim = XmStringCreateLocalized("");

   419     } else {

   420         jobject font;

   421         jobject target;

   422 

   423         target = (*env)->GetObjectField(env, this, mMenuItemPeerIDs.target);

   424         if (JNU_IsNull(env, target)) {

   425             JNU_ThrowNullPointerException(env, "NullPointerException");

   426             AWT_UNLOCK();

   427             return;

   428         }

   429         font = JNU_CallMethodByName(env, NULL, target, "getFont_NoClientCode",

   430                                     "()Ljava/awt/Font;").l;

   431 

   432         if (awtJNI_IsMultiFont(env, font)) {

   433             xim = awtJNI_MakeMultiFontString(env, label, font);

   434         } else {

   435             clabel = (char *) JNU_GetStringPlatformChars(env, label, NULL);

   436             xim = XmStringCreate(clabel, "labelFont");

   437             JNU_ReleaseStringPlatformChars(env, label, clabel);

   438         }

   439     }

   440     XtUnmanageChild(wdata->widget);

   441     XtVaSetValues(wdata->widget, XmNlabelString, xim, NULL);

   442     XtManageChild(wdata->widget);

   443     XmStringFree(xim);

   444     AWT_UNLOCK();

   445 }

   446 

   447 

   448 /*

   449  * Class:     sun_awt_motif_MMenuItemPeer

   450  * Method:    pSetShortCut

   451  * Signature: (Ljava/lang/String;)V

   452  */

   453 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_pSetShortcut

   454 (JNIEnv *env, jobject this, jstring shortcut)

   455 {

   456     struct ComponentData *wdata;

   457     char *cshortcut;

   458     XmString xim;

   459 

   460 

   461     AWT_LOCK();

   462     wdata = (struct ComponentData *)

   463         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   464     if (wdata == NULL) {

   465         JNU_ThrowNullPointerException(env, "NullPointerException");

   466         AWT_UNLOCK();

   467         return;

   468     }

   469     if (JNU_IsNull(env, shortcut)) {

   470         xim = XmStringCreateLocalized("");

   471     } else {

   472         jobject font;

   473         jobject target;

   474 

   475         target = (*env)->GetObjectField(env, this, mMenuItemPeerIDs.target);

   476         if (JNU_IsNull(env, target)) {

   477             JNU_ThrowNullPointerException(env, "NullPointerException");

   478             AWT_UNLOCK();

   479             return;

   480         }

   481         font = JNU_CallMethodByName(env, NULL, target, "getFont_NoClientCode",

   482                                     "()Ljava/awt/Font;").l;

   483 

   484         if (awtJNI_IsMultiFont(env, font)) {

   485             xim = awtJNI_MakeMultiFontString(env, shortcut, font);

   486         } else {

   487             cshortcut = (char *) JNU_GetStringPlatformChars(env, shortcut, NULL);

   488             xim = XmStringCreate(cshortcut, "labelFont");

   489             JNU_ReleaseStringPlatformChars(env, shortcut, cshortcut);

   490         }

   491     }

   492 

   493     XtUnmanageChild(wdata->widget);

   494     XtVaSetValues(wdata->widget, XmNacceleratorText, xim, NULL);

   495     XtManageChild(wdata->widget);

   496     XmStringFree(xim);

   497     AWT_UNLOCK();

   498 }

   499 

   500 

   501 /*

   502  * Class:     sun_awt_motif_MMenuItemPeer

   503  * Method:    pEnable

   504  * Signature: ()V

   505  */

   506 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_pEnable

   507 (JNIEnv *env, jobject this)

   508 {

   509     struct MenuItemData *mdata;

   510 

   511     AWT_LOCK();

   512 

   513     mdata = (struct MenuItemData *)

   514         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   515 

   516     if (mdata == NULL) {

   517         JNU_ThrowNullPointerException(env, "NullPointerException");

   518         AWT_UNLOCK();

   519         return;

   520     }

   521     XtSetSensitive(mdata->comp.widget, True);

   522     AWT_UNLOCK();

   523 }

   524 

   525 /*

   526  * Class:     sun_awt_motif_MMenuItemPeer

   527  * Method:    pDisable

   528  * Signature: ()V

   529  */

   530 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_pDisable

   531 (JNIEnv *env, jobject this)

   532 {

   533     struct MenuItemData *mdata;

   534 

   535     AWT_LOCK();

   536 

   537     mdata = (struct MenuItemData *)

   538         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   539 

   540     if (mdata == NULL) {

   541         JNU_ThrowNullPointerException(env, "NullPointerException");

   542         AWT_UNLOCK();

   543         return;

   544     }

   545     XtSetSensitive(mdata->comp.widget, False);

   546     AWT_UNLOCK();

   547 }

   548 

   549 /*

   550  * Class:     sun_awt_motif_MMenuItemPeer

   551  * Method:    pDispose

   552  * Signature: ()V

   553  */

   554 JNIEXPORT void JNICALL Java_sun_awt_motif_MMenuItemPeer_pDispose

   555 (JNIEnv *env, jobject this)

   556 {

   557     struct MenuItemData *mdata;

   558     Widget parent;

   559     Boolean isParentManaged = False;

   560 

   561     AWT_LOCK();

   562 

   563     mdata = (struct MenuItemData *)

   564         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   565 

   566     if (mdata != NULL) {

   567         /* Fix for 4280561:Workspace freezes, does not respond to mouse clicks

   568         **

   569         ** this really helps a lot of Fujitsu problems, take down a popup

   570         ** menu when removing items, on windows you could never get here, since

   571         ** the show() of a popup menu puts it in a menu loop where further

   572         ** events are processed in that loop, its like a modal dialog show,

   573         ** in that it dosn't return till it comes down.

   574         ** in X - future xevents will be dispatched immeadiatly, but some

   575         ** may be still waiting on the java queue - which can cause them to be

   576         ** dispatched out of order (sometimes hanging system !)

   577         */

   578         /* note: should realy only take down if XtParent(mdata->comp.widget)

   579         ** is the activePopup (in awt_PopupMenu.c) but ...

   580         */

   581         {

   582             removePopupMenus();

   583         }

   584         XtUnmanageChild(mdata->comp.widget);

   585         awt_util_consumeAllXEvents(mdata->comp.widget);

   586 

   587         parent = XtParent(mdata->comp.widget);

   588         if (parent != NULL && XtIsManaged(parent)) {

   589             isParentManaged = True;

   590             XtUnmanageChild(parent);

   591         }

   592 

   593         XtDestroyWidget(mdata->comp.widget);

   594 

   595         if (isParentManaged) {

   596             XtManageChild(parent);

   597         }

   598 

   599         free((void *) mdata);

   600         (*env)->SetLongField(env, this, mMenuItemPeerIDs.pData, (jlong)0);

   601         awtJNI_DeleteGlobalMenuRef(env, this);

   602     }

   603     AWT_UNLOCK();

   604 }

   605 

   606 /*

   607  * Class:     sun_awt_motif_MCheckboxMenuItemPeer

   608  * Method:    pSetState

   609  * Signature: (Z)V

   610  */

   611 JNIEXPORT void JNICALL Java_sun_awt_motif_MCheckboxMenuItemPeer_pSetState

   612   (JNIEnv *env, jobject this, jboolean state)

   613 {

   614     struct MenuItemData *mdata;

   615 

   616     AWT_LOCK();

   617 

   618     mdata = (struct MenuItemData *)

   619         JNU_GetLongFieldAsPtr(env, this, mMenuItemPeerIDs.pData);

   620 

   621     if (mdata == NULL) {

   622         JNU_ThrowNullPointerException(env, "menuitem data is null");

   623         AWT_UNLOCK();

   624         return;

   625     }

   626     XtVaSetValues(mdata->comp.widget, XmNset, (Boolean)state, NULL);

   627     AWT_UNLOCK();

   628 }

   629 

   630 /*

   631  * Class:     sun_awt_motif_MCheckboxMenuItemPeer

   632  * Method:    getState

   633  * Signature: ()Z

   634  */

   635 JNIEXPORT jboolean JNICALL Java_sun_awt_motif_MCheckboxMenuItemPeer_getState

   636   (JNIEnv *env, jobject this)

   637 {

   638     struct MenuItemData *mdata;

   639     Boolean             state;

   640 

   641     AWT_LOCK();

   642 

   643     mdata = (struct MenuItemData *)

   644       (*env)->GetLongField(env, this, mMenuItemPeerIDs.pData);

   645 

   646     if (mdata == NULL) {

   647         JNU_ThrowNullPointerException(env, "menuitem data is null");

   648         AWT_UNLOCK();

   649         return JNI_FALSE;

   650     }

   651     XtVaGetValues(mdata->comp.widget, XmNset, &state, NULL);

   652     AWT_UNLOCK();

   653     return ((state) ? JNI_TRUE : JNI_FALSE);

   654 }