static void save(final FileObject fo, final String content) {
   if (fo == null) throw new NullPointerException();
   if (content == null) throw new NullPointerException();
   requestProcessor.post(
       new Runnable() {
         public void run() {
           try {
             FileLock lock = fo.lock();
             try {
               OutputStream os = fo.getOutputStream(lock);
               Writer writer = new OutputStreamWriter(os, "UTF-8"); // NOI18N
               try {
                 writer.write(content);
               } finally {
                 writer.close();
               }
             } finally {
               lock.releaseLock();
             }
           } catch (IOException ex) {
             ErrorManager.getDefault().notify(ex);
           }
         }
       });
 }
    @Override
    public void actionPerformed(ActionEvent e) {
      final GitHubIssuePanel p = getPanel();
      p.setNewCommentEnabled(false);

      GitHubIssues gitHubIssues = GitHubIssues.getInstance();
      RequestProcessor rp = gitHubIssues.getRequestProcessor();
      rp.post(
          new Runnable() {
            @Override
            public void run() {
              try {
                String comment = p.getNewComment();
                if (StringUtils.isEmpty(comment)) {
                  closeReopen();
                } else {
                  Comment newComment = comment(comment);
                  if (newComment != null) {
                    closeReopen();
                  }
                }

                SwingUtilities.invokeLater(
                    new Runnable() {
                      @Override
                      public void run() {
                        p.update();
                      }
                    });
              } finally {
                p.setNewCommentEnabled(true);
              }
            }
          });
    }
  @NbBundle.Messages({"GitHubIssueController.delete.comment.fail=Can't delete this issue."})
  private void deleteComment() {
    final Comment deletedComment = getPanel().getDeletedComment();
    if (deletedComment == null) {
      return;
    }
    RequestProcessor rp = GitHubIssues.getInstance().getRequestProcessor();
    rp.post(
        new Runnable() {

          @Override
          public void run() {
            GitHubRepository repository = getPanel().getIssue().getRepository();
            final boolean success = GitHubIssueSupport.deleteComment(repository, deletedComment);

            SwingUtilities.invokeLater(
                new Runnable() {

                  @Override
                  public void run() {
                    if (success) {
                      // remove comment panel
                      getPanel().removeDeletedComment();
                    } else {
                      // show error message
                      UiUtils.showErrorDialog(Bundle.GitHubIssueController_delete_comment_fail());
                    }
                  }
                });
          }
        });
  }
  public static ClassLoader getReferenceClassLoader() {
    if (referenceClassLoader != null) {
      return referenceClassLoader;
    }

    REFERENCE_RP
        .post(
            new Runnable() {
              @Override
              public void run() {
                if (referenceClassLoader != null) {
                  return;
                }

                try {
                  referenceLibrary = copyCompleteJarToTempDir();
                  referenceClassLoader =
                      new URLClassLoader(
                          new URL[] {Utilities.toURI(referenceLibrary).toURL()},
                          ClassLoader.getSystemClassLoader());
                } catch (IOException ex) {
                  Exceptions.printStackTrace(ex);
                }
              }
            })
        .waitFinished();

    return referenceClassLoader;
  }
  public void propertyChange(PropertyChangeEvent evt) {
    String propertyName = evt.getPropertyName();
    if (propertyName == null) return;
    if ((!JPDABreakpoint.PROP_ENABLED.equals(propertyName))
        && (!JPDABreakpoint.PROP_VALIDITY.equals(propertyName))
        && (!LineBreakpoint.PROP_CONDITION.equals(propertyName))
        && (!LineBreakpoint.PROP_URL.equals(propertyName))
        && (!LineBreakpoint.PROP_LINE_NUMBER.equals(propertyName)) // &&
    //             (!FieldBreakpoint.PROP_CLASS_NAME.equals( propertyName )) &&
    //             (!FieldBreakpoint.PROP_FIELD_NAME.equals( propertyName )) &&
    //             (!MethodBreakpoint.PROP_CLASS_FILTERS.equals( propertyName )) &&
    //             (!MethodBreakpoint.PROP_CLASS_EXCLUSION_FILTERS.equals( propertyName )) &&
    //             (!MethodBreakpoint.PROP_METHOD_NAME.equals( propertyName )) &&
    //             (!MethodBreakpoint.PROP_METHOD_SIGNATURE.equals( propertyName )

    ) return;
    //        JPDABreakpoint b = (JPDABreakpoint) evt.getSource();
    VisageLineBreakpoint b = (VisageLineBreakpoint) evt.getSource();
    DebuggerManager manager = DebuggerManager.getDebuggerManager();
    Breakpoint[] bkpts = manager.getBreakpoints();
    boolean found = false;
    for (int x = 0; x < bkpts.length; x++) {
      if (b == bkpts[x]) {
        found = true;
        break;
      }
    }
    if (!found) {
      // breakpoint has been removed
      return;
    }
    rp.post(new AnnotationRefresh(b, true, true));
  }
 @Override
 public void actionPerformed(ActionEvent ev) {
   // Start JSLintRunnable
   if (processor == null) {
     processor = new RequestProcessor("JSLintErrorCheck", 1, true);
   }
   processor.post(new JSLintRunnable(context, "-e"));
 }
 public @Override void actionPerformed(ActionEvent e) {
   RP.post(
       new Runnable() {
         @Override
         public void run() {
           DDHelper.addJsfListener(serverProject, webProject);
         }
       });
 } // class
 @Override
 public void run() {
   if (!SwingUtilities.isEventDispatchThread()) {
     EventQueue.invokeLater(this);
     return;
   }
   currentToken = new Object();
   TopComponent.Registry registry = TopComponent.getRegistry();
   final TopComponent activeTc = registry.getActivated();
   final Set<TopComponent> opened = new HashSet<>(registry.getOpened());
   final LayoutScene existingLayers = currentLayers;
   final boolean isMaximized = isLayersMaximized();
   final Object token = currentToken;
   RP.post(
       () -> {
         findNewLayers(existingLayers, activeTc, opened, isMaximized, token);
       });
 }
  @NbBundle.Messages({
    "GitHubIssueController.edit.comment.title=Edit Comment",
    "GitHubIssueController.edit.comment.fail=Can't edit this comment."
  })
  private void editComment() {
    final Comment comment = getPanel().getEditedComment();
    final String editedBody =
        CommentTabbedPanel.showDialog(
            Bundle.GitHubIssueController_edit_comment_title(), comment.getBody());
    if (editedBody != null) {
      final GitHubIssue issue = getPanel().getIssue();
      if (issue != null) {
        RequestProcessor rp = GitHubIssues.getInstance().getRequestProcessor();
        rp.post(
            new Runnable() {

              @Override
              public void run() {
                Comment editedComment = issue.editComment(comment, editedBody);
                if (editedComment == null) {
                  UiUtils.showErrorDialog(Bundle.GitHubIssueController_edit_comment_fail());
                  return;
                }
                SwingUtilities.invokeLater(
                    new Runnable() {

                      @Override
                      public void run() {
                        getPanel().loadComments();
                      }
                    });
              }
            });
      }
    }
  }
    @Override
    public void actionPerformed(ActionEvent e) {
      String actionCommand = e.getActionCommand();
      final boolean isNewPullRequest = actionCommand.equals("New PR"); // NOI18N
      GitHubIssuePanel p = getPanel();
      p.setCreatePullRequestButtonEnabled(false);
      final GitHubIssue issue = p.getIssue();

      if (isNewPullRequest && !p.isNewPullRequestSelected()) {
        // remove the new pull request from the panle
        SwingUtilities.invokeLater(
            new Runnable() {
              @Override
              public void run() {
                getPanel().setNewPullRequest(null);
              }
            });
        return;
      }

      RequestProcessor rp = GitHubIssues.getInstance().getRequestProcessor();
      rp.post(
          new Runnable() {
            @Override
            public void run() {
              final GitHubRepository repository = issue.getRepository();
              GitHubCache cache = GitHubCache.create(repository);
              final User mySelf = cache.getMySelf();

              List<RepositoryBranch> baseBranches = cache.getBranches(true);
              final HashMap<Repository, List<RepositoryBranch>> baseRepositories = new HashMap<>();
              baseRepositories.put(repository.getRepository(), baseBranches);
              final Map<Repository, List<RepositoryBranch>> headRepositories =
                  getHeadRepositories(repository, baseBranches);

              SwingUtilities.invokeLater(
                  new Runnable() {
                    @Override
                    public void run() {
                      try {
                        if (baseRepositories.isEmpty() || headRepositories.isEmpty()) {
                          UiUtils.showErrorDialog(
                              Bundle
                                  .CreatePullRequestAction_error_message_cannot_find_base_head_repositories());
                          return;
                        }

                        // create descriptor
                        final CreatePullRequestPanel createPullRequestPanel =
                            new CreatePullRequestPanel(baseRepositories, headRepositories);
                        createPullRequestPanel.setMessage(
                            Bundle.CreatePullRequestAction_confirmation_message());
                        final NotifyDescriptor.Confirmation descriptor =
                            new NotifyDescriptor.Confirmation(
                                createPullRequestPanel,
                                Bundle.CreatePullRequestAction_descriptor_title(),
                                NotifyDescriptor.OK_CANCEL_OPTION,
                                NotifyDescriptor.QUESTION_MESSAGE);

                        // add listeners
                        ChangeListener changeListener =
                            new ChangeListener() {
                              @Override
                              public void stateChanged(ChangeEvent e) {
                                descriptor.setValid(false);
                                createPullRequestPanel.setErrorMessage(""); // NOI18N
                              }
                            };
                        createPullRequestPanel.addChangeListener(changeListener);
                        ComparePullRequestPropertyChangeListener propertyChangeListener =
                            new ComparePullRequestPropertyChangeListener(
                                repository, createPullRequestPanel, descriptor);
                        createPullRequestPanel.addPropertyChangeListener(propertyChangeListener);
                        changeListener.stateChanged(null);

                        // show dialog
                        if (DialogDisplayer.getDefault().notify(descriptor)
                            == NotifyDescriptor.OK_OPTION) {
                          RepositoryBranch selectedBaseBranch =
                              createPullRequestPanel.getSelectedBaseBranch();
                          RepositoryBranch selectedHeadBranch =
                              createPullRequestPanel.getSelectedHeadBranch();
                          String baseBranch = selectedBaseBranch.getName();
                          String headBranch =
                              mySelf.getLogin() + ":" + selectedHeadBranch.getName(); // NOI18N
                          PullRequest pullRequest;
                          try {
                            if (isNewPullRequest) {
                              // set new pull request to panel
                              PullRequestMarker baseMarker = new PullRequestMarker();
                              baseMarker.setLabel(baseBranch);
                              PullRequestMarker headMarker = new PullRequestMarker();
                              headMarker.setLabel(headBranch);
                              PullRequest newPullRequest =
                                  new PullRequest().setBase(baseMarker).setHead(headMarker);
                              getPanel().setNewPullRequest(newPullRequest);
                            } else {
                              pullRequest = issue.createPullRequest(headBranch, baseBranch);
                              if (pullRequest != null) {
                                getPanel().refresh();
                              }
                            }
                          } catch (IOException ex) {
                            UiUtils.showErrorDialog(
                                "Can't create a pull request:" + ex.getMessage()); // NOI18N
                          }
                        } else if (isNewPullRequest) {
                          getPanel().setNewPullRequestSelected(false);
                        }

                        // remove listeners
                        createPullRequestPanel.removeChangeListener(changeListener);
                        createPullRequestPanel.removePropertyChangeListener(propertyChangeListener);
                      } finally {
                        getPanel().setCreatePullRequestButtonEnabled(true);
                      }
                    }
                  });
            }
          });
    }
    @NbBundle.Messages({
      "SubmitIssueAction.message.pull.request.added.fail=The pull request has not been added.",
      "SubmitIssueAction.message.issue.added.fail=The issue has not been added.",
      "SubmitIssueAction.message.issue.updated.fail=The issue has not been updated."
    })
    @Override
    public void actionPerformed(ActionEvent e) {
      final GitHubIssuePanel p = getPanel();
      p.setSubmitButtonEnabled(false);
      RequestProcessor rp = GitHubIssues.getInstance().getRequestProcessor();
      rp.post(
          new Runnable() {

            @Override
            public void run() {
              SwingUtilities.invokeLater(
                  new Runnable() {
                    @Override
                    public void run() {
                      GitHubIssue issue = p.getIssue();
                      CreateIssueParams issueParams = getCreateIssueParams(issue.isNew(), p);
                      if (issue.isNew()) {
                        if (p.isNewPullRequestSelected()) {
                          // add pull request
                          // can be added only title and body to a pull request
                          // add other than those after the pull request was created
                          PullRequest newPullRequest = p.getNewPullRequest();
                          if (newPullRequest != null) {
                            newPullRequest
                                .setTitle(issueParams.getTitle())
                                .setBody(issueParams.getBody());
                            try {
                              PullRequest createdPullRequest =
                                  issue.createPullRequest(newPullRequest);
                              if (createdPullRequest != null) {
                                issue.editIssue(issueParams);
                                p.update();
                              } else {
                                // show dialog
                                UiUtils.showErrorDialog(
                                    Bundle.SubmitIssueAction_message_pull_request_added_fail());
                              }
                            } catch (IOException ex) {
                              UiUtils.showErrorDialog(ex.getMessage());
                            }
                          }
                        } else {
                          // add issue
                          Issue newIssue = issue.submitNewIssue(issueParams);
                          if (newIssue != null) {
                            p.update();
                          } else {
                            // show dialog
                            UiUtils.showErrorDialog(
                                Bundle.SubmitIssueAction_message_issue_added_fail());
                          }
                        }
                      } else {
                        // edit issue
                        Issue editIssue = issue.editIssue(issueParams);
                        if (editIssue != null) {
                          p.update();
                        } else {
                          // show dialog
                          UiUtils.showErrorDialog(
                              Bundle.SubmitIssueAction_message_issue_updated_fail());
                        }
                      }
                      p.setSubmitButtonEnabled(true);
                    }
                  });
            }
          });
    }
  public Task run() {
    ClassLoader targetLoader;
    if (target.contains("sharwell/optimized")) {
      targetLoader = Thread.currentThread().getContextClassLoader();
    } else {
      targetLoader = getReferenceClassLoader();
    }

    if (targetLoader == null) {
      return RequestProcessor.Task.EMPTY;
    }

    final ClassLoader loader = targetLoader;

    return REFERENCE_RP.post(
        new Runnable() {
          @Override
          public void run() {
            try {
              Class<?> toolClass = loader.loadClass(Tool.class.getName());
              Constructor<?> ctor = toolClass.getConstructor(String[].class);
              Method processGrammarsOnCommandLine =
                  toolClass.getMethod("processGrammarsOnCommandLine");

              List<String> args = getCommandArguments();
              for (FileObject grammarFile : grammarFiles) {
                args.add(FileUtil.toFile(grammarFile).getAbsolutePath());
              }

              ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
              Thread.currentThread().setContextClassLoader(loader);
              try {
                InputOutput inputOutput =
                    IOProvider.getDefault()
                        .getIO(String.format("ANTLR Codegen (%s)", target), false);
                inputOutput.select();
                PrintStream originalOut = System.out;
                try (OutputWriter outputWriter = inputOutput.getOut()) {
                  System.setOut(new PrintStream(new OutputWriterStream(outputWriter)));
                  try {
                    PrintStream originalErr = System.err;
                    try (OutputWriter errorWriter = inputOutput.getErr()) {
                      System.setErr(new PrintStream(new OutputWriterStream(errorWriter)));
                      try {
                        outputWriter.format("Arguments: %s%n", args);
                        Object tool =
                            ctor.newInstance((Object) args.toArray(new String[args.size()]));
                        processGrammarsOnCommandLine.invoke(tool);
                      } finally {
                        System.setErr(originalErr);
                      }
                    }
                  } finally {
                    System.setOut(originalOut);
                  }
                }
              } finally {
                Thread.currentThread().setContextClassLoader(contextClassLoader);
              }
            } catch (ClassNotFoundException
                | NoSuchMethodException
                | SecurityException
                | InstantiationException
                | IllegalAccessException
                | IllegalArgumentException
                | InvocationTargetException ex) {
              Exceptions.printStackTrace(ex);
            }
          }
        });
  }