java类java.awt.EventQueue的实例源码

public static void main(String[] args) throws Exception, InterruptedException {
    EventQueue.invokeLater(new Runnable()
    {
        public void run()
        {
            try
            {
                JavavcCameraTest gabber = new JavavcCameraTest(0);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    });

}

private void updateToolbar(final FileObject file) {
    RP.post(new Runnable() {

        @Override
        public void run() {
            //getActiveProviders() must not be called in EDT as it might do some I/Os
            final Collection<CssStylesPanelProvider> activeProviders = getActiveProviders(file);
            EventQueue.invokeLater(new Runnable() {

                @Override
                public void run() {
                    updateToolbar(file, activeProviders);
                }

            });
        }

    });
}

private void initializePatches () {
    panel.cmbPatches.setModel(new DefaultComboBoxModel(new String[] { LOADING_PATCHES }));
    validate();
    Utils.postParallel(new Runnable() {
        @Override
        public void run () {
            final List<Patch> patches = PatchStorage.getInstance().getPatches();
            EventQueue.invokeLater(new Runnable() {
                @Override
                public void run () {
                    panel.cmbPatches.setModel(new DefaultComboBoxModel(patches.toArray(new Patch[patches.size()])));
                    if (!patches.isEmpty()) {
                        panel.cmbPatches.setSelectedIndex(0);
                    }
                }
            });
        }
    }, 0);
}

public final void waitFinished() {
    ActionStateUpdater u = actionStateUpdater;
    synchronized (this) {
        u = actionStateUpdater;
    }
    if (u == null) {
        return;
    }
    u.waitFinished();
    if (EventQueue.isDispatchThread()) {
        u.run();
    } else {
        try {
            EventQueue.invokeAndWait(u);
        } catch (Exception ex) {
            Exceptions.printStackTrace(ex);
        }
    }
}

@Override
public void actionPerformed (ActionEvent event) {
    final File f = new FileChooserBuilder(OpenRepositoryAction.class).setDirectoriesOnly(true)
            .setApproveText(Bundle.CTL_OpenRepository_okButton())
            .setAccessibleDescription(Bundle.CTL_OpenRepository_ACSD())
            .showOpenDialog();
    if (f == null) {
        return;
    }
    Utils.postParallel(new Runnable () {
        @Override
        public void run() {
            final File repository = Git.getInstance().getRepositoryRoot(f);
            if (repository != null) {
                GitRepositories.getInstance().add(repository, true);
                EventQueue.invokeLater(new Runnable() {

                    @Override
                    public void run () {
                        GitRepositoryTopComponent rtc = GitRepositoryTopComponent.findInstance();
                        rtc.open();
                        rtc.requestActive();
                        rtc.selectRepository(repository);
                    }
                });
            }
        }
    }, 0);
}

@Override
protected void createPasteTypes(Transferable t, List<PasteType> s) {
    assertFalse("Don't block AWT", EventQueue.isDispatchThread());
    if (pasteTypes != null) {
        s.addAll(pasteTypes);
    }
}

/**
 * Launch the application.
 */
public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                Interface window = new Interface();
                window.frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

public static void main(String[] args) throws Exception {

        createTestUI();

        monitor = new ProgressMonitor(frame, "Progress", null, 0, 100);

        robotThread = new TestThread();
        robotThread.start();

        for (counter = 0; counter <= 100; counter += 10) {
            Thread.sleep(1000);

            EventQueue.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    if (!monitor.isCanceled()) {
                        monitor.setProgress(counter);
                        System.out.println("Progress bar is in progress");
                    }
                }
            });

            if (monitor.isCanceled()) {
                break;
            }
        }

        disposeTestUI();

        if (counter >= monitor.getMaximum()) {
            throw new RuntimeException("Escape key did not cancel the ProgressMonitor");
        }
    }

synchronized void append(String val) {
  values.add(val);
  if (queue) {
    queue = false;
    EventQueue.invokeLater(this);
  }
}

private void configurationsListChanged(@NullAllowed Collection<? extends ProjectConfiguration> configs) {
    LOGGER.log(Level.FINER, "configurationsListChanged: {0}", configs);
    ProjectConfigurationProvider<?> _pcp;
    synchronized (this) {
        _pcp = pcp;
    }
    if (configs == null) {
        EventQueue.invokeLater(new Runnable() {
            public @Override void run() {
                configListCombo.setModel(EMPTY_MODEL);
                configListCombo.setEnabled(false); // possibly redundant, but just in case
            }
        });
    } else {
        final DefaultComboBoxModel model = new DefaultComboBoxModel(configs.toArray());
        if (_pcp != null && _pcp.hasCustomizer()) {
            model.addElement(CUSTOMIZE_ENTRY);
        }
        EventQueue.invokeLater(new Runnable() {
            public @Override void run() {
                configListCombo.setModel(model);
                configListCombo.setEnabled(true);
            }
        });
    }
    if (_pcp != null) {
        activeConfigurationChanged(getActiveConfiguration(_pcp));
    }
}