/** * Finds out the monitor where the user currently has the input focus. * This method is usually used to help the client code to figure out on * which monitor it should place newly created windows/frames/dialogs. * * @return the GraphicsConfiguration of the monitor which currently has the * input focus */ private static GraphicsConfiguration getCurrentGraphicsConfiguration() { Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if (focusOwner != null) { Window w = SwingUtilities.getWindowAncestor(focusOwner); if (w != null) { return w.getGraphicsConfiguration(); } else { //#217737 - try to find the main window which could be placed in secondary screen for( Frame f : Frame.getFrames() ) { if( "NbMainWindow".equals(f.getName())) { //NOI18N return f.getGraphicsConfiguration(); } } } } return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); }
public Component getComponent() { if (component == null) { Window activeWindow = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); if (activeWindow != null) { return activeWindow.getFocusOwner(); } Window[] windows = Window.getWindows(); if (windows.length > 0) { if (windows[0].getFocusOwner() != null) { return windows[0].getFocusOwner(); } return windows[0]; } } return component; }
public void executeCommand() { PrivateChatter chat = mgr.getChatterFor(p); if (chat == null) { return; } Window f = SwingUtilities.getWindowAncestor(chat); if (!f.isVisible()) { f.setVisible(true); Component c = KeyboardFocusManager.getCurrentKeyboardFocusManager() .getFocusOwner(); if (c == null || !SwingUtilities.isDescendingFrom(c, f)) { java.awt.Toolkit.getDefaultToolkit().beep(); for (int i = 0,j = chat.getComponentCount(); i < j; ++i) { if (chat.getComponent(i) instanceof JTextField) { (chat.getComponent(i)).requestFocus(); break; } } } } else { f.toFront(); } chat.show(msg); }
private static void maybeInitializeFocusPolicy(JComponent comp) { // Check for JRootPane which indicates that a swing toplevel // is coming, in which case a swing default focus policy // should be instatiated. See 7125044. if (comp instanceof JRootPane) { synchronized (classLock) { if (!getLAFState().focusPolicyInitialized) { getLAFState().focusPolicyInitialized = true; if (FocusManager.isFocusManagerEnabled()) { KeyboardFocusManager.getCurrentKeyboardFocusManager(). setDefaultFocusTraversalPolicy( new LayoutFocusTraversalPolicy()); } } } } }
/** * Instantiates a new key board. */ public KeyBoard() { this.keySpecificTypedConsumer = new CopyOnWriteArrayList<>(); this.keySpecificPressedConsumer = new CopyOnWriteArrayList<>(); this.keySpecificReleasedConsumer = new CopyOnWriteArrayList<>(); this.keyPressedConsumer = new CopyOnWriteArrayList<>(); this.keyReleasedConsumer = new CopyOnWriteArrayList<>(); this.keyTypedConsumer = new CopyOnWriteArrayList<>(); this.pressedKeys = new CopyOnWriteArrayList<>(); this.releasedKeys = new CopyOnWriteArrayList<>(); this.typedKeys = new CopyOnWriteArrayList<>(); this.keyObservers = new CopyOnWriteArrayList<>(); KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(this); Input.InputLoop.attach(this); }
private void detach() { KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(this); if (tree != null) { tree.getSelectionModel().removeTreeSelectionListener(this); tree.getModel().removeTreeModelListener(this); tree.removeHierarchyBoundsListener(this); tree.removeHierarchyListener(this); tree.removeComponentListener(this); } else { list.getSelectionModel().removeListSelectionListener(this); list.getModel().removeListDataListener(this); list.removeHierarchyBoundsListener(this); list.removeHierarchyListener(this); list.removeComponentListener(this); } pane.getHorizontalScrollBar().getModel().removeChangeListener(this); pane.getVerticalScrollBar().getModel().removeChangeListener(this); detached = true; }
/** Overridden to hide the selection when not focused, and paint across the * selected row if focused. */ public Component prepareRenderer(TableCellRenderer renderer, int row, int col) { Object value = getValueAt(row, col); Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); boolean isSelected = isSelected(row, focusOwner); Component result = renderer.getTableCellRendererComponent(this, value, isSelected, false, row, col); if( PropUtils.isNimbus ) { //HACK to get rid of alternate row background colors if( !isSelected ) { Color bkColor = getBackground(); if( null != bkColor ) result.setBackground( new Color( bkColor.getRGB() ) ); } } return result; }
public void testRadioButtonThreshold() throws Exception { if (!canRun) return; System.err.println("running"); clickOn(basicRen); tagsRen2.setRadioButtonMax(2); clickOn(tagsRen2); Component c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); assertTrue("after setting radio max below threshold, click on the renderer should focus a combo box, not " + c, c instanceof JComboBox); clickOn(basicRen); tagsRen2.setRadioButtonMax(10); sleep(); clickOn(tagsRen2, 80, 25); tagsRen2.requestFocus(); sleep(); c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); assertTrue("after setting radio button max > threshold, focus owner should be a radio button, not " + c, c instanceof JRadioButton); }
public void testEditableCombo() throws Exception{ if (!canRun) return; edRen.setUpdatePolicy(edRen.UPDATE_ON_CONFIRMATION); clickOn(edRen); requestFocus(edRen); sleep(); sleep(); JComponent c = (JComponent)KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); Object o = edRen.getProperty().getValue(); String nuVal = "FOO"; typeKey(c, KeyEvent.VK_F); typeKey(c, KeyEvent.VK_O); typeKey(c, KeyEvent.VK_O); assertEquals("After typing into editable combo, value should match the typed value", nuVal, edRen.getEnteredValue()); assertNotSame("After typing into editable combo with policy UPDATE_ON_CONFIRMATION, the property should not have the value typed", nuVal, edRen.getProperty().getValue()); pressKey(c, KeyEvent.VK_ENTER); assertEquals("After pressing enter on an editable combo, value should be updated", nuVal, edRen.getProperty().getValue()); }
@Override public void actionPerformed(ActionEvent e) { int selIndexBefore = getSelectedIndex(); defaultAction.actionPerformed( e ); int selIndexCurrent = getSelectedIndex(); if( selIndexBefore != selIndexCurrent ) return; if( focusNext && 0 == selIndexCurrent && getModel().getSize() > 1 && getModel().getSize() > getColumnCount() ) return; KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager(); Container container = kfm.getCurrentFocusCycleRoot(); FocusTraversalPolicy policy = container.getFocusTraversalPolicy(); if( null == policy ) policy = kfm.getDefaultFocusTraversalPolicy(); Component next = focusNext ? policy.getComponentAfter( container, CategoryList.this ) : policy.getComponentBefore( container, CategoryList.this ); if( null != next && next instanceof CategoryButton ) { clearSelection(); next.requestFocus(); } }
private static GraphicsConfiguration getCurrentGraphicsConfiguration() { Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if (focusOwner != null) { Window w = SwingUtilities.getWindowAncestor(focusOwner); if (w != null) { return w.getGraphicsConfiguration(); } } return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration(); }
public void disabled_testReadOnlyMode() throws Exception { requestFocus (focusButton); changeProperty (stringPanel, stringProp); setPreferences(stringPanel, PropertyPanel.PREF_READ_ONLY | PropertyPanel.PREF_INPUT_STATE); Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); requestFocus(stringPanel); Component owner2 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); assertSame("Requesting focus on a read only inline editor panel should not change the focus owner, but it was " + owner2, owner, owner2); requestFocus(stringPanel); setPreferences(filePanel, PropertyPanel.PREF_READ_ONLY | PropertyPanel.PREF_CUSTOM_EDITOR); jf.repaint(); Component owner3 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); assertSame("Requesting focus on a read only custom editor panel should not change the focus owner, not " + owner3, owner, owner3); }
@Override public void mousePressed(MouseEvent e) { Point p = e.getPoint(); int i = getLayoutModel().indexOfPoint(p.x, p.y); tabState.setPressed(i); SingleSelectionModel sel = getSelectionModel(); selectionChanged = i != sel.getSelectedIndex(); // invoke possible selection change if ((i != -1) || !selectionChanged) { boolean change = shouldPerformAction(TabDisplayer.COMMAND_SELECT, i, e); if (change) { getSelectionModel().setSelectedIndex(i); tabState.setSelected(i); Component tc = i >= 0 ? getDataModel().getTab(i).getComponent() : null; if( null != tc && tc instanceof TopComponent && !((TopComponent)tc).isAncestorOf( KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner() ) ) { ((TopComponent)tc).requestActive(); } } } if (e.isPopupTrigger()) { //Post a popup menu show request shouldPerformAction(TabDisplayer.COMMAND_POPUP_REQUEST, i, e); } }
private static boolean isWaitCursor() { Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if (focus != null) { if (focus.getCursor().getType() == Cursor.WAIT_CURSOR) { LOG.finer("wait cursor on focus owner"); // NOI18N return true; } Window w = SwingUtilities.windowForComponent(focus); if (w != null && isWaitCursorOnWindow(w)) { LOG.finer("wait cursor on window"); // NOI18N return true; } } for (Frame f : Frame.getFrames()) { if (isWaitCursorOnWindow(f)) { LOG.finer("wait cursor on frame"); // NOI18N return true; } } LOG.finest("no wait cursor"); // NOI18N return false; }
/** * @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 void testDlgIsShown() throws Exception { final R r = new R(); r.l = new CountDownLatch(1); final boolean[] shown = new boolean[] { false }; KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); if (w != null) { r.l.countDown(); shown[0] = true; } } }); SwingUtilities.invokeAndWait(new Runnable() { public void run() { ProgressUtils.runOffEventDispatchThread(r, "Test", new AtomicBoolean(false), true, 10, 100); } }); if (!shown[0]) { fail("Dialog was not shown"); } }
private CutCopyPasteDeleteAction(String i18nKey, String action) { super(i18nKey); putValue(ACTION_COMMAND_KEY, action); KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager(); manager.addPropertyChangeListener("permanentFocusOwner", new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { Object o = evt.getNewValue(); if (o instanceof JComponent) { focusOwner = (JComponent) o; } else { focusOwner = null; } } }); }
public void actionPerformed (ActionEvent ae) { javax.print.attribute.PrintRequestAttributeSet prSet = new javax.print.attribute.HashPrintRequestAttributeSet(); java.awt.print.PrinterJob.getPrinterJob().pageDialog(prSet); Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); int dialogButton = JOptionPane.showConfirmDialog (w, "Did the pageDialog shown in non-default monitor?", null, JOptionPane.YES_NO_OPTION); if(dialogButton == JOptionPane.NO_OPTION) { fail("PageDialog is shown in wrong monitor"); } else { java.awt.print.PrinterJob.getPrinterJob().printDialog(prSet); dialogButton = JOptionPane.showConfirmDialog (w, "Did the printDialog shown in non-default monitor?", null, JOptionPane.YES_NO_OPTION); if(dialogButton == JOptionPane.NO_OPTION) { fail("PrintDialog is shown in wrong monitor"); } else { pass(); } } }
/** * Checks if the focus is still on this component or its child components. */ private boolean isFocusInside(Object newFocusedComp) { if (newFocusedComp instanceof Popup) { return true; } if (newFocusedComp instanceof Component && !SwingUtilities.isDescendingFrom((Component) newFocusedComp, this)) { // Check if focus is on other window if (containingWindow == null) { return false; } Window focusedWindow = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); // if focus is on other window return true if (containingWindow == focusedWindow) { return false; } } return true; }
private Point calculatePosition(Component source) { int xSource = source.getLocationOnScreen().x; int ySource = source.getLocationOnScreen().y; // get size of popup Dimension popupSize = ((Component) popupComponent).getSize(); if (popupSize.width == 0) { popupSize = ((Component) popupComponent).getPreferredSize(); } int xPopup = 0; int yPopup = 0; // get max x and y window positions Window focusedWindow = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); int maxX = focusedWindow.getLocationOnScreen().x + focusedWindow.getWidth(); int maxY = focusedWindow.getLocationOnScreen().y + focusedWindow.getHeight(); switch (position) { case VERTICAL: // place popup at sources' x position xPopup = xSource; // check if popup is outside active window if (xPopup + popupSize.width > maxX) { // move popup x position to the left // to fit inside the active window xPopup = maxX - popupSize.width - BORDER_OFFSET; } // place popup always below source (to avoid overlapping) yPopup = ySource + source.getHeight(); // if the popup now would be moved outside of RM Studio to the left it would look // silly, so in that case just show it at its intended position and let it be cut // off on the right side as we cannot do anything about it if (xPopup < focusedWindow.getLocationOnScreen().x || (xPopup - focusedWindow.getLocationOnScreen().x) + popupSize.width > focusedWindow.getWidth()) { xPopup = xSource; } break; case HORIZONTAL: // place popup always to the right side of the source (to avoid overlapping) xPopup = xSource + source.getWidth(); yPopup = ySource; // check if popup is outside active window if (yPopup + popupSize.height > maxY) { // move popup upwards to fit into active window yPopup = maxY - popupSize.height - BORDER_OFFSET; } // if the popup now would be moved outside of RM Studio at the top it would look // silly, so in that case just show it at its intended position and let it be cut // off on the bottom side as we cannot do anything about it if (yPopup < focusedWindow.getLocationOnScreen().y || (yPopup - focusedWindow.getLocationOnScreen().y) + popupSize.height > focusedWindow.getHeight()) { yPopup = ySource; } break; } return new Point(xPopup, yPopup); }
private Window findFocusWindow() { Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusedWindow(); if (w != null) return w; w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); if (w != null) return w; Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if (focusOwner != null) w = SwingUtilities.getWindowAncestor(focusOwner); if (w != null) return w; Window[] validWindows = getValidWindows(); if (validWindows.length > 0) return validWindows[validWindows.length - 1]; return null; }
/** * Requests focus on a child of the spinner if the spinner doesn't have * focus. */ private void focusSpinnerIfNecessary() { Component fo = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if( spinner.isRequestFocusEnabled() && (fo == null || !SwingUtilities.isDescendingFrom(fo, spinner)) ) { Container root = spinner; if( !root.isFocusCycleRoot() ) { root = root.getFocusCycleRootAncestor(); } if( root != null ) { FocusTraversalPolicy ftp = root.getFocusTraversalPolicy(); Component child = ftp.getComponentAfter(root, spinner); if( child != null && SwingUtilities.isDescendingFrom(child, spinner) ) { child.requestFocus(); } } } }
void test1(final TestCase t) { Runnable action = new Runnable() { public void run() { KeyboardFocusManager.setCurrentKeyboardFocusManager(new TestKFM()); if (t == TestCase.REMOVAL) { frame.remove(frame.panel0); } else if (t == TestCase.HIDING) { frame.panel0.setVisible(false); } frame.repaint(); } }; if (!Util.trackFocusGained(frame.b3, action, 2000, false)) { throw new TestFailedException(t + ": focus wasn't transfered as expected!"); } KeyboardFocusManager.setCurrentKeyboardFocusManager(kfm); }
/** * Dump some of the queued key events back into the regular event system. */ private void _dumpQueue(int count) { KeyboardFocusManager mgr = KeyboardFocusManager.getCurrentKeyboardFocusManager(); while ((count > 0) && (queue.size() > 0)) { KeyEvent ke = queue.pop(); mgr.redispatchEvent(ke.getComponent(), ke); count--; } }
@Override public void quickSearchCanceled() { // Check whether the cancel was explicit or implicit. // Implicit cancel has undefined focus owner // TODO: After switch to JDK 8, we can e.g. add a static method to Callback providing the info. Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); if (focusOwner != null) { displaySearchResult(quickSearchInitialRow, quickSearchInitialColumn); } quickSearchInitialRow = -1; quickSearchInitialColumn = -1; quickSearchLastPos = null; }
public void testFocusReturn() throws Exception { if (!focusWorks) { return; } clickOn(tb, 1, 1); requestFocus(tb); typeKey(tb, KeyEvent.VK_B); typeKey(tb, KeyEvent.VK_E); typeKey(tb, KeyEvent.VK_SPACE); typeKey(tb, KeyEvent.VK_N); typeKey(tb, KeyEvent.VK_I); typeKey(tb, KeyEvent.VK_C); typeKey(tb, KeyEvent.VK_E); sleep(); SLEEP_LENGTH=1000; Component c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); sleep(); pressKey(c, KeyEvent.VK_ENTER); typeKey(c, KeyEvent.VK_ENTER); sleep(); sleep(); sleep(); sleep(); c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); assertNotNull(c); Container top = ((JComponent) c).getTopLevelAncestor(); assertTrue("Focus should no longer be on the property sheet after an erroneous value was entered", top != jf); assertTrue("An error dialog should be showing after an exception was thrown in setAsText() but focus owner is " + c, jf != top); JRootPane jrp = ((JComponent) c).getRootPane(); jrp.getDefaultButton().doClick(); sleep(); c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); assertTrue("After the error dialog is closed following a bad property edit, the table should return to edit mode on the previously edited property", c instanceof InplaceEditor); }
public void testPostSetAction() throws Exception { if (!canSafelyRunFocusTests()) { System.err.println("Cannot run post set " + "action test - testing machine's focus behavior is not sane"); return; } pressCell(tb, 1, 1); sleep(); requestFocus(tb); System.err.println("WILL TYPE MIAOU"); JComponent focusOwner = (JComponent)KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); assertTrue("Focus should be on a JTextField, not " + focusOwner, focusOwner instanceof JTextField); typeString("MIAOU", focusOwner); sleep(); sleep(); System.err.println("MIAOU TYPED"); postSetAction.assertNotPerformed(); System.err.println("ACTION NOT PERFORMED AS IT SHOULD BE"); pressKey(tb, KeyEvent.VK_ENTER); System.err.println("SENDING ENTER TO " + tb); Thread.currentThread().sleep(1000); sleep(); System.err.println("TYPING ENTER TO " + tb); typeKey(tb, KeyEvent.VK_ENTER); sleep(); sleep(); System.err.println("POST SET ACTION PERFORMED: " + postSetAction.performed); postSetAction.assertPerformed(); click(tb, 1, 0); }
private static void runTest8() throws Exception { hitKey(robot, KeyEvent.VK_TAB); SwingUtilities.invokeAndWait(new Runnable() { @Override public void run() { if (KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() != radioBtnSingle) { System.out.println("Separate Component added in button group layout"); throw new RuntimeException("Focus is not on Radio Button Single as Expected"); } } }); }
private static void runTest3() throws Exception { hitKey(robot, KeyEvent.VK_SHIFT, KeyEvent.VK_TAB); hitKey(robot, KeyEvent.VK_SHIFT, KeyEvent.VK_TAB); hitKey(robot, KeyEvent.VK_SHIFT, KeyEvent.VK_TAB); SwingUtilities.invokeAndWait(new Runnable() { @Override public void run() { if (KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() != radioBtn1) { System.out.println("Radio button Group/Non Grouped Radio Button SHIFT-Tab Key Test failed"); throw new RuntimeException("Focus is not on Radio Button A as Expected"); } } }); }
public static boolean waitForDialog() { Container c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); int ct = 0; while (!(c instanceof Dialog)) { try { Thread.currentThread().sleep(50); } catch (Exception e) {} c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); ct++; if (ct > 100) { return false; } } return true; }
public static boolean waitForFrame() { Container c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); int ct = 0; while (!(c instanceof JFrame)) { try { Thread.currentThread().sleep(50); } catch (Exception e) {} c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow(); ct++; if (ct > 100) { return false; } } return true; }
public static Component waitForComponentOrChildToGetFocus(Container c) { Component foc = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); int ct=0; while (foc == null || (foc != c && !c.isAncestorOf(foc))) { try { Thread.currentThread().sleep(100); } catch (Exception e ) {} foc = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); ct++; if (ct > 200) { break; } } return foc; }
public void testCustomEditorTitle() throws Exception { if (!canRun) return; requestFocus(custRen); Runnable run = new Runnable() { public void run() { try { doCtrlPressKey(stringRen, KeyEvent.VK_SPACE); } catch (Exception e) {} } }; new Thread(run).start(); Thread.currentThread().sleep(1000); sleep(); Component owner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); assertTrue("Control press should invoke custom editor", ((JComponent) owner).getTopLevelAncestor() != stringRen.getTopLevelAncestor()); Container c = ((JComponent) owner).getTopLevelAncestor(); System.err.println("CLASS: " + c.getClass()); if (c instanceof JDialog) { assertEquals("Custom editor supplying a title via client properties should be shown in a dialog with that title", ((JDialog) c).getTitle(), "Don't panic"); } }
@Override public void addNotify () { super.addNotify(); getExplorerManager().setRootContext(root); getExplorerManager().addPropertyChangeListener(this); if (toolbar.isVisible()) { attachToolbarListeners(); } revisionsPanel1.lstRevisions.addListSelectionListener(this); revisionsPanel1.lstRevisions.addMouseListener(this); if (options.contains(Option.DISPLAY_REVISIONS)) { KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(this); revisionsPanel1.updateHistory(currRepository, roots, currRevision); EventQueue.invokeLater(new Runnable() { @Override public void run() { int width = revisionsPanel1.getPreferredSize().width; int leftPanelWidth = jSplitPane1.getPreferredSize().width - width; jSplitPane1.setDividerLocation(Math.min(200, leftPanelWidth)); if (sliderPos > 0) { EventQueue.invokeLater(new Runnable() { @Override public void run () { jSplitPane1.setDividerLocation(sliderPos); } }); } } }); } if (options.contains(Option.EXPAND_BRANCHES) || options.contains(Option.EXPAND_TAGS)) { tree.expandNode(root); } }
@Override public void removeNotify() { if (options.contains(Option.DISPLAY_REVISIONS)) { KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(this); } revisionsPanel1.lstRevisions.removeListSelectionListener(this); getExplorerManager().removePropertyChangeListener(this); if (toolbar.isVisible()) { detachToolbarListeners(); } super.removeNotify(); }
@Override public void actionPerformed(ActionEvent e) { if (isEditing() || editorComp != null) { removeEditor(); return; } else { Component c = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); InputMap imp = getRootPane().getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); ActionMap am = getRootPane().getActionMap(); KeyStroke escape = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0, false); Object key = imp.get(escape); if (key == null) { //Default for NbDialog key = "Cancel"; } if (key != null) { Action a = am.get(key); if (a != null) { String commandKey = (String)a.getValue(Action.ACTION_COMMAND_KEY); if (commandKey == null) { commandKey = key.toString(); } a.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, commandKey)); //NOI18N } } } }
@RandomlyFails // NB-Core-Build #8093 public void testNodesReleasing () { SwingUtilities.invokeLater(new Runnable() { public void run() { fillAndShowTTV(); // wait for a while to be sure that TTV was completely painted // and references between property panels -> properties -> nodes // established Timer timer = new Timer(5000, new ActionListener () { public void actionPerformed (ActionEvent evt) { TTVTest.this.cleanAndCheckTTV(); } }); timer.setRepeats(false); timer.start(); } }); // wait for results synchronized (this) { try { wait(); KeyboardFocusManager.getCurrentKeyboardFocusManager ().clearGlobalFocusOwner (); for (WeakReference<Node> weakNode : weakNodes) { assertGC ("Check Node weakNode", weakNode); } } catch (InterruptedException exc) { fail("Test was interrupted somehow."); } } // result needn't be synced, was set before we were notified if (result > 0) { System.out.println("OK, TreeTableView released nodes after " + result + " GC cycles"); } else { System.out.println("TreeTableView leaks memory! Nodes were not freed even after 10 GC cycles."); fail("TreeTableView leaks memory! Nodes were not freed even after 10 GC cycles."); } }
void removeItems() { if (lastFocused != null) { if(!lastFocused.requestFocusInWindow()) { // Workarounr for 4810575. // If lastFocused is not in currently focused window // requestFocusInWindow will fail. In this case we must // request focus by requestFocus() if it was not // transferred from our popup. Window cfw = KeyboardFocusManager .getCurrentKeyboardFocusManager() .getFocusedWindow(); if(cfw != null && "###focusableSwingPopup###".equals(cfw.getName())) { lastFocused.requestFocus(); } } lastFocused = null; } if (invokerRootPane != null) { invokerRootPane.removeKeyListener(this); invokerRootPane.setFocusTraversalKeysEnabled(focusTraversalKeysEnabled); removeUIInputMap(invokerRootPane, menuInputMap); removeUIActionMap(invokerRootPane, menuActionMap); invokerRootPane = null; } receivedKeyPressed = false; }
public void disabled_testTableUIBehavior () throws Exception { requestFocus (tagsPanel); System.err.println("TAGS PANEL BOUNDS: " + tagsPanel.getBounds()); Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); assertTrue ("After requesting focus on a property with tags, a combo box should have focus, not " + focusOwner, focusOwner instanceof JComboBox); assertTrue("After requesting focus on a property with tags, with TableUI false, the combo's popup should not be open", !((JComboBox) focusOwner).isPopupVisible()); requestFocus(focusButton); tagsPanel.setPreferences(PropertyPanel.PREF_TABLEUI); requestFocus(tagsPanel); focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner(); assertTrue ("After requesting focus on a property with tags, a combo box should have focus, not " + focusOwner, focusOwner instanceof JComboBox); assertTrue("After requesting focus on a property with tags, with TableUI true, the combo's popup should be open", ((JComboBox) focusOwner).isPopupVisible()); sleep(); requestFocus(focusButton); /* //Commenting this out for now - too heavily depends to on the look and //feel's behavior assertTrue("After shifting focus away from a tableUI combo box, its popup should no longer be open", !((JComboBox) focusOwner).isPopupVisible()); */ }