@Override public void setPressed(boolean b) { if ((isPressed() == b) || !isEnabled()) { return; } if (!b && isArmed()) { updateState(); } if (b) { stateMask |= PRESSED; } else { stateMask &= ~PRESSED; } fireStateChanged(); if (!isPressed() && isArmed()) { int modifiers = 0; AWTEvent currentEvent = EventQueue.getCurrentEvent(); if (currentEvent instanceof InputEvent) { modifiers = ((InputEvent) currentEvent).getModifiers(); } else if (currentEvent instanceof ActionEvent) { modifiers = ((ActionEvent) currentEvent).getModifiers(); } fireActionPerformed( new ActionEvent( this, ActionEvent.ACTION_PERFORMED, getActionCommand(), EventQueue.getMostRecentEventTime(), modifiers)); } }
/** Repaints immediately the component. */ public void immediateRepaint() { if (EventQueue.isDispatchThread()) { Rectangle visRect = getRenderRect(); if (doubleBufferedRendering) repaint( visRect.x, visRect.y, visRect.width, visRect.height); else paintImmediately( visRect.x, visRect.y, visRect.width, visRect.height); } else { try { EventQueue.invokeAndWait( new Runnable() { public void run() { Rectangle visRect = getRenderRect(); if (doubleBufferedRendering) repaint( visRect.x, visRect.y, visRect.width, visRect.height); else paintImmediately( visRect.x, visRect.y, visRect.width, visRect.height); } }); } catch (Exception e) { } } }
public void scrollBy(final int x, final int y) { if (EventQueue.isDispatchThread()) { this.scrollByImpl(x, y); } else { EventQueue.invokeLater(() -> scrollByImpl(x, y)); } }
public void navigabilityChanged(final Wizard wizard) { final Runnable runnable = new Runnable() { @Override public void run() { if (wizard.isBusy()) { next.setEnabled(false); prev.setEnabled(false); finish.setEnabled(false); cancel.setEnabled(false); parent.getOuterPanel().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); wasBusy = true; return; } else if (wasBusy) { cancel.setEnabled(true); parent.getOuterPanel().setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)); } configureNavigationButtons(wizard, prev, next, finish); parent.updateProblem(); } }; if (EventQueue.isDispatchThread()) runnable.run(); else EventQueue.invokeLater(runnable); }
/** * Clears the current document if any. If called outside the GUI thread, the operation will be * scheduled to be performed in the GUI thread. */ public void clearDocument() { if (java.awt.EventQueue.isDispatchThread()) { this.clearDocumentImpl(); } else { java.awt.EventQueue.invokeLater(() -> HtmlPanel.this.clearDocumentImpl()); } }
private void AceptarActionPerformed( java.awt.event.ActionEvent evt) { // GEN-FIRST:event_AceptarActionPerformed if (Ver_alumno.isSelected()) { setVisible(false); java.awt.EventQueue.invokeLater( new Runnable() { public void run() { new VerAlumnos().setVisible(true); } }); } else { if (Act_Alumno.isSelected()) { setVisible(false); java.awt.EventQueue.invokeLater( new Runnable() { public void run() { new Actualizar_Alumno().setVisible(true); } }); } else { if (Crear_Alumno.isSelected()) { setVisible(false); java.awt.EventQueue.invokeLater( new Runnable() { public void run() { new Crear_Alumnos().setVisible(true); } }); } } } } // GEN-LAST:event_AceptarActionPerformed
/** * Scrolls to the element identified by the given ID in the current document. * * <p>If this method is invoked outside the GUI thread, the operation is scheduled to be performed * as soon as possible in the GUI thread. * * @param nameOrId The name or ID of the element in the document. */ public void scrollToElement(final String nameOrId) { if (EventQueue.isDispatchThread()) { this.scrollToElementImpl(nameOrId); } else { EventQueue.invokeLater(() -> scrollToElementImpl(nameOrId)); } }
/** * Allows a custom EventQueue implementation to replace this one. All pending events are * transferred to the new queue. Calls to postEvent, getNextEvent, and peekEvent and others are * forwarded to the pushed queue until it is removed with a pop(). * * @exception NullPointerException if newEventQueue is null. */ public synchronized void push(EventQueue newEventQueue) { if (newEventQueue == null) throw new NullPointerException(); /* Make sure we are at the top of the stack because callers can only get a reference to the one at the bottom using Toolkit.getDefaultToolkit().getSystemEventQueue() */ if (next != null) { next.push(newEventQueue); return; } /* Make sure we have a live dispatch thread to drive the queue */ if (dispatchThread == null) dispatchThread = new EventDispatchThread(this); synchronized (newEventQueue) { // The RI transfers the events without calling the new eventqueue's // push(), but using getNextEvent(). while (peekEvent() != null) { try { newEventQueue.postEventImpl(getNextEvent()); } catch (InterruptedException ex) { // What should we do with this? ex.printStackTrace(); } } newEventQueue.prev = this; } next = newEventQueue; }
void appendOutput(final String line) { if (!EventQueue.isDispatchThread()) { EventQueue.invokeLater( new Runnable() { public void run() { appendOutput(line); } }); return; } if (!isShowing()) { // ignore request, dialog is closed return; } // Can now accept user input outputArea.setEditable(true); Document doc = outputArea.getDocument(); if (doc != null) { try { doc.insertString(doc.getLength(), line + "\n", null); // NOI18N } catch (BadLocationException e) { } } }
public void run() { if (!EventQueue.isDispatchThread()) { EventQueue.invokeLater(this); } else { doRun(); } }
public void run() { do { try { Thread.sleep(time); } catch (InterruptedException e) { // Auto-generated catch block throw new RuntimeException(e); } if (run != this.runtime.runNumber) { break; } if (EventQueue.isDispatchThread()) { runner.run(Context.enter()); } else { try { EventQueue.invokeAndWait(runner); } catch (Exception e) { e.printStackTrace(); } } } while (loop); }
public void startModelValidating() { if (!isModelValid() && !validationStarted) { validationStarted = true; EventQueue.invokeLater( () -> { Scripts.LocalContext context = Scripts.getContext(); RP.execute( () -> { Scripts.setContext(context); try { validateModel(); } catch (Exception ex) { Logger.getLogger(PlatypusDataObject.class.getName()) .log(Level.WARNING, ex.getMessage(), ex); } finally { Scripts.setContext(null); EventQueue.invokeLater( () -> { validationStarted = false; setModelValid(true); }); } }); }); } }
public void doTest() throws Exception { try { robot.waitForIdle(delay); for (DialogOwner owner : DialogOwner.values()) { EventQueue.invokeLater( () -> { createGUI(owner); }); robot.waitForIdle(delay); dialog.activated.waitForFlagTriggered(); assertTrue( dialog.activated.flag(), "Dialog did not trigger " + "Window Activated event when it became visible"); dialog.closeGained.waitForFlagTriggered(); assertTrue( dialog.closeGained.flag(), "The 1st button did not " + "gain focus when the dialog became visible"); dialog.checkUnblockedDialog(robot, ""); robot.waitForIdle(delay); } } finally { EventQueue.invokeAndWait(this::closeAll); } }
public synchronized void expand() { if (EventQueue.isDispatchThread()) { EventQueue.invokeLater( new Runnable() { @Override public void run() { _expand(); } }); } else { try { EventQueue.invokeAndWait( new Runnable() { @Override public void run() { _expand(); } }); } catch (InterruptedException | InvocationTargetException e) { System.err.println(e); } } }
/** see: http://www.javakey.net/4-java-gui/686df4a3d194cade.htm */ private synchronized void startModal() { if (this.isVisible() && !this.isShowing()) { Container parent = this.getParent(); while (parent != null) { if (parent.isVisible() == false) { parent.setVisible(true); } parent = parent.getParent(); } } try { if (SwingUtilities.isEventDispatchThread()) { EventQueue theQueue = getToolkit().getSystemEventQueue(); while (this.isVisible()) { AWTEvent event = theQueue.getNextEvent(); Object source = event.getSource(); if (event instanceof ActiveEvent) { ((ActiveEvent) event).dispatch(); } else if (source instanceof Component) { ((Component) source).dispatchEvent(event); } else if (source instanceof MenuComponent) { ((MenuComponent) source).dispatchEvent(event); } else { System.err.println("Unable to dispatch: " + event); } } } else { while (this.isVisible()) { wait(); } } } catch (InterruptedException e) { e.printStackTrace(); } }
private void wakeupEDT() { if (log.isLoggable(PlatformLogger.Level.FINEST)) { log.finest("wakeupEDT(): EDT == " + dispatchThread); } EventQueue eq = dispatchThread.getEventQueue(); eq.postEvent(new PeerEvent(this, wakingRunnable, PeerEvent.PRIORITY_EVENT)); }
@Override public void run() { if (!EventQueue.isDispatchThread()) { ProgressHandle ph; ph = ProgressHandleFactory.createHandle( NbBundle.getMessage(ResultsTopComponent.class, "PreparingResultsWindow.msg")); ph.start(); n = new ResultsNode(query); rtcsc = query.getColumns(); List cols = Arrays.asList(rtcsc); Iterator colsIt = cols.iterator(); alps = new ArrayList(); while (colsIt.hasNext()) { RtcQueryColumn rsc = (RtcQueryColumn) colsIt.next(); alps.add(rsc.getColumnIdentifier()); alps.add(rsc.getColumnDisplayName()); } actualCols = alps.toArray(new String[] {}); EventQueue.invokeLater(this); ph.finish(); } else { outlineView.setPropertyColumns(alps.toArray(new String[] {})); Outline outline = outlineView.getOutline(); removeDefaultColumn(outline); ETableColumnModel etcm = (ETableColumnModel) outline.getColumnModel(); // TODO: szymon : change j to proper sort order int j = 1; for (int i = 1; i < rtcsc.length; i++) { ETableColumn etc = (ETableColumn) etcm.getColumn(i); if (alps.get(i * 2 - 2).equals("id")) { etc.setMaxWidth(20); } if (alps.get(i * 2 - 2).equals("internalSeverity")) { etc.setMaxWidth(20); } if (alps.get(i * 2 - 2).equals("internalPriority")) { etc.setMaxWidth(20); } if (alps.get(i * 2 - 2).equals("workItemType")) { etc.setMaxWidth(20); } if (alps.get(i * 2 - 2).equals("internalState")) { etc.setMaxWidth(85); } if (alps.get(i * 2 - 2).equals("summary")) { etc.setMaxWidth(550); etc.setWidth(475); etc.setMinWidth(400); } if (rtcsc[i].isSortColumn()) { etcm.setColumnSorted(etc, rtcsc[i].isAscending(), j); j++; } } manager.setRootContext(n); } }
/** * Instantiates the given TutorialApplication class, then invokes {@code #startup} with the given * arguments. Typically this method is called from an application's #main method. * * @param appClass the class of the application to launch * @param args optional launch arguments, often the main method's arguments. */ public static synchronized void launch( final Class /*<? extends TutorialApplication>*/ appClass, final String[] args) { Runnable runnable = new Runnable() { public void run() { TutorialApplication application = null; try { application = (TutorialApplication) appClass.newInstance(); } catch (InstantiationException e) { e.printStackTrace(); LOGGER.log(Level.SEVERE, "Can't instantiate " + appClass, e); return; } catch (IllegalAccessException e) { e.printStackTrace(); LOGGER.log(Level.SEVERE, "Illegal Access during launch of " + appClass, e); return; } try { application.initializeLookAndFeel(); application.startup(args); } catch (Exception e) { String message = "Failed to launch " + appClass; // String message = String.format("Failed to launch %s ", appClass); LOGGER.log(Level.SEVERE, message, e); throw new Error(message, e); } } }; if (EventQueue.isDispatchThread()) { runnable.run(); } else { EventQueue.invokeLater(runnable); } }
/** * This arranges for runnable to have its run method called in the dispatch thread of the * EventQueue. This will happen after all pending events are processed. * * @since 1.2 */ public static void invokeLater(Runnable runnable) { EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue(); InvocationEvent ie = new InvocationEvent(eq, runnable, null, false); eq.postEvent(ie); }
@Override public Node.PropertySet[] getPropertySets() { final Node.PropertySet[][] props = new Node.PropertySet[1][]; Runnable runnable = new Runnable() { @Override public void run() { FormLAF.executeWithLAFLocks( new Runnable() { @Override public void run() { props[0] = component.getProperties(); } }); } }; if (EventQueue.isDispatchThread()) { runnable.run(); } else { try { // We have made some attempts to keep initialization // of properties outside AWT thread, but it always // deadlocked with AWT thread for various reasons. EventQueue.invokeAndWait(runnable); } catch (InterruptedException iex) { FormUtils.LOGGER.log(Level.INFO, iex.getMessage(), iex); } catch (InvocationTargetException itex) { FormUtils.LOGGER.log(Level.INFO, itex.getMessage(), itex); } } return props[0]; }
private void createGUI() throws Exception { EventQueue.invokeAndWait(this::showParent); robot.waitForIdle(delay); EventQueue.invokeLater(this::showChild); robot.waitForIdle(delay); }
@Override public ActionCallback show() { LOG.assertTrue( EventQueue.isDispatchThread(), "Access is allowed from event dispatch thread only"); if (myTypeAheadCallback != null) { IdeFocusManager.getInstance(myProject).typeAheadUntil(myTypeAheadCallback); } LOG.assertTrue( EventQueue.isDispatchThread(), "Access is allowed from event dispatch thread only"); final ActionCallback result = new ActionCallback(); final AnCancelAction anCancelAction = new AnCancelAction(); final JRootPane rootPane = getRootPane(); anCancelAction.registerCustomShortcutSet( new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0)), rootPane); myDisposeActions.add( new Runnable() { @Override public void run() { anCancelAction.unregisterCustomShortcutSet(rootPane); } }); if (!myCanBeParent && myWindowManager != null) { myWindowManager.doNotSuggestAsParent(myDialog.getWindow()); } final CommandProcessorEx commandProcessor = ApplicationManager.getApplication() != null ? (CommandProcessorEx) CommandProcessor.getInstance() : null; final boolean appStarted = commandProcessor != null; if (myDialog.isModal() && !isProgressDialog()) { if (appStarted) { commandProcessor.enterModal(); LaterInvocator.enterModal(myDialog); } } if (appStarted) { hidePopupsIfNeeded(); } try { myDialog.show(); } finally { if (myDialog.isModal() && !isProgressDialog()) { if (appStarted) { commandProcessor.leaveModal(); LaterInvocator.leaveModal(myDialog); } } myDialog.getFocusManager().doWhenFocusSettlesDown(result.createSetDoneRunnable()); } return result; }
/** Initializes the core phone objects. */ private void initializePhone() { // Load Preferences loadPreferences(); if (preferences == null) { return; } guiManager = new GuiManager(); guiManager.addUserActionListener(this); logManager = new LogManagerImpl(this); this.getLogManager().setRemoteLogging(true); try { EventQueue.invokeAndWait( new Runnable() { @Override public void run() { registerMenu = new JCheckBoxMenuItem(PhoneRes.getIString("phone.enabled")); } }); } catch (Exception e) { Log.error(e); } registerMenu.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent actionEvent) { if (getStatus() == SipRegisterStatus.Unregistered || getStatus() == SipRegisterStatus.RegistrationFailed) { register(); } else { handleUnregisterRequest(); } } }); SIPConfig.setPreferredNetworkAddress(preferences.getPreferredAddress()); NetworkAddressManager.start(); try { EventQueue.invokeAndWait( new Runnable() { @Override public void run() { // Initialize Missed calls missedCalls = new MissedCalls(); } }); } catch (Exception e) { Log.error(e); } final JMenu actionsMenu = SparkManager.getMainWindow().getMenuByName(Res.getString("menuitem.actions")); actionsMenu.add(registerMenu); }
/** * Sets an HTML DOM node and invalidates the component so it is rendered as soon as possible in * the GUI thread. * * <p>If this method is called from a thread that is not the GUI dispatch thread, the document is * scheduled to be set later. Note that {@link #setPreferredWidth(int) preferred size} * calculations should be done in the GUI dispatch thread for this reason. * * @param node This should normally be a Document instance obtained with {@link * org.lobobrowser.html.parser.DocumentBuilderImpl}. * <p> * @param rcontext A renderer context. * @see org.lobobrowser.html.parser.DocumentBuilderImpl#parse(org.xml.sax.InputSource) * @see org.lobobrowser.html.test.SimpleHtmlRendererContext */ public void setDocument(final Document node, final HtmlRendererContext rcontext) { setCursor(Cursor.getDefaultCursor()); if (java.awt.EventQueue.isDispatchThread()) { this.setDocumentImpl(node, rcontext); } else { java.awt.EventQueue.invokeLater(() -> HtmlPanel.this.setDocumentImpl(node, rcontext)); } }
public void setVisible(boolean visible) { if (java.awt.EventQueue.isDispatchThread()) { // System.err.println("DialogMessageLogger.setVisible(): on EDT"); outputDialog.setVisible(visible); } else { // System.err.println("DialogMessageLogger.setVisible(): on non-EDT"); java.awt.EventQueue.invokeLater(new SetVisibleRunnable(visible)); } }
public void sendLn(String message) { if (java.awt.EventQueue.isDispatchThread()) { // System.err.println("sendLn(): on EDT"); outputTextArea.append(message + "\n"); } else { // System.err.println("sendLn(): on non-EDT"); java.awt.EventQueue.invokeLater(new SendRunnable(message + "\n")); } }
public void handleDocumentRendering( final NavigatorFrame frame, final ClientletResponse response, final ComponentContent content) { if (EventQueue.isDispatchThread()) { this.handleDocumentRenderingImpl(frame, response, content); } else { EventQueue.invokeLater( () -> BrowserPanel.this.handleDocumentRenderingImpl(frame, response, content)); } }
/** * Construct a logger. * * @param titleMessage for the title bar of the dialog box * @param width initial width of the resizeable dialog box * @param height initial height of the resizeable dialog box * @param exitApplicationOnClose if true, when the dialog box is closed (X-d out), will exit the * application with success status * @param visible if true, will be made visible after construction */ public DialogMessageLogger( String titleMessage, int width, int height, boolean exitApplicationOnClose, boolean visible) { if (java.awt.EventQueue.isDispatchThread()) { System.err.println("DialogMessageLogger(): constructing on EDT"); createGUI(titleMessage, width, height, exitApplicationOnClose, visible); } else { System.err.println("DialogMessageLogger(): constructing on non-EDT"); java.awt.EventQueue.invokeLater( new CreateGUIRunnable(titleMessage, width, height, exitApplicationOnClose, visible)); } }
// Post the given event to the corresponding event queue for the given component. void postEvent(@Nullable Component c, @Nonnull AWTEvent event) { // Force an update of the input state, so that we're in synch internally. Otherwise we might // post more events before // this one gets processed and end up using stale values for those events. inputState.update(event); EventQueue eventQueue = eventQueueFor(c); if (eventQueue != null) { eventQueue.postEvent(event); } pause(settings.delayBetweenEvents()); }
/** * Pass an event onto the AWT component. * * @see java.awt.Component#processEvent(java.awt.AWTEvent) */ protected final void processEvent(AWTEvent event) { AppContext ac = SunToolkit.targetToAppContext(target); if (ac == null) { target.dispatchEvent(SwingToolkit.convertEvent(event, target)); } else { EventQueue eq = (EventQueue) ac.get(AppContext.EVENT_QUEUE_KEY); if (eq == null) { target.dispatchEvent(SwingToolkit.convertEvent(event, target)); } else { eq.postEvent(SwingToolkit.convertEvent(event, target)); } } }