Java Code Examples for java.awt.Window#isShowing()

private void printOpenModalDialogs() {
	boolean hasModal = false;
	Set<Window> windows = AbstractGenericTest.getAllWindows();
	for (Window window : windows) {
		if (window instanceof Dialog) {
			if (((Dialog) window).isModal() && window.isShowing()) {
				hasModal = true;
				break;
			}
		}
	}

	if (!hasModal) {
		return;
	}

	String windowInfo = AbstractDockingTest.getOpenWindowsAsString();
	if (!windowInfo.isEmpty()) {
		Msg.error(TestEnv.class, "Open modal dialogs - all windows: " + windowInfo);
	}

}
 

/**
 * Closes all child windows
 */
private void killAllChildren() {
    Iterator<Window> it = childFrames.iterator();

    while (it.hasNext()) {
        Window curFrame = it.next();

        if (curFrame != null
                && curFrame.isShowing()) {
            curFrame.setVisible(false);
            curFrame.dispose();
        }
    }

    childFrames.clear();
}
 

public static void closeAllWindows(boolean showError) {
	boolean firstClose = true;
	for (Window window : getAllWindows()) {

		if (!window.isShowing()) {
			continue;
		}

		if (showError) {

			if (firstClose) { // only print once
				firstClose = false;
				printOpenWindows();
			}

			// note: we use System.err here to get more obvious errors in the console
			String title = getDebugTitleForWindow(window);
			System.err.println("DockingTestCase - Forced window closure: " + title);
			String errorMessage = checkMessageDisplay(window);
			if (errorMessage != null) {
				System.err.println("\tWindow error message: " + errorMessage);
			}
		}

		Window w = window;
		runSwing(() -> w.dispose());
	}
}
 

/**
 * Gets the dialog component provider <b>that is inside the given window</b> or null if a
 * provider of the given class type is not in the window.
 *
 * @param window the window that contains the desired provider.
 * @param ghidraClass the class of the desired provider
 * @return the desired provider or null if the window does not contain a provider of the given type.
 */
protected static <T extends DialogComponentProvider> T getDialogComponentProvider(Window window,
		Class<T> ghidraClass) {

	if (!(window instanceof DockingDialog)) {
		return null;
	}

	if (!window.isVisible()) {
		return null;
	}

	if (!window.isShowing()) {
		return null;
	}

	DialogComponentProvider provider = ((DockingDialog) window).getDialogComponent();
	if (provider == null || !provider.isVisible()) {
		// provider can be null if the DockingDialog is disposed before we can get the provider
		return null;
	}

	if (!ghidraClass.isAssignableFrom(provider.getClass())) {
		return null;
	}

	return ghidraClass.cast(provider);
}
 

private static boolean isHierarchyShowing(Window w) {

		if (w.isShowing()) {
			return true;
		}

		Window[] children = w.getOwnedWindows();
		for (Window child : children) {
			if (child.isShowing()) {
				return true;
			}
		}

		return false;
	}
 

private static void windowToString(Window w, int depth, StringBuilder buffy) {

		String title = getDebugTitleForWindow(w);
		String prefix = StringUtils.repeat('\t', depth);
		String visibility = w.isShowing() ? "" : " (not showing)";
		String padded = prefix + title + visibility;
		buffy.append(padded).append('\n');

		Window[] children = w.getOwnedWindows();
		for (Window child : children) {
			windowToString(child, depth + 1, buffy);
		}
	}
 

private static void waitEQ(final Window w) throws Exception {
    class R implements Runnable {
        boolean visible;
        
        public void run() {
            visible = w.isShowing();
        }
    }
    R r = new R();
    while (!r.visible) {
        SwingUtilities.invokeAndWait(r);
    }
}
 

/**
 * @return Focused and showing Window or null.
 */
private Window findFocusedWindow() {
    Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusedWindow();
    while( null != w && !w.isShowing() ) {
        w = w.getOwner();
    }
    return w;
}
 

public static SettingsEditor find(GURPSCharacter character) {
    for (Window window : Window.getWindows()) {
        if (window.isShowing() && window instanceof SettingsEditor) {
            SettingsEditor wnd = (SettingsEditor) window;
            if (wnd.mCharacter == character) {
                return wnd;
            }
        }
    }
    return null;
}
 

/**
 * @param window The window to check.
 * @return {@code true} if an owned window is showing.
 */
public static boolean hasOwnedWindowsShowing(Window window) {
    if (window != null) {
        for (Window one : window.getOwnedWindows()) {
            if (one.isShowing() && one.getType() != Window.Type.POPUP) {
                return true;
            }
        }
    }
    return false;
}
 

/**
 * @param window The {@link Window} to close.
 * @return Whether the window was closed or not.
 */
public static boolean close(Window window) {
    if (window == null) {
        return true;
    }
    window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
    return !window.isShowing();
}
 

void grab(boolean setATime, Window w) {
     bounds  = w.getBounds();
     showing = w.isShowing();
     if(w instanceof Frame)
icon  = ((Frame)w).getState() == Frame.ICONIFIED;
     if(setATime)
activationTime = System.currentTimeMillis();
   }
 

public void show() {
  // ((Window) getComponent()).show();
  if(startingup) {
    shouldShow = true;
    if(waitForReset) {
      return;
    }
  }
  Window w = (Window) getComponent();
  if(w.isShowing()) {
    // empty  // System.out.println("Window "+this+" is showing "+w.isShowing());
  } else {
    w.setVisible(true);
  }
}
 

public void hide() {
  // ((Window) getComponent()).show();
  if(startingup) {
    shouldShow = false;
    if(waitForReset) {
      return;
    }
  }
  Window w = (Window) getComponent();
  if(w.isShowing()) {
    w.setVisible(false);
  }
}