| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.intellij.ui.mac; |
| |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.ui.DialogWrapper; |
| import com.intellij.openapi.ui.Messages; |
| import com.intellij.openapi.util.SystemInfo; |
| import com.intellij.openapi.util.registry.Registry; |
| import com.intellij.openapi.util.text.StringUtil; |
| import com.intellij.openapi.wm.IdeFocusManager; |
| import com.intellij.openapi.wm.WindowManager; |
| import com.intellij.openapi.wm.impl.ModalityHelper; |
| import com.intellij.ui.mac.foundation.ID; |
| import com.intellij.ui.mac.foundation.MacUtil; |
| import com.intellij.util.ui.UIUtil; |
| import com.sun.jna.Callback; |
| import com.sun.jna.Pointer; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.awt.event.InputEvent; |
| import java.awt.event.WindowAdapter; |
| import java.awt.event.WindowEvent; |
| import java.lang.reflect.Method; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import static com.intellij.ui.mac.foundation.Foundation.*; |
| |
| /** |
| * @author pegov |
| */ |
| public class MacMessagesImpl extends MacMessages { |
| private static final Logger LOG = Logger.getInstance("#com.intellij.ui.mac.MacMessages"); |
| |
| |
| private static class MessageResult { |
| MessageResult (int returnCode, boolean suppress) { |
| myReturnCode = returnCode; |
| mySuppress = suppress; |
| } |
| private final int myReturnCode; |
| private final boolean mySuppress; |
| } |
| |
| private static final Map<Window, MessageResult> resultsFromDocumentRoot = new HashMap<Window, MessageResult> (); |
| private static final Map<Window, MacMessagesQueue<Runnable>> queuesFromDocumentRoot = new HashMap<Window, MacMessagesQueue<Runnable>>(); |
| |
| private static final Callback SHEET_DID_END = new Callback() { |
| @SuppressWarnings("UnusedDeclaration") |
| public void callback(ID self, String selector, ID alert, ID returnCode, ID contextInfo) { |
| synchronized (lock) { |
| Window documentRoot = windowFromId.get(contextInfo.longValue()); |
| processResult(documentRoot); |
| ID suppressState = invoke(invoke(alert, "suppressionButton"), "state"); |
| resultsFromDocumentRoot.put(documentRoot, new MessageResult(returnCode.intValue(), suppressState.intValue() == 1)); |
| queuesFromDocumentRoot.get(windowFromId.get(contextInfo.longValue())).runFromQueue(); |
| } |
| JDK7WindowReorderingWorkaround.enableReordering(); |
| cfRelease(self); |
| } |
| }; |
| |
| private static final Callback VARIABLE_BUTTONS_SHEET_PANEL = new Callback() { |
| @SuppressWarnings("UnusedDeclaration") |
| public void callback(ID self, String selector, ID params) { |
| ID title = invoke(params, "objectAtIndex:", 0); |
| ID message = invoke(params, "objectAtIndex:", 1); |
| ID focusedWindow = invoke(params, "objectAtIndex:", 2); |
| ID alertStyle = invoke(params, "objectAtIndex:", 4); |
| ID doNotAskText = invoke(params, "objectAtIndex:", 5); |
| int defaultOptionIndex = Integer.parseInt(toStringViaUTF8(invoke(params, "objectAtIndex:", 6))); |
| int focusedOptionIndex = Integer.parseInt(toStringViaUTF8(invoke(params, "objectAtIndex:", 7))); |
| ID buttons = invoke(params, "objectAtIndex:", 8); |
| ID doNotAskChecked = invoke(params, "objectAtIndex:", 9); |
| |
| ID alert = invoke(invoke("NSAlert", "alloc"), "init"); |
| |
| invoke(alert, "setMessageText:", title); |
| invoke(alert, "setInformativeText:", message); |
| |
| if ("error".equals(toStringViaUTF8(alertStyle))) { |
| invoke(alert, "setAlertStyle:", 2); // NSCriticalAlertStyle = 2 |
| } |
| |
| final ID buttonEnumerator = invoke(buttons, "objectEnumerator"); |
| while (true) { |
| final ID button = invoke(buttonEnumerator, "nextObject"); |
| if (0 == button.intValue()) break; |
| invoke(alert, "addButtonWithTitle:", button); |
| } |
| |
| if (defaultOptionIndex != -1) { |
| invoke(invoke(alert, "window"), "setDefaultButtonCell:", |
| invoke(invoke(invoke(alert, "buttons"), "objectAtIndex:", defaultOptionIndex), "cell")); |
| } |
| |
| // it seems like asking for focus will cause java to go and query focus owner too, which may cause dead locks on main-thread |
| //if (focusedOptionIndex != -1) { |
| // invoke(invoke(alert, "window"), "makeFirstResponder:", |
| // invoke(invoke(alert, "buttons"), "objectAtIndex:", focusedOptionIndex)); |
| //} else { |
| // int count = invoke(buttons, "count").intValue(); |
| // invoke(invoke(alert, "window"), "makeFirstResponder:", |
| // invoke(invoke(alert, "buttons"), "objectAtIndex:", count == 1 ? 0 : 1)); |
| //} |
| |
| enableEscapeToCloseTheMessage(alert); |
| |
| String doNotAsk = toStringViaUTF8(doNotAskText); |
| if (!"-1".equals(doNotAsk)) { |
| invoke(alert, "setShowsSuppressionButton:", 1); |
| invoke(invoke(alert, "suppressionButton"), "setTitle:", doNotAskText); |
| invoke(invoke(alert, "suppressionButton"), "setState:", "checked".equals(toStringViaUTF8(doNotAskChecked))); |
| } |
| |
| invoke(alert, "beginSheetModalForWindow:modalDelegate:didEndSelector:contextInfo:", focusedWindow, self, |
| createSelector("alertDidEnd:returnCode:contextInfo:"), focusedWindow); |
| cfRelease(alert); |
| } |
| }; |
| |
| private static final Callback SIMPLE_SHEET_PANEL = new Callback() { |
| @SuppressWarnings("UnusedDeclaration") |
| public void callback(ID self, String selector, ID params) { |
| ID title = invoke(params, "objectAtIndex:", 0); |
| ID defaultText = invoke(params, "objectAtIndex:", 1); |
| ID otherText = invoke(params, "objectAtIndex:", 2); |
| ID alternateText = invoke(params, "objectAtIndex:", 3); |
| ID message = invoke(params, "objectAtIndex:", 4); |
| ID focusedWindow = invoke(params, "objectAtIndex:", 5); |
| ID alertStyle = invoke(params, "objectAtIndex:", 7); |
| ID doNotAskText = invoke(params, "objectAtIndex:", 8); |
| ID doNotAskChecked = invoke(params, "objectAtIndex:", 9); |
| |
| boolean alternateExist = !"-1".equals(toStringViaUTF8(alternateText)); |
| boolean otherExist = !"-1".equals(toStringViaUTF8(otherText)); |
| |
| final ID alert = invoke("NSAlert", "alertWithMessageText:defaultButton:alternateButton:otherButton:informativeTextWithFormat:", |
| title, defaultText, alternateExist ? alternateText : null, otherExist ? otherText : null, message); |
| |
| if ("error".equals(toStringViaUTF8(alertStyle))) { |
| invoke(alert, "setAlertStyle:", 2); // NSCriticalAlertStyle = 2 |
| } |
| |
| // it seems like asking for focus will cause java to go and query focus owner too, which may cause dead locks on main-thread |
| //ID window = invoke(alert, "window"); |
| //invoke(window, "makeFirstResponder:", |
| // invoke(invoke(alert, "buttons"), "objectAtIndex:", alternateExist ? 2 : otherExist ? 1 : 0)); |
| // |
| |
| if (!alternateExist) { |
| enableEscapeToCloseTheMessage(alert); |
| } |
| |
| String doNotAsk = toStringViaUTF8(doNotAskText); |
| if (!"-1".equals(doNotAsk)) { |
| invoke(alert, "setShowsSuppressionButton:", 1); |
| invoke(invoke(alert, "suppressionButton"), "setTitle:", doNotAskText); |
| invoke(invoke(alert, "suppressionButton"), "setState:", "checked".equals(toStringViaUTF8(doNotAskChecked))); |
| } |
| |
| invoke(alert, "beginSheetModalForWindow:modalDelegate:didEndSelector:contextInfo:", focusedWindow, self, |
| createSelector("alertDidEnd:returnCode:contextInfo:"), focusedWindow); |
| } |
| }; |
| |
| private static void processResult(Window w) { |
| synchronized (lock) { |
| if (!blockedDocumentRoots.keySet().contains(w)) { |
| throw new RuntimeException("Window should be in th list."); |
| } |
| |
| int openedSheetsForWindow = blockedDocumentRoots.get(w); |
| |
| if (openedSheetsForWindow < 1) { |
| throw new RuntimeException("We should have at least one window in the list"); |
| } |
| |
| if (openedSheetsForWindow == 1) { |
| // The last sheet |
| blockedDocumentRoots.remove(w); |
| } else { |
| blockedDocumentRoots.put(w, openedSheetsForWindow - 1); |
| } |
| |
| } |
| } |
| |
| private static void enableEscapeToCloseTheMessage(ID alert) { |
| int buttonsNumber = invoke(invoke(alert, "buttons"), "count").intValue(); |
| if (buttonsNumber < 2) return; |
| invoke(invoke(invoke(alert, "buttons"), "objectAtIndex:", |
| buttonsNumber - 1), "setKeyEquivalent:", nsString("\033")); |
| } |
| |
| private MacMessagesImpl() {} |
| |
| private static final Callback windowDidBecomeMainCallback = new Callback() { |
| @SuppressWarnings("UnusedDeclaration") // this is a native up-call |
| public void callback(ID self, |
| ID nsNotification) |
| { |
| synchronized (lock) { |
| if (!windowFromId.keySet().contains(self.longValue())) { |
| return; |
| } |
| } |
| invoke(self, "oldWindowDidBecomeMain:", nsNotification); |
| } |
| }; |
| |
| static { |
| if (SystemInfo.isMac) { |
| final ID delegateClass = allocateObjcClassPair(getObjcClass("NSObject"), "NSAlertDelegate_"); |
| if (!addMethod(delegateClass, createSelector("alertDidEnd:returnCode:contextInfo:"), SHEET_DID_END, "v*")) { |
| throw new RuntimeException("Unable to add method to objective-c delegate class!"); |
| } |
| if (!addMethod(delegateClass, createSelector("showSheet:"), SIMPLE_SHEET_PANEL, "v*")) { |
| throw new RuntimeException("Unable to add method to objective-c delegate class!"); |
| } |
| if (!addMethod(delegateClass, createSelector("showVariableButtonsSheet:"), VARIABLE_BUTTONS_SHEET_PANEL, "v*")) { |
| throw new RuntimeException("Unable to add method to objective-c delegate class!"); |
| } |
| registerObjcClassPair(delegateClass); |
| |
| if (SystemInfo.isJavaVersionAtLeast("1.7")) { |
| |
| ID awtWindow = getObjcClass("AWTWindow"); |
| |
| Pointer windowWillEnterFullScreenMethod = createSelector("windowDidBecomeMain:"); |
| ID originalWindowWillEnterFullScreen = class_replaceMethod(awtWindow, windowWillEnterFullScreenMethod, |
| windowDidBecomeMainCallback, "v@::@"); |
| |
| addMethodByID(awtWindow, createSelector("oldWindowDidBecomeMain:"), |
| originalWindowWillEnterFullScreen, "v@::@"); |
| |
| } |
| } |
| } |
| |
| @Override |
| public void showOkMessageDialog(@NotNull String title, String message, @NotNull String okText, @Nullable Window window) { |
| showAlertDialog(title, okText, null, null, message, window); |
| } |
| |
| @Override |
| public void showOkMessageDialog(@NotNull String title, String message, @NotNull String okText) { |
| showAlertDialog(title, okText, null, null, message, null); |
| } |
| |
| @Override |
| @Messages.YesNoResult |
| public int showYesNoDialog(@NotNull String title, String message, @NotNull String yesButton, @NotNull String noButton, @Nullable Window window) { |
| return showAlertDialog(title, yesButton, null, noButton, message, window) == Messages.YES ? Messages.YES : Messages.NO; |
| } |
| |
| @Override |
| @Messages.YesNoResult |
| public int showYesNoDialog(@NotNull String title, String message, @NotNull String yesButton, @NotNull String noButton, @Nullable Window window, |
| @Nullable DialogWrapper.DoNotAskOption doNotAskDialogOption) { |
| return showAlertDialog(title, yesButton, null, noButton, message, window, false, doNotAskDialogOption) == Messages.YES ? Messages.YES : Messages.NO; |
| } |
| |
| @Override |
| public void showErrorDialog(@NotNull String title, String message, @NotNull String okButton, @Nullable Window window) { |
| showAlertDialog(title, okButton, null, null, message, window, true, null); |
| } |
| |
| @Override |
| @Messages.YesNoCancelResult |
| public int showYesNoCancelDialog(@NotNull String title, |
| String message, |
| @NotNull String defaultButton, |
| String alternateButton, |
| String otherButton, |
| Window window, |
| @Nullable DialogWrapper.DoNotAskOption doNotAskOption) { |
| return showAlertDialog(title, defaultButton, alternateButton, otherButton, message, window, false, doNotAskOption); |
| } |
| |
| private static final Object lock = new Object(); |
| |
| private static final HashMap<Window, Integer> blockedDocumentRoots = new HashMap<Window, Integer>(); |
| |
| private static final HashMap<Long, Window> windowFromId = new HashMap<Long, Window>(); |
| |
| public static void pumpEventsDocumentExclusively (Window documentRoot) { |
| |
| Integer messageNumber = blockedDocumentRoots.get(documentRoot); |
| |
| EventQueue theQueue = documentRoot.getToolkit().getSystemEventQueue(); |
| |
| do { |
| try { |
| AWTEvent event = theQueue.getNextEvent(); |
| boolean eventOk = true; |
| if (event instanceof InputEvent) { |
| final Object s = event.getSource(); |
| if (s instanceof Component) { |
| Component c = (Component)s; |
| |
| Window w = findDocumentRoot(c); |
| if (w == documentRoot) { |
| eventOk = false; |
| ((InputEvent)event).consume(); |
| } |
| } |
| } |
| |
| if (eventOk) { |
| Class<?>[] paramString = new Class<?>[1]; |
| paramString[0] = AWTEvent.class; |
| Method method = theQueue.getClass().getDeclaredMethod("dispatchEvent",paramString); |
| method.setAccessible(true); |
| method.invoke(theQueue, event); |
| } |
| } |
| catch (MacMessageException mme) { |
| throw mme; |
| } |
| catch (Throwable e) { |
| LOG.error(e); |
| } |
| } |
| while (isBlockedDocumentRoot(documentRoot, messageNumber)); |
| } |
| |
| private static boolean isBlockedDocumentRoot(Window documentRoot, Integer messageNumber) { |
| synchronized (lock) { |
| return messageNumber.equals(blockedDocumentRoots.get(documentRoot)); |
| } |
| } |
| |
| private static Window findDocumentRoot (final Component c) { |
| if (c == null) return null; |
| Window w = c instanceof Window ? (Window)c : getContainingWindow(c); |
| synchronized (c.getTreeLock()) { |
| while (w.getOwner() != null) { |
| w = w.getOwner(); |
| } |
| } |
| return w; |
| } |
| |
| // This method is not available in jdk 1.6.0_6. Should be changed to the JDK implementation |
| // as soon as we will have switched on JDK 7. |
| private static Window getContainingWindow(Component comp) { |
| while (comp != null && !(comp instanceof Window)) { |
| comp = comp.getParent(); |
| } |
| return (Window)comp; |
| } |
| |
| private static void startModal(final Window w, ID windowId) { |
| long windowPtr = windowId.longValue(); |
| synchronized (lock) { |
| JDK7WindowReorderingWorkaround.disableReordering(); |
| windowFromId.put(windowPtr, w); |
| if (blockedDocumentRoots.keySet().contains(w)) { |
| blockedDocumentRoots.put(w, blockedDocumentRoots.get(w) + 1); |
| } else { |
| blockedDocumentRoots.put(w, 1); |
| } |
| } |
| |
| pumpEventsDocumentExclusively(w); |
| synchronized (lock) { |
| windowFromId.remove(windowPtr); |
| } |
| } |
| |
| private enum COMMON_DIALOG_PARAM_TYPE { |
| title, |
| message, |
| errorStyle, |
| doNotAskDialogOption1, |
| doNotAskDialogOption2, |
| nativeFocusedWindow |
| } |
| |
| private enum MESSAGE_DIALOG_PARAM_TYPE { |
| buttonsArray, |
| defaultOptionIndex, |
| focusedOptionIndex |
| } |
| |
| private enum ALERT_DIALOG_PARAM_TYPE { |
| defaultText, |
| alternateText, |
| otherText |
| } |
| |
| private static class DialogParamsWrapper { |
| private ID window = null; |
| private final Map<Enum, Object> params; |
| private final DialogType dialogType; |
| |
| private enum DialogType { |
| alert, |
| message |
| } |
| |
| private DialogParamsWrapper(@NotNull DialogType t, @NotNull Map<Enum, Object> p) { |
| dialogType = t; |
| params = p; |
| } |
| |
| private void setNativeWindow (final ID w) { |
| window = w; |
| } |
| |
| private ID getParamsAsID() { |
| if (window == null) { |
| throw new MacMessageException("Window should be in the list."); |
| } |
| params.put(COMMON_DIALOG_PARAM_TYPE.nativeFocusedWindow, window); |
| |
| ID paramsAsID = null; |
| |
| switch (dialogType) { |
| case alert: |
| paramsAsID = getParamsForAlertDialog(params); |
| break; |
| case message: |
| paramsAsID = getParamsForMessageDialog(params); |
| break; |
| } |
| return paramsAsID; |
| } |
| |
| |
| private static ID getParamsForAlertDialog(@NotNull Map<Enum, Object> params) { |
| return invoke("NSArray", "arrayWithObjects:", |
| params.get(COMMON_DIALOG_PARAM_TYPE.title), |
| params.get(ALERT_DIALOG_PARAM_TYPE.defaultText), |
| params.get(ALERT_DIALOG_PARAM_TYPE.alternateText), |
| params.get(ALERT_DIALOG_PARAM_TYPE.otherText), |
| params.get(COMMON_DIALOG_PARAM_TYPE.message), |
| params.get(COMMON_DIALOG_PARAM_TYPE.nativeFocusedWindow), |
| nsString(""), |
| params.get(COMMON_DIALOG_PARAM_TYPE.errorStyle), |
| params.get(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption1), |
| params.get(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption2), |
| null); |
| } |
| |
| private static ID getParamsForMessageDialog(@NotNull Map<Enum, Object> params) { |
| return invoke("NSArray", "arrayWithObjects:", |
| params.get(COMMON_DIALOG_PARAM_TYPE.title), |
| params.get(COMMON_DIALOG_PARAM_TYPE.message), |
| params.get(COMMON_DIALOG_PARAM_TYPE.nativeFocusedWindow), |
| nsString(""), |
| params.get(COMMON_DIALOG_PARAM_TYPE.errorStyle), |
| params.get(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption1), |
| params.get(MESSAGE_DIALOG_PARAM_TYPE.defaultOptionIndex), |
| params.get(MESSAGE_DIALOG_PARAM_TYPE.focusedOptionIndex), |
| params.get(MESSAGE_DIALOG_PARAM_TYPE.buttonsArray), |
| params.get(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption2), |
| null); |
| } |
| } |
| |
| @Messages.YesNoCancelResult |
| public static int showAlertDialog(@NotNull String title, |
| @NotNull String defaultText, |
| @Nullable final String alternateText, |
| @Nullable final String otherText, |
| final String message, |
| @Nullable Window window, |
| final boolean errorStyle, |
| @Nullable final DialogWrapper.DoNotAskOption doNotAskDialogOption) { |
| |
| Map<Enum, Object> params = new HashMap<Enum, Object> (); |
| |
| ID pool = invoke(invoke("NSAutoreleasePool", "alloc"), "init"); |
| try { |
| params.put(COMMON_DIALOG_PARAM_TYPE.title, nsString(title)); |
| params.put(ALERT_DIALOG_PARAM_TYPE.defaultText, nsString(UIUtil.removeMnemonic(defaultText))); |
| params.put(ALERT_DIALOG_PARAM_TYPE.alternateText, nsString(otherText == null ? "-1" : UIUtil.removeMnemonic(otherText))); |
| params.put(ALERT_DIALOG_PARAM_TYPE.otherText, nsString(alternateText == null ? "-1" : UIUtil.removeMnemonic(alternateText))); |
| // replace % -> %% to avoid formatted parameters (causes SIGTERM) |
| params.put(COMMON_DIALOG_PARAM_TYPE.message, nsString(StringUtil.stripHtml(message == null ? "" : message, true).replace("%", "%%"))); |
| params.put(COMMON_DIALOG_PARAM_TYPE.errorStyle, nsString(errorStyle ? "error" : "-1")); |
| params.put(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption1, nsString(doNotAskDialogOption == null || !doNotAskDialogOption.canBeHidden() |
| // TODO: state=!doNotAsk.shouldBeShown() |
| ? "-1" |
| : doNotAskDialogOption.getDoNotShowMessage())); |
| params.put(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption2, nsString(doNotAskDialogOption != null |
| && !doNotAskDialogOption.isToBeShown() ? "checked" : "-1")); |
| MessageResult result = resultsFromDocumentRoot.remove( |
| showDialog(window, "showSheet:", new DialogParamsWrapper(DialogParamsWrapper.DialogType.alert, params))); |
| |
| int convertedResult = convertReturnCodeFromNativeAlertDialog(result.myReturnCode, alternateText); |
| |
| if (doNotAskDialogOption != null && doNotAskDialogOption.canBeHidden()) { |
| boolean operationCanceled = convertedResult == Messages.CANCEL; |
| if (!operationCanceled || doNotAskDialogOption.shouldSaveOptionsOnCancel()) { |
| doNotAskDialogOption.setToBeShown(!result.mySuppress, convertedResult); |
| } |
| } |
| |
| return convertedResult; |
| } |
| finally { |
| invoke(pool, "release"); |
| } |
| } |
| |
| @Override |
| public int showMessageDialog(@NotNull final String title, |
| final String message, |
| @NotNull final String[] buttons, |
| final boolean errorStyle, |
| @Nullable Window window, |
| final int defaultOptionIndex, |
| final int focusedOptionIndex, |
| @Nullable final DialogWrapper.DoNotAskOption doNotAskDialogOption) { |
| ID pool = invoke(invoke("NSAutoreleasePool", "alloc"), "init"); |
| try { |
| final ID buttonsArray = invoke("NSMutableArray", "array"); |
| for (String s : buttons) { |
| ID s1 = nsString(UIUtil.removeMnemonic(s)); |
| invoke(buttonsArray, "addObject:", s1); |
| } |
| |
| Map<Enum, Object> params = new HashMap<Enum, Object>(); |
| |
| params.put(COMMON_DIALOG_PARAM_TYPE.title, nsString(title)); |
| // replace % -> %% to avoid formatted parameters (causes SIGTERM) |
| params.put(COMMON_DIALOG_PARAM_TYPE.message, nsString(StringUtil.stripHtml(message == null ? "" : message, true).replace("%", "%%"))); |
| |
| params.put(COMMON_DIALOG_PARAM_TYPE.errorStyle, nsString(errorStyle ? "error" : "-1")); |
| params.put(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption1, nsString(doNotAskDialogOption == null || !doNotAskDialogOption.canBeHidden() |
| // TODO: state=!doNotAsk.shouldBeShown() |
| ? "-1" |
| : doNotAskDialogOption.getDoNotShowMessage())); |
| params.put(COMMON_DIALOG_PARAM_TYPE.doNotAskDialogOption2, nsString(doNotAskDialogOption != null && !doNotAskDialogOption.isToBeShown() ? "checked" : "-1")); |
| params.put(MESSAGE_DIALOG_PARAM_TYPE.defaultOptionIndex, nsString(Integer.toString(defaultOptionIndex))); |
| params.put(MESSAGE_DIALOG_PARAM_TYPE.focusedOptionIndex, nsString(Integer.toString(focusedOptionIndex))); |
| params.put(MESSAGE_DIALOG_PARAM_TYPE.buttonsArray, buttonsArray); |
| |
| MessageResult result = resultsFromDocumentRoot.remove(showDialog(window, "showVariableButtonsSheet:", |
| new DialogParamsWrapper(DialogParamsWrapper.DialogType.message, params))); |
| |
| final int code = convertReturnCodeFromNativeMessageDialog(result.myReturnCode); |
| |
| final int cancelCode = buttons.length - 1; |
| |
| if (doNotAskDialogOption != null && doNotAskDialogOption.canBeHidden()) { |
| if (cancelCode != code || doNotAskDialogOption.shouldSaveOptionsOnCancel()) { |
| doNotAskDialogOption.setToBeShown(!result.mySuppress, code); |
| } |
| } |
| |
| return code; |
| } |
| finally { |
| invoke(pool, "release"); |
| } |
| } |
| |
| //title, message, errorStyle, window, paramsArray, doNotAskDialogOption, "showVariableButtonsSheet:" |
| private static Window showDialog(@Nullable Window window, final String methodName, final DialogParamsWrapper paramsWrapper) { |
| |
| final Window foremostWindow = getForemostWindow(window); |
| |
| final Window documentRoot = getDocumentRootFromWindow(foremostWindow); |
| |
| final ID nativeFocusedWindow = MacUtil.findWindowFromJavaWindow(foremostWindow); |
| |
| paramsWrapper.setNativeWindow(nativeFocusedWindow); |
| |
| final ID paramsArray = paramsWrapper.getParamsAsID(); |
| |
| foremostWindow.addWindowListener(new WindowAdapter() { |
| @Override |
| public void windowClosed(WindowEvent e) { |
| super.windowClosed(e); |
| //if (blockedDocumentRoots.get(documentRoot) != null) { |
| // LOG.assertTrue(blockedDocumentRoots.get(documentRoot) < 2); |
| //} |
| queuesFromDocumentRoot.remove(documentRoot); |
| if (blockedDocumentRoots.remove(documentRoot) != null) { |
| throw new MacMessageException("Owner window has been removed"); |
| } |
| } |
| }); |
| |
| final ID delegate = invoke(invoke(getObjcClass("NSAlertDelegate_"), "alloc"), "init"); |
| |
| IdeFocusManager.getGlobalInstance().setTypeaheadEnabled(false); |
| |
| runOrPostponeForWindow(documentRoot, new Runnable() { |
| @Override |
| public void run() { |
| invoke(delegate, "performSelectorOnMainThread:withObject:waitUntilDone:", |
| createSelector(methodName), paramsArray, false); |
| } |
| }); |
| |
| startModal(documentRoot, nativeFocusedWindow); |
| |
| IdeFocusManager.getGlobalInstance().setTypeaheadEnabled(true); |
| return documentRoot; |
| } |
| |
| private static int convertReturnCodeFromNativeMessageDialog(int result) { |
| return result - 1000; |
| } |
| |
| @Messages.YesNoCancelResult |
| private static int convertReturnCodeFromNativeAlertDialog(int returnCode, String alternateText) { |
| // DEFAULT = 1 |
| // ALTERNATE = 0 |
| // OTHER = -1 (cancel) |
| |
| int cancelCode; |
| int code; |
| if (alternateText != null) { |
| // DEFAULT = 0 |
| // ALTERNATE = 1 |
| // CANCEL = 2 |
| |
| cancelCode = Messages.CANCEL; |
| |
| switch (returnCode) { |
| case 1: |
| code = Messages.YES; |
| break; |
| case 0: |
| code = Messages.NO; |
| break; |
| case -1: // cancel |
| default: |
| code = Messages.CANCEL; |
| break; |
| } |
| } |
| else { |
| // DEFAULT = 0 |
| // CANCEL = 1 |
| |
| cancelCode = 1; |
| |
| switch (returnCode) { |
| case 1: |
| code = Messages.YES; |
| break; |
| case -1: // cancel |
| default: |
| code = Messages.NO; |
| break; |
| } |
| } |
| |
| if (cancelCode == code) { |
| code = Messages.CANCEL; |
| } |
| LOG.assertTrue(code == Messages.YES || code == Messages.NO || code == Messages.CANCEL, code); |
| return code; |
| } |
| |
| private static void runOrPostponeForWindow(Window documentRoot, Runnable task) { |
| synchronized (lock) { |
| MacMessagesQueue<Runnable> queue = queuesFromDocumentRoot.get(documentRoot); |
| |
| if (queue == null) { |
| queue = new MacMessagesQueue<Runnable>(); |
| queuesFromDocumentRoot.put(documentRoot, queue); |
| } |
| |
| queue.runOrEnqueue(task); |
| } |
| } |
| |
| private static Window getForemostWindow(final Window window) { |
| Window _window = null; |
| IdeFocusManager ideFocusManager = IdeFocusManager.getGlobalInstance(); |
| |
| Component focusOwner = IdeFocusManager.findInstance().getFocusOwner(); |
| // Let's ask for a focused component first |
| if (focusOwner != null) { |
| _window = SwingUtilities.getWindowAncestor(focusOwner); |
| } |
| |
| if (_window == null) { |
| // Looks like ide lost focus, let's ask about the last focused component |
| focusOwner = ideFocusManager.getLastFocusedFor(ideFocusManager.getLastFocusedFrame()); |
| if (focusOwner != null) { |
| _window = SwingUtilities.getWindowAncestor(focusOwner); |
| } |
| } |
| |
| if (_window == null) { |
| _window = WindowManager.getInstance().findVisibleFrame(); |
| } |
| |
| if (_window == null && window != null) { |
| // It might be we just has not opened a frame yet. |
| // So let's ask AWT |
| focusOwner = window.getMostRecentFocusOwner(); |
| if (focusOwner != null) { |
| _window = SwingUtilities.getWindowAncestor(focusOwner); |
| } |
| } |
| |
| if (_window != null) { |
| // We have successfully found the window |
| // Let's check that we have not missed a blocker |
| if (ModalityHelper.isModalBlocked(_window)) { |
| _window = ModalityHelper.getModalBlockerFor(_window); |
| } |
| } |
| |
| if (SystemInfo.isAppleJvm && MacUtil.getWindowTitle(_window) == null) { |
| // With Apple JDK we cannot find a window if it does not have a title |
| // Let's show a dialog instead of the message. |
| throw new MacMessageException("MacMessage parent does not have a title."); |
| } |
| while (_window != null && MacUtil.getWindowTitle(_window) == null) { |
| _window = _window.getOwner(); |
| //At least our frame should have a title |
| } |
| |
| while (Registry.is("skip.untitled.windows.for.mac.messages") && _window != null && _window instanceof JDialog && !((JDialog)_window).isModal()) { |
| _window = _window.getOwner(); |
| } |
| |
| return _window; |
| } |
| |
| /** |
| * Document root is intended to queue messages per a document root |
| */ |
| private static Window getDocumentRootFromWindow(Window window) { |
| return findDocumentRoot(window); |
| } |
| |
| @Messages.YesNoCancelResult |
| private static int showAlertDialog(@NotNull String title, |
| @NotNull String okText, |
| @Nullable String alternateText, |
| @Nullable String cancelText, |
| String message, |
| @Nullable Window window) { |
| return showAlertDialog(title, okText, alternateText, cancelText, message, window, false, null); |
| } |
| } |
