void* AwtPanel::Restack(void * param) {
TRY;
JNIEnv* env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobjectArray peers = (jobjectArray)param;
int peerCount = env->GetArrayLength(peers);
if (peerCount < 1) {
env->DeleteGlobalRef(peers);
return AWTPANEL_RESTACK_MSG_1;
}
jobject self = env->GetObjectArrayElement(peers, 0);
// It's entirely possible that our native resources have been destroyed
// before our java peer - if we're dispose()d, for instance.
// Alert caller w/ IllegalComponentStateException.
if (self == NULL) {
env->DeleteGlobalRef(peers);
return AWTPANEL_RESTACK_MSG_2;
}
PDATA pData = JNI_GET_PDATA(self);
if (pData == NULL) {
env->DeleteGlobalRef(peers);
env->DeleteLocalRef(self);
return AWTPANEL_RESTACK_MSG_3;
}
AwtPanel* panel = (AwtPanel*)pData;
HWND prevWindow = 0;
for (int i = 1; i < peerCount; i++) {
jobject peer = env->GetObjectArrayElement(peers, i);
if (peer == NULL) {
// Nonsense
env->DeleteGlobalRef(peers);
env->DeleteLocalRef(self);
return AWTPANEL_RESTACK_MSG_4;
}
PDATA child_pData = JNI_GET_PDATA(peer);
if (child_pData == NULL) {
env->DeleteLocalRef(peer);
env->DeleteGlobalRef(peers);
env->DeleteLocalRef(self);
return AWTPANEL_RESTACK_MSG_3;
}
AwtComponent* child_comp = (AwtComponent*)child_pData;
::SetWindowPos(child_comp->GetHWnd(), prevWindow, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS);
prevWindow = child_comp->GetHWnd();
env->DeleteLocalRef(peer);
}
env->DeleteGlobalRef(peers);
env->DeleteLocalRef(self);
CATCH_BAD_ALLOC_RET("Allocation error");
return NULL;
}
/*
* Class: sun_awt_windows_WCheckboxPeer
* Method: setLabel
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WCheckboxPeer_setLabel(JNIEnv *env, jobject self,
jstring label)
{
TRY;
PDATA pData;
JNI_CHECK_PEER_RETURN(self);
AwtComponent* c = (AwtComponent*)JNI_GET_PDATA(self);
LPCTSTR labelStr;
// Fix for 4378378: by convention null label means empty string
if (label == NULL) {
labelStr = TEXT("");
} else {
labelStr = JNU_GetStringPlatformChars(env, label, JNI_FALSE);
}
if (labelStr == NULL) {
throw std::bad_alloc();
}
c->SetText(labelStr);
c->VerifyState();
// Fix for 4378378: release StringPlatformChars only if label is not null
if (label != NULL) {
JNU_ReleaseStringPlatformChars(env, label, labelStr);
}
CATCH_BAD_ALLOC;
}
/*
* Class: sun_awt_windows_WCheckboxPeer
* Method: setState
* Signature: (Z)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WCheckboxPeer_setState(JNIEnv *env, jobject self,
jboolean state)
{
TRY;
PDATA pData;
JNI_CHECK_PEER_RETURN(self);
AwtComponent* c = (AwtComponent*)JNI_GET_PDATA(self);
/*
* when multifont and group checkbox receive setState native
* method, it must be redraw to display correct check mark
*/
jobject target = env->GetObjectField(self, AwtObject::targetID);
jobject group = env->GetObjectField(target, AwtCheckbox::groupID);
if (group != NULL) {
HWND hWnd = c->GetHWnd();
RECT rect;
VERIFY(::GetWindowRect(hWnd,&rect));
VERIFY(::ScreenToClient(hWnd, (LPPOINT)&rect));
VERIFY(::ScreenToClient(hWnd, ((LPPOINT)&rect)+1));
VERIFY(::InvalidateRect(hWnd,&rect,TRUE));
VERIFY(::UpdateWindow(hWnd));
} else {
c->SendMessage(BM_SETCHECK, (WPARAM)(state ? BST_CHECKED :
BST_UNCHECKED));
VERIFY(::InvalidateRect(c->GetHWnd(), NULL, FALSE));
}
c->VerifyState();
CATCH_BAD_ALLOC;
}
//
// utility function to get the C++ object from the Java one
//
// (static)
AwtRobot * AwtRobot::GetRobot( jobject self )
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
AwtRobot * robot = (AwtRobot *)JNI_GET_PDATA(self);
DASSERT( !::IsBadWritePtr( robot, sizeof(AwtRobot)));
return robot;
}
JNIEXPORT jboolean JNICALL
Java_sun_awt_windows_WPrintDialogPeer__1show(JNIEnv *env, jobject peer)
{
TRY;
DASSERT(peer != NULL);
jobject target = env->GetObjectField(peer, AwtObject::targetID);
DASSERT(target != NULL);
jobject parent = env->GetObjectField(peer, AwtPrintDialog::parentID);
DASSERT(parent != NULL);
jobject control = env->GetObjectField(target, AwtPrintDialog::controlID);
DASSERT(control != NULL);
AwtComponent *awtParent = (AwtComponent *)JNI_GET_PDATA(parent);
DASSERT(awtParent != NULL);
PRINTDLG pd;
memset(&pd, 0, sizeof(PRINTDLG));
pd.lStructSize = sizeof(PRINTDLG);
AwtPrintControl::InitPrintDialog(env, control, pd);
pd.lpfnPrintHook = (LPPRINTHOOKPROC)PrintDialogHookProc;
pd.lpfnSetupHook = (LPSETUPHOOKPROC)PrintDialogHookProc;
pd.Flags |= PD_ENABLESETUPHOOK | PD_ENABLEPRINTHOOK;
AwtDialog::ModalDisable(NULL);
BOOL ret = AwtPrintDialog::PrintDlg(&pd);
AwtDialog::ModalEnable(NULL);
AwtDialog::ModalNextWindowToFront(awtParent->GetHWnd());
if (ret) {
AwtPrintControl::UpdateAttributes(env, control, pd);
}
return ret;
CATCH_BAD_ALLOC_RET(0);
}
//
// (static)
// Switches to Windows thread via SendMessage and synchronously
// calls AwtObject::WinThreadExecProc with the given command id
// and parameters.
//
// Useful for writing code that needs to be synchronized with
// what's happening on the Windows thread.
//
LRESULT AwtObject::WinThreadExec(
jobject peerObject,
UINT cmdId,
LPARAM param1,
LPARAM param2,
LPARAM param3,
LPARAM param4 )
{
DASSERT( peerObject != NULL);
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
AwtObject* object = (AwtObject *)JNI_GET_PDATA(peerObject);
DASSERT( !IsBadReadPtr(object, sizeof(AwtObject)) );
ExecuteArgs args;
LRESULT retVal;
// setup arguments
args.cmdId = cmdId;
args.param1 = param1;
args.param2 = param2;
args.param3 = param3;
args.param4 = param4;
// call WinThreadExecProc on the toolkit thread
retVal = AwtToolkit::GetInstance().SendMessage(WM_AWT_EXECUTE_SYNC,
(WPARAM)object,
(LPARAM)&args);
return retVal;
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: isWindowUnderMouse
* Signature: (Ljava/awt/Window)Z
*/
JNIEXPORT jboolean JNICALL
Java_sun_awt_DefaultMouseInfoPeer_isWindowUnderMouse(JNIEnv *env, jclass cls,
jobject window)
{
POINT pt;
if (env->EnsureLocalCapacity(1) < 0) {
return JNI_FALSE;
}
jobject winPeer = AwtObject::GetPeerForTarget(env, window);
PDATA pData;
pData = JNI_GET_PDATA(winPeer);
env->DeleteLocalRef(winPeer);
if (pData == NULL) {
return JNI_FALSE;
}
AwtComponent * ourWindow = (AwtComponent *)pData;
HWND hwnd = ourWindow->GetHWnd();
VERIFY(::GetCursorPos(&pt));
AwtComponent * componentFromPoint = AwtComponent::GetComponent(::WindowFromPoint(pt));
while (componentFromPoint != NULL
&& componentFromPoint->GetHWnd() != hwnd
&& !AwtComponent::IsTopLevelHWnd(componentFromPoint->GetHWnd()))
{
componentFromPoint = componentFromPoint->GetParent();
}
return ((componentFromPoint != NULL) && (componentFromPoint->GetHWnd() == hwnd)) ? JNI_TRUE : JNI_FALSE;
}
/*
* Class: sun_awt_windows_WMenuItemPeer
* Method: _dispose
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WMenuItemPeer__1dispose(JNIEnv *env, jobject self)
{
TRY_NO_HANG;
PDATA pData = JNI_GET_PDATA(self);
AwtObject::_Dispose(pData);
CATCH_BAD_ALLOC;
}
/*
* Class: sun_awt_windows_WInputMethod
* Method: disableNativeIME
* Signature: (Lsun/awt/windows/WComponentPeer;)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WInputMethod_disableNativeIME(JNIEnv *env, jobject self, jobject peer)
{
TRY_NO_VERIFY;
//get C++ Class of Focused Component
if (peer == 0) return;
AwtComponent* p = (AwtComponent*)JNI_GET_PDATA(peer);
if (p == 0) return;
p->SetInputMethod(NULL, TRUE);
// use special message to call ImmAssociateContext() in main thread.
AwtToolkit::GetInstance().SendMessage(WM_AWT_ASSOCIATECONTEXT,
reinterpret_cast<WPARAM>(p->GetHWnd()), NULL);
CATCH_BAD_ALLOC;
}
/*
* Class: sun_awt_windows_WCheckboxPeer
* Method: create
* Signature: (Lsun/awt/windows/WComponentPeer;)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WCheckboxPeer_create(JNIEnv *env, jobject self,
jobject parent)
{
TRY;
PDATA pData;
JNI_CHECK_PEER_RETURN(parent);
AwtToolkit::CreateComponent(self, parent,
(AwtToolkit::ComponentFactory)
AwtCheckbox::Create);
JNI_CHECK_PEER_CREATION_RETURN(self);
#ifdef DEBUG
((AwtComponent*)JNI_GET_PDATA(self))->VerifyState();
#endif
CATCH_BAD_ALLOC;
}
/* Create a new AwtPopupMenu object and menu. */
AwtPopupMenu* AwtPopupMenu::Create(jobject self, jobject parent)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject target = NULL;
AwtPopupMenu* popupMenu = NULL;
try {
if (env->EnsureLocalCapacity(1) < 0) {
return NULL;
}
JNI_CHECK_NULL_GOTO(parent, "peer", done);
AwtComponent* awtParent = (AwtComponent*) JNI_GET_PDATA(parent);
target = env->GetObjectField(self, AwtObject::targetID);
JNI_CHECK_NULL_GOTO(target, "null target", done);
popupMenu = new AwtPopupMenu();
SetLastError(0);
HMENU hMenu = ::CreatePopupMenu();
// fix for 5088782
if (!CheckMenuCreation(env, self, hMenu))
{
env->DeleteLocalRef(target);
return NULL;
}
popupMenu->SetHMenu(hMenu);
popupMenu->LinkObjects(env, self);
popupMenu->SetParent(awtParent);
} catch (...) {
env->DeleteLocalRef(target);
throw;
}
done:
env->DeleteLocalRef(target);
return popupMenu;
}
void AwtPopupMenu::_Show(void *param)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
static jclass popupMenuCls;
if (popupMenuCls == NULL) {
jclass popupMenuClsLocal = env->FindClass("java/awt/PopupMenu");
if (popupMenuClsLocal != NULL) {
popupMenuCls = (jclass)env->NewGlobalRef(popupMenuClsLocal);
env->DeleteLocalRef(popupMenuClsLocal);
}
}
static jfieldID isTrayIconPopupID;
if (popupMenuCls != NULL && isTrayIconPopupID == NULL) {
isTrayIconPopupID = env->GetFieldID(popupMenuCls, "isTrayIconPopup", "Z");
DASSERT(isTrayIconPopupID);
}
ShowStruct *ss = (ShowStruct*)param;
if (ss->self != NULL && isTrayIconPopupID != NULL) {
PDATA pData = JNI_GET_PDATA(ss->self);
if (pData) {
AwtPopupMenu *p = (AwtPopupMenu *)pData;
jobject target = p->GetTarget(env);
BOOL isTrayIconPopup = env->GetBooleanField(target, isTrayIconPopupID);
env->DeleteLocalRef(target);
p->Show(env, ss->event, isTrayIconPopup);
}
}
if (ss->self != NULL) {
env->DeleteGlobalRef(ss->self);
}
if (ss->event != NULL) {
env->DeleteGlobalRef(ss->event);
}
delete ss;
if (isTrayIconPopupID == NULL) {
throw std::bad_alloc();
}
}
/*
* Class: sun_awt_windows_WCheckboxPeer
* Method: setCheckboxGroup
* Signature: (Ljava/awt/CheckboxGroup;)V
*/
JNIEXPORT void JNICALL
Java_sun_awt_windows_WCheckboxPeer_setCheckboxGroup(JNIEnv *env, jobject self,
jobject group)
{
TRY;
PDATA pData;
JNI_CHECK_PEER_RETURN(self);
/* REMIND
#ifdef DEBUG
if (group != NULL) {
DASSERT(IsInstanceOf((HObject*)group, "java/awt/CheckboxGroup"));
}
#endif
*/
AwtComponent* c = (AwtComponent*)JNI_GET_PDATA(self);
c->SendMessage(BM_SETSTYLE, (WPARAM)BS_OWNERDRAW, (LPARAM)TRUE);
c->VerifyState();
CATCH_BAD_ALLOC;
}
/*
* Class: sun_awt_windows_WInputMethod
* Method: hideWindowsNative
* Signature: (Lsun/awt/windows/WComponentPeer;Z)V
*/
JNIEXPORT void JNICALL Java_sun_awt_windows_WInputMethod_setStatusWindowVisible
(JNIEnv *env, jobject self, jobject peer, jboolean visible)
{
/* Retrieve the default input method Window handler from AwtToolkit.
Windows system creates a default input method window for the
toolkit thread.
*/
HWND hwndIME = AwtToolkit::GetInstance().GetInputMethodWindow();
if (hwndIME == NULL) {
if (peer == NULL) {
return;
}
AwtComponent* p = (AwtComponent*)JNI_GET_PDATA(peer);
if (p == NULL || (hwndIME = ImmGetDefaultIMEWnd(p->GetHWnd())) == NULL) {
return;
}
AwtToolkit::GetInstance().SetInputMethodWindow(hwndIME);
}
::SendMessage(hwndIME, WM_IME_CONTROL,
visible ? IMC_OPENSTATUSWINDOW : IMC_CLOSESTATUSWINDOW, 0);
}
static void GlobalSetCursor(void* pStruct) {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject cursor = ((GlobalSetCursorStruct*)pStruct)->cursor;
jboolean u = ((GlobalSetCursorStruct*)pStruct)->u;
jlong pData = env->GetLongField(cursor, AwtCursor::pDataID);
AwtCursor *awtCursor = (AwtCursor *)jlong_to_ptr(pData);
if (awtCursor == NULL) {
awtCursor = AwtCursor::CreateSystemCursor(cursor);
}
HCURSOR hCursor = awtCursor->GetHCursor();
BOOL blocked = false;
if (jobject jcomp = AwtComponent::FindHeavyweightUnderCursor(u)) {
if(jobject jpeer = AwtObject::GetPeerForTarget(env, jcomp))
{
if(AwtComponent *awtComponent = (AwtComponent*)JNI_GET_PDATA(jpeer)) {
blocked = ::IsWindow(AwtWindow::GetModalBlocker(
AwtComponent::GetTopLevelParentForWindow(
awtComponent->GetHWnd())));
if (!blocked) {
awtComponent->setCursorCache(hCursor);
}
}
env->DeleteLocalRef(jpeer);
}
env->DeleteGlobalRef(jcomp);
}
if (!blocked) {
::SetCursor(hCursor); // don't need WM_AWT_SETCURSOR
}
env->DeleteGlobalRef(((GlobalSetCursorStruct*)pStruct)->cursor);
}
/*
* Copy settings into a print dialog & any devmode
*/
BOOL AwtPrintControl::InitPrintDialog(JNIEnv *env,
jobject printCtrl, PRINTDLG &pd) {
HWND hwndOwner = NULL;
jobject dialogOwner =
env->GetObjectField(printCtrl, AwtPrintControl::dialogOwnerPeerID);
if (dialogOwner != NULL) {
AwtComponent *dialogOwnerComp =
(AwtComponent *)JNI_GET_PDATA(dialogOwner);
hwndOwner = dialogOwnerComp->GetHWnd();
env->DeleteLocalRef(dialogOwner);
dialogOwner = NULL;
}
jobject mdh = NULL;
jobject dest = NULL;
jobject select = NULL;
jobject dialog = NULL;
LPTSTR printName = NULL;
LPTSTR portName = NULL;
// If the user didn't specify a printer, then this call returns the
// name of the default printer.
jstring printerName = (jstring)
env->CallObjectMethod(printCtrl, AwtPrintControl::getPrinterID);
if (printerName != NULL) {
pd.hDevMode = AwtPrintControl::getPrintHDMode(env, printCtrl);
pd.hDevNames = AwtPrintControl::getPrintHDName(env, printCtrl);
LPTSTR getName = (LPTSTR)JNU_GetStringPlatformChars(env,
printerName, NULL);
BOOL samePrinter = FALSE;
// check if given printername is same as the currently saved printer
if (pd.hDevNames != NULL ) {
DEVNAMES *devnames = (DEVNAMES *)::GlobalLock(pd.hDevNames);
if (devnames != NULL) {
LPTSTR lpdevnames = (LPTSTR)devnames;
printName = lpdevnames+devnames->wDeviceOffset;
if (!_tcscmp(printName, getName)) {
samePrinter = TRUE;
printName = _tcsdup(lpdevnames+devnames->wDeviceOffset);
portName = _tcsdup(lpdevnames+devnames->wOutputOffset);
}
}
::GlobalUnlock(pd.hDevNames);
}
if (!samePrinter) {
LPTSTR foundPrinter = NULL;
LPTSTR foundPort = NULL;
DWORD cbBuf = 0;
VERIFY(AwtPrintControl::FindPrinter(NULL, NULL, &cbBuf,
NULL, NULL));
LPBYTE buffer = new BYTE[cbBuf];
if (AwtPrintControl::FindPrinter(printerName, buffer, &cbBuf,
&foundPrinter, &foundPort) &&
(foundPrinter != NULL) && (foundPort != NULL)) {
printName = _tcsdup(foundPrinter);
portName = _tcsdup(foundPort);
if (!AwtPrintControl::CreateDevModeAndDevNames(&pd,
foundPrinter, foundPort)) {
delete [] buffer;
if (printName != NULL) {
free(printName);
}
if (portName != NULL) {
free(portName);
}
return FALSE;
}
DASSERT(pd.hDevNames != NULL);
} else {
delete [] buffer;
if (printName != NULL) {
free(printName);
}
if (portName != NULL) {
free(portName);
}
return FALSE;
}
delete [] buffer;
}
// PrintDlg may change the values of hDevMode and hDevNames so we
// re-initialize our saved handles.
AwtPrintControl::setPrintHDMode(env, printCtrl, NULL);
AwtPrintControl::setPrintHDName(env, printCtrl, NULL);
} else {
// There is no default printer. This means that there are no
// printers installed at all.
if (printName != NULL) {
free(printName);
}
if (portName != NULL) {
free(portName);
}
// Returning TRUE means try to display the native print dialog
// which will either display an error message or prompt the
// user to install a printer.
return TRUE;
}
// Now, set-up the struct for the real calls to ::PrintDlg and ::CreateDC
pd.hwndOwner = hwndOwner;
pd.Flags = PD_ENABLEPRINTHOOK | PD_RETURNDC | PD_USEDEVMODECOPIESANDCOLLATE;
pd.lpfnPrintHook = (LPPRINTHOOKPROC)PrintDlgHook;
if (env->CallBooleanMethod(printCtrl, AwtPrintControl::getCollateID)) {
pd.Flags |= PD_COLLATE;
}
pd.nCopies = (WORD)env->CallIntMethod(printCtrl,
AwtPrintControl::getCopiesID);
pd.nFromPage = (WORD)env->CallIntMethod(printCtrl,
AwtPrintControl::getFromPageID);
pd.nToPage = (WORD)env->CallIntMethod(printCtrl,
AwtPrintControl::getToPageID);
pd.nMinPage = (WORD)env->CallIntMethod(printCtrl,
AwtPrintControl::getMinPageID);
jint maxPage = env->CallIntMethod(printCtrl,
AwtPrintControl::getMaxPageID);
pd.nMaxPage = (maxPage <= (jint)((WORD)-1)) ? (WORD)maxPage : (WORD)-1;
if (env->CallBooleanMethod(printCtrl,
AwtPrintControl::getDestID)) {
pd.Flags |= PD_PRINTTOFILE;
}
jint selectType = env->CallIntMethod(printCtrl,
AwtPrintControl::getSelectID);
// selectType identifies whether No selection (2D) or
// SunPageSelection (AWT)
if (selectType != 0) {
pd.Flags |= selectType;
}
if (!env->CallBooleanMethod(printCtrl,
AwtPrintControl::getPrintToFileEnabledID)) {
pd.Flags |= PD_DISABLEPRINTTOFILE;
}
if (pd.hDevMode != NULL) {
DEVMODE *devmode = (DEVMODE *)::GlobalLock(pd.hDevMode);
DASSERT(!IsBadWritePtr(devmode, sizeof(DEVMODE)));
devmode->dmFields |= DM_COPIES | DM_COLLATE | DM_ORIENTATION |
DM_PAPERSIZE | DM_PRINTQUALITY | DM_COLOR | DM_DUPLEX;
devmode->dmCopies = pd.nCopies;
jint orient = env->CallIntMethod(printCtrl,
AwtPrintControl::getOrientID);
if (orient == 0) {
devmode->dmOrientation = DMORIENT_LANDSCAPE;
} else if (orient == 1) {
devmode->dmOrientation = DMORIENT_PORTRAIT;
}
devmode->dmCollate = (pd.Flags & PD_COLLATE) ? DMCOLLATE_TRUE
: DMCOLLATE_FALSE;
int quality = env->CallIntMethod(printCtrl,
AwtPrintControl::getQualityID);
if (quality) {
devmode->dmPrintQuality = quality;
}
int color = env->CallIntMethod(printCtrl,
AwtPrintControl::getColorID);
if (color) {
devmode->dmColor = color;
}
int sides = env->CallIntMethod(printCtrl,
AwtPrintControl::getSidesID);
if (sides) {
devmode->dmDuplex = (int)sides;
}
jintArray obj = (jintArray)env->CallObjectMethod(printCtrl,
AwtPrintControl::getWin32MediaID);
jboolean isCopy;
jint *wid_ht = env->GetIntArrayElements(obj,
&isCopy);
double newWid = 0.0, newHt = 0.0;
if (wid_ht != NULL && wid_ht[0] != 0 && wid_ht[1] != 0) {
devmode->dmPaperSize = AwtPrintControl::getNearestMatchingPaper(
printName,
portName,
(double)wid_ht[0],
(double)wid_ht[1],
&newWid, &newHt);
}
env->ReleaseIntArrayElements(obj, wid_ht, 0);
::GlobalUnlock(pd.hDevMode);
devmode = NULL;
}
if (printName != NULL) {
free(printName);
}
if (portName != NULL) {
free(portName);
}
return TRUE;
}
JNIEXPORT jboolean JNICALL
Java_sun_awt_windows_WPrintDialogPeer__1show(JNIEnv *env, jobject peer)
{
TRY;
jboolean result = JNI_FALSE;
// as peer object is used later on another thread, create a global ref
jobject peerGlobalRef = env->NewGlobalRef(peer);
DASSERT(peerGlobalRef != NULL);
jobject target = env->GetObjectField(peerGlobalRef, AwtObject::targetID);
DASSERT(target != NULL);
jobject parent = env->GetObjectField(peerGlobalRef, AwtPrintDialog::parentID);
jobject control = env->GetObjectField(target, AwtPrintDialog::controlID);
DASSERT(control != NULL);
AwtComponent *awtParent = (parent != NULL) ? (AwtComponent *)JNI_GET_PDATA(parent) : NULL;
HWND hwndOwner = awtParent ? awtParent->GetHWnd() : NULL;
PRINTDLG pd;
memset(&pd, 0, sizeof(PRINTDLG));
pd.lStructSize = sizeof(PRINTDLG);
pd.lCustData = (LPARAM)peerGlobalRef;
if (!AwtPrintControl::InitPrintDialog(env, control, pd))
{
result = JNI_FALSE;
}
else
{
pd.lpfnPrintHook = (LPPRINTHOOKPROC)PrintDialogHookProc;
pd.lpfnSetupHook = (LPSETUPHOOKPROC)PrintDialogHookProc;
pd.Flags |= PD_ENABLESETUPHOOK | PD_ENABLEPRINTHOOK;
// To disable Win32 native parent modality we have to set
// hwndOwner field to either NULL or some hidden window. For
// parentless dialogs we use NULL to show them in the taskbar,
// and for all other dialogs AwtToolkit's HWND is used.
if (awtParent != NULL) {
pd.hwndOwner = AwtToolkit::GetInstance().GetHWnd();
} else {
pd.hwndOwner = NULL;
}
AwtDialog::CheckInstallModalHook();
BOOL ret = AwtPrintDialog::PrintDlg(&pd);
if (ret)
{
AwtPrintControl::UpdateAttributes(env, control, pd);
result = JNI_TRUE;
}
else
{
result = JNI_FALSE;
}
DASSERT(env->GetLongField(peer, AwtComponent::hwndID) == 0L);
AwtDialog::CheckUninstallModalHook();
AwtDialog::ModalActivateNextWindow(NULL, target, peer);
}
env->DeleteGlobalRef(peerGlobalRef);
env->DeleteLocalRef(target);
if (parent != NULL) {
env->DeleteLocalRef(parent);
}
env->DeleteLocalRef(control);
return result;
CATCH_BAD_ALLOC_RET(0);
}
/*
* Create a new AwtCanvas object and window.
*/
AwtCanvas* AwtCanvas::Create(jobject self, jobject hParent)
{
TRY;
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject target = NULL;
AwtCanvas *canvas = NULL;
try {
if (env->EnsureLocalCapacity(1) < 0) {
return NULL;
}
AwtComponent* parent;
JNI_CHECK_NULL_GOTO(hParent, "null hParent", done);
parent = (AwtComponent*)JNI_GET_PDATA(hParent);
JNI_CHECK_NULL_GOTO(parent, "null parent", done);
target = env->GetObjectField(self, AwtObject::targetID);
JNI_CHECK_NULL_GOTO(target, "null target", done);
canvas = new AwtCanvas();
{
jint x = env->GetIntField(target, AwtComponent::xID);
jint y = env->GetIntField(target, AwtComponent::yID);
jint width = env->GetIntField(target, AwtComponent::widthID);
jint height = env->GetIntField(target, AwtComponent::heightID);
canvas->CreateHWnd(env, L"",
WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0,
x, y, width, height,
parent->GetHWnd(),
NULL,
::GetSysColor(COLOR_WINDOWTEXT),
::GetSysColor(COLOR_WINDOW),
self);
// Set the pixel format of the HWND if a GraphicsConfiguration
// was provided to the Canvas constructor.
jclass canvasClass = env->FindClass("java/awt/Canvas");
if ( env->IsInstanceOf( target, canvasClass ) ) {
// Get GraphicsConfig from our target
jobject graphicsConfig = env->GetObjectField(target,
AwtComponent::graphicsConfigID);
if (graphicsConfig != NULL) {
jclass win32cls = env->FindClass("sun/awt/Win32GraphicsConfig");
DASSERT (win32cls != NULL);
if ( env->IsInstanceOf( graphicsConfig, win32cls ) ) {
// Get the visual ID member from our GC
jint visual = env->GetIntField(graphicsConfig,
AwtWin32GraphicsConfig::win32GCVisualID);
if (visual > 0) {
HDC hdc = ::GetDC(canvas->m_hwnd);
// Set our pixel format
PIXELFORMATDESCRIPTOR pfd;
BOOL ret = ::SetPixelFormat(hdc, (int)visual, &pfd);
::ReleaseDC(canvas->m_hwnd, hdc);
//Since a GraphicsConfiguration was specified, we should
//throw an exception if the PixelFormat couldn't be set.
if (ret == FALSE) {
DASSERT(!safe_ExceptionOccurred(env));
jclass excCls = env->FindClass(
"java/lang/RuntimeException");
DASSERT(excCls);
env->ExceptionClear();
env->ThrowNew(excCls,
"\nUnable to set Pixel format on Canvas");
env->DeleteLocalRef(target);
return canvas;
}
}
}
}
}
}
} catch (...) {
env->DeleteLocalRef(target);
throw;
}
done:
env->DeleteLocalRef(target);
return canvas;
CATCH_BAD_ALLOC_RET(0);
}
AwtChoice* AwtChoice::Create(jobject peer, jobject parent) {
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject target = NULL;
AwtChoice* c = NULL;
RECT rc;
try {
if (env->EnsureLocalCapacity(1) < 0) {
return NULL;
}
AwtCanvas* awtParent;
JNI_CHECK_NULL_GOTO(parent, "null parent", done);
awtParent = (AwtCanvas*)JNI_GET_PDATA(parent);
JNI_CHECK_NULL_GOTO(awtParent, "null awtParent", done);
target = env->GetObjectField(peer, AwtObject::targetID);
JNI_CHECK_NULL_GOTO(target, "null target", done);
c = new AwtChoice();
{
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | WS_VSCROLL |
CBS_DROPDOWNLIST | CBS_OWNERDRAWFIXED;
DWORD exStyle = 0;
if (GetRTL()) {
exStyle |= WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR;
if (GetRTLReadingOrder())
exStyle |= WS_EX_RTLREADING;
}
/*
* In OWNER_DRAW, the size of the edit control part of the
* choice must be determinded in its creation, when the parent
* cannot get the choice's instance from its handle. So
* record the pair of the ID and the instance of the choice.
*/
UINT myId = awtParent->CreateControlID();
DASSERT(myId > 0);
c->m_myControlID = myId;
awtParent->PushChild(myId, c);
jint x = env->GetIntField(target, AwtComponent::xID);
jint y = env->GetIntField(target, AwtComponent::yID);
jint width = env->GetIntField(target, AwtComponent::widthID);
jint height = env->GetIntField(target, AwtComponent::heightID);
jobject dimension = JNU_CallMethodByName(env, NULL, peer,
"preferredSize",
"()Ljava/awt/Dimension;").l;
DASSERT(!safe_ExceptionOccurred(env));
if (dimension != NULL && width == 0) {
width = env->GetIntField(dimension, AwtDimension::widthID);
}
c->CreateHWnd(env, L"", style, exStyle,
x, y, width, height,
awtParent->GetHWnd(),
reinterpret_cast<HMENU>(static_cast<INT_PTR>(myId)),
::GetSysColor(COLOR_WINDOWTEXT),
::GetSysColor(COLOR_WINDOW),
peer);
/* suppress inheriting parent's color. */
c->m_backgroundColorSet = TRUE;
c->UpdateBackground(env, target);
/* Bug 4255631 Solaris: Size returned by Choice.getSize() does not match
* actual size
* Fix: Set the Choice to its actual size in the component.
*/
::GetClientRect(c->GetHWnd(), &rc);
env->SetIntField(target, AwtComponent::widthID, (jint) rc.right);
env->SetIntField(target, AwtComponent::heightID, (jint) rc.bottom);
env->DeleteLocalRef(dimension);
}
} catch (...) {
env->DeleteLocalRef(target);
throw;
}
done:
env->DeleteLocalRef(target);
return c;
}
AwtCheckbox* AwtCheckbox::Create(jobject peer, jobject parent)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jstring label = NULL;
jobject target = NULL;
AwtCheckbox *checkbox = NULL;
try {
if (env->EnsureLocalCapacity(2) < 0) {
return NULL;
}
AwtComponent* awtParent;
JNI_CHECK_NULL_GOTO(parent, "null parent", done);
awtParent = (AwtComponent*)JNI_GET_PDATA(parent);
JNI_CHECK_NULL_GOTO(awtParent, "null awtParent", done);
target = env->GetObjectField(peer, AwtObject::targetID);
JNI_CHECK_NULL_GOTO(target, "null target", done);
checkbox = new AwtCheckbox();
{
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | BS_OWNERDRAW;
LPCWSTR defaultLabelStr = L"";
LPCWSTR labelStr = defaultLabelStr;
DWORD exStyle = 0;
if (GetRTL()) {
exStyle |= WS_EX_RIGHT;
if (GetRTLReadingOrder())
exStyle |= WS_EX_RTLREADING;
}
label = (jstring)env->GetObjectField(target, AwtCheckbox::labelID);
if (label != NULL) {
labelStr = JNU_GetStringPlatformChars(env, label, 0);
}
if (labelStr != 0) {
jint x = env->GetIntField(target, AwtComponent::xID);
jint y = env->GetIntField(target, AwtComponent::yID);
jint width = env->GetIntField(target, AwtComponent::widthID);
jint height = env->GetIntField(target, AwtComponent::heightID);
checkbox->CreateHWnd(env, labelStr, style, exStyle,
x, y, width, height,
awtParent->GetHWnd(),
reinterpret_cast<HMENU>(static_cast<INT_PTR>(
awtParent->CreateControlID())),
::GetSysColor(COLOR_WINDOWTEXT),
::GetSysColor(COLOR_BTNFACE),
peer);
if (labelStr != defaultLabelStr) {
JNU_ReleaseStringPlatformChars(env, label, labelStr);
}
} else {
throw std::bad_alloc();
}
}
} catch (...) {
env->DeleteLocalRef(label);
env->DeleteLocalRef(target);
throw;
}
done:
env->DeleteLocalRef(label);
env->DeleteLocalRef(target);
return checkbox;
}
void
AwtFileDialog::Show(void *p)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jobject peer;
WCHAR unicodeChar = L' ';
LPTSTR fileBuffer = NULL;
LPTSTR currentDirectory = NULL;
jint mode = 0;
BOOL result = FALSE;
DWORD dlgerr;
jstring directory = NULL;
jstring title = NULL;
jstring file = NULL;
jobject fileFilter = NULL;
jobject target = NULL;
jobject parent = NULL;
AwtComponent* awtParent = NULL;
jboolean multipleMode = JNI_FALSE;
OPENFILENAME ofn;
memset(&ofn, 0, sizeof(ofn));
/*
* There's a situation (see bug 4906972) when InvokeFunction (by which this method is called)
* returnes earlier than this method returnes. Probably it's caused due to ReplyMessage system call.
* So for the avoidance of this mistiming we need to make new global reference here
* (not local as it's used by the hook) and then manage it independently of the calling thread.
*/
peer = env->NewGlobalRef((jobject)p);
try {
DASSERT(peer);
target = env->GetObjectField(peer, AwtObject::targetID);
parent = env->GetObjectField(peer, AwtFileDialog::parentID);
if (parent != NULL) {
awtParent = (AwtComponent *)JNI_GET_PDATA(parent);
}
// DASSERT(awtParent);
title = (jstring)(env)->GetObjectField(target, AwtDialog::titleID);
HWND hwndOwner = awtParent ? awtParent->GetHWnd() : NULL;
if (title == NULL || env->GetStringLength(title)==0) {
title = JNU_NewStringPlatform(env, &unicodeChar);
}
JavaStringBuffer titleBuffer(env, title);
directory =
(jstring)env->GetObjectField(target, AwtFileDialog::dirID);
JavaStringBuffer directoryBuffer(env, directory);
multipleMode = env->CallBooleanMethod(peer, AwtFileDialog::isMultipleModeMID);
UINT bufferLimit;
if (multipleMode == JNI_TRUE) {
bufferLimit = MULTIPLE_MODE_BUFFER_LIMIT;
} else {
bufferLimit = SINGLE_MODE_BUFFER_LIMIT;
}
LPTSTR fileBuffer = new TCHAR[bufferLimit];
memset(fileBuffer, 0, bufferLimit * sizeof(TCHAR));
file = (jstring)env->GetObjectField(target, AwtFileDialog::fileID);
if (file != NULL) {
LPCTSTR tmp = JNU_GetStringPlatformChars(env, file, NULL);
_tcscpy(fileBuffer, tmp);
JNU_ReleaseStringPlatformChars(env, file, tmp);
} else {
fileBuffer[0] = _T('\0');
}
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFilter = s_fileFilterString;
ofn.nFilterIndex = 1;
/*
Fix for 6488834.
To disable Win32 native parent modality we have to set
hwndOwner field to either NULL or some hidden window. For
parentless dialogs we use NULL to show them in the taskbar,
and for all other dialogs AwtToolkit's HWND is used.
*/
if (awtParent != NULL)
{
ofn.hwndOwner = AwtToolkit::GetInstance().GetHWnd();
}
else
{
ofn.hwndOwner = NULL;
}
ofn.lpstrFile = fileBuffer;
ofn.nMaxFile = bufferLimit;
ofn.lpstrTitle = titleBuffer;
ofn.lpstrInitialDir = directoryBuffer;
ofn.Flags = OFN_LONGNAMES | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY |
OFN_ENABLEHOOK | OFN_EXPLORER | OFN_ENABLESIZING;
fileFilter = env->GetObjectField(peer,
AwtFileDialog::fileFilterID);
if (!JNU_IsNull(env,fileFilter)) {
ofn.Flags |= OFN_ENABLEINCLUDENOTIFY;
}
ofn.lCustData = (LPARAM)peer;
ofn.lpfnHook = (LPOFNHOOKPROC)FileDialogHookProc;
if (multipleMode == JNI_TRUE) {
ofn.Flags |= OFN_ALLOWMULTISELECT;
}
// Save current directory, so we can reset if it changes.
currentDirectory = new TCHAR[MAX_PATH+1];
VERIFY(::GetCurrentDirectory(MAX_PATH, currentDirectory) > 0);
mode = env->GetIntField(target, AwtFileDialog::modeID);
AwtDialog::CheckInstallModalHook();
// show the Win32 file dialog
if (mode == java_awt_FileDialog_LOAD) {
result = AwtFileDialog::GetOpenFileName(&ofn);
} else {
result = AwtFileDialog::GetSaveFileName(&ofn);
}
// Fix for 4181310: FileDialog does not show up.
// If the dialog is not shown because of invalid file name
// replace the file name by empty string.
if (!result) {
dlgerr = ::CommDlgExtendedError();
if (dlgerr == FNERR_INVALIDFILENAME) {
_tcscpy(fileBuffer, TEXT(""));
if (mode == java_awt_FileDialog_LOAD) {
result = AwtFileDialog::GetOpenFileName(&ofn);
} else {
result = AwtFileDialog::GetSaveFileName(&ofn);
}
}
}
AwtDialog::CheckUninstallModalHook();
DASSERT(env->GetLongField(peer, AwtComponent::hwndID) == 0L);
AwtDialog::ModalActivateNextWindow(NULL, target, peer);
VERIFY(::SetCurrentDirectory(currentDirectory));
// Report result to peer.
if (result) {
jint length = (jint)GetBufferLength(ofn.lpstrFile, ofn.nMaxFile);
jcharArray jnames = env->NewCharArray(length);
env->SetCharArrayRegion(jnames, 0, length, (jchar*)ofn.lpstrFile);
env->CallVoidMethod(peer, AwtFileDialog::handleSelectedMID, jnames);
env->DeleteLocalRef(jnames);
} else {
env->CallVoidMethod(peer, AwtFileDialog::handleCancelMID);
}
DASSERT(!safe_ExceptionOccurred(env));
} catch (...) {
env->DeleteLocalRef(target);
env->DeleteLocalRef(parent);
env->DeleteLocalRef(title);
env->DeleteLocalRef(directory);
env->DeleteLocalRef(file);
env->DeleteLocalRef(fileFilter);
env->DeleteGlobalRef(peer);
delete[] currentDirectory;
if (ofn.lpstrFile)
delete[] ofn.lpstrFile;
throw;
}
env->DeleteLocalRef(target);
env->DeleteLocalRef(parent);
env->DeleteLocalRef(title);
env->DeleteLocalRef(directory);
env->DeleteLocalRef(file);
env->DeleteLocalRef(fileFilter);
env->DeleteGlobalRef(peer);
delete[] currentDirectory;
if (ofn.lpstrFile)
delete[] ofn.lpstrFile;
}
static UINT_PTR CALLBACK
FileDialogHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
TRY;
HWND parent = ::GetParent(hdlg);
switch(uiMsg) {
case WM_INITDIALOG: {
OPENFILENAME *ofn = (OPENFILENAME *)lParam;
jobject peer = (jobject)(ofn->lCustData);
env->CallVoidMethod(peer, AwtFileDialog::setHWndMID,
(jlong)parent);
::SetProp(parent, ModalDialogPeerProp, reinterpret_cast<HANDLE>(peer));
// fix for 4508670 - disable CS_SAVEBITS
DWORD style = ::GetClassLong(hdlg,GCL_STYLE);
::SetClassLong(hdlg,GCL_STYLE,style & ~CS_SAVEBITS);
// set appropriate icon for parentless dialogs
jobject awtParent = env->GetObjectField(peer, AwtFileDialog::parentID);
if (awtParent == NULL) {
::SendMessage(parent, WM_SETICON, (WPARAM)ICON_BIG,
(LPARAM)AwtToolkit::GetInstance().GetAwtIcon());
} else {
AwtWindow *awtWindow = (AwtWindow *)JNI_GET_PDATA(awtParent);
::SendMessage(parent, WM_SETICON, (WPARAM)ICON_BIG,
(LPARAM)(awtWindow->GetHIcon()));
::SendMessage(parent, WM_SETICON, (WPARAM)ICON_SMALL,
(LPARAM)(awtWindow->GetHIconSm()));
env->DeleteLocalRef(awtParent);
}
// subclass dialog's parent to receive additional messages
WNDPROC lpfnWndProc = ComCtl32Util::GetInstance().SubclassHWND(parent,
FileDialogWndProc);
::SetProp(parent, NativeDialogWndProcProp, reinterpret_cast<HANDLE>(lpfnWndProc));
::SetProp(parent, OpenFileNameProp, (void *)lParam);
break;
}
case WM_DESTROY: {
HIMC hIMC = ::ImmGetContext(hdlg);
if (hIMC != NULL) {
::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
::ImmReleaseContext(hdlg, hIMC);
}
WNDPROC lpfnWndProc = (WNDPROC)(::GetProp(parent, NativeDialogWndProcProp));
ComCtl32Util::GetInstance().UnsubclassHWND(parent,
FileDialogWndProc,
lpfnWndProc);
::RemoveProp(parent, ModalDialogPeerProp);
::RemoveProp(parent, NativeDialogWndProcProp);
::RemoveProp(parent, OpenFileNameProp);
break;
}
case WM_NOTIFY: {
OFNOTIFYEX *notifyEx = (OFNOTIFYEX *)lParam;
if (notifyEx) {
jobject peer = (jobject)(::GetProp(parent, ModalDialogPeerProp));
if (notifyEx->hdr.code == CDN_INCLUDEITEM) {
LPITEMIDLIST pidl = (LPITEMIDLIST)notifyEx->pidl;
// Get the filename and directory
TCHAR szPath[MAX_PATH];
if (!::SHGetPathFromIDList(pidl, szPath)) {
return TRUE;
}
jstring strPath = JNU_NewStringPlatform(env, szPath);
if (strPath == NULL) {
throw std::bad_alloc();
}
// Call FilenameFilter.accept with path and filename
UINT uRes = (env->CallBooleanMethod(peer,
AwtFileDialog::checkFilenameFilterMID, strPath) == JNI_TRUE);
env->DeleteLocalRef(strPath);
return uRes;
} else if (notifyEx->hdr.code == CDN_FILEOK) {
// This notification is sent when user selects some file and presses
// OK button; it is not sent when no file is selected. So it's time
// to unblock all the windows blocked by this dialog as it will
// be closed soon
env->CallVoidMethod(peer, AwtFileDialog::setHWndMID, (jlong)0);
} else if (notifyEx->hdr.code == CDN_SELCHANGE) {
// reallocate the buffer if the buffer is too small
LPOPENFILENAME lpofn = (LPOPENFILENAME)GetProp(parent, OpenFileNameProp);
UINT nLength = CommDlg_OpenSave_GetSpec(parent, NULL, 0) +
CommDlg_OpenSave_GetFolderPath(parent, NULL, 0);
if (lpofn->nMaxFile < nLength)
{
// allocate new buffer
LPTSTR newBuffer = new TCHAR[nLength];
if (newBuffer) {
memset(newBuffer, 0, nLength * sizeof(TCHAR));
LPTSTR oldBuffer = lpofn->lpstrFile;
lpofn->lpstrFile = newBuffer;
lpofn->nMaxFile = nLength;
// free the previously allocated buffer
if (oldBuffer) {
delete[] oldBuffer;
}
}
}
}
}
break;
}
}
return FALSE;
CATCH_BAD_ALLOC_RET(TRUE);
}
