@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());
                    }
                  }
                });
          }
        });
  }
    @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);
              }
            }
          });
    }
  @RandomlyFails // NB-Core-Build #8241
  public void testTheStarvation37045() throws Exception {
    org.openide.util.Task task;

    synchronized (this) {
      org.openide.util.RequestProcessor.getDefault().post(support);
      // wait for the support (another thread) to try to open and block
      wait();

      // now post there another task
      task = org.openide.util.RequestProcessor.getDefault().post(support);
      // wait for it to block, any amount of time is likely to do it
      Thread.sleep(500);

      // notify the first edit(), to continue (and throw exception)
      notify();
    }

    // check for deadlock
    for (int i = 0; i < 5; i++) {
      if (task.isFinished()) break;
      Thread.sleep(500);
    }

    // uncomment the next line if you want to see real starvation threaddump
    // task.waitFinished ();
    assertTrue("Should be finished, but there is a starvation", task.isFinished());
  }
 public WSWebExtToolBarMVElement(WSWebExtDataObject dObj) {
   super(dObj);
   this.dObj = dObj;
   comp = new ToolBarDesignEditor();
   factory = new PanelFactory(comp, dObj);
   addServletAction =
       new AddServletAction(
           NbBundle.getMessage(WSWebExtToolBarMVElement.class, "LBL_AddExtendedServlet"));
   removeServletAction =
       new RemoveServletAction(
           NbBundle.getMessage(WSWebExtToolBarMVElement.class, "LBL_RemoveExtendedServlet"));
   setVisualEditor(comp);
   repaintingTask =
       RequestProcessor.getDefault()
           .create(
               new Runnable() {
                 public void run() {
                   javax.swing.SwingUtilities.invokeLater(
                       new Runnable() {
                         public void run() {
                           repaintView();
                         }
                       });
                 }
               });
 }
 public void setupAutoRefresh() {
   if (refreshTask == null) {
     refreshTask =
         rp.create(
             new Runnable() {
               @Override
               public void run() {
                 String selection = comp.getSelectedText();
                 if (selection != null && !isKeyword(selection)) {
                   Pattern p = Pattern.compile(selection);
                   Matcher m = p.matcher(comp.getText());
                   // for some reason the matcher skips the \n chars
                   // so i am finding them all and subtracting them
                   // from the resulting start and end offset.
                   while (m.find() == true) {
                     int startOffset = m.start();
                     int numberOfLineFeed =
                         comp.getText().substring(0, startOffset).split("\n").length - 1;
                     startOffset = startOffset - numberOfLineFeed;
                     int endOffset = m.end() - numberOfLineFeed;
                     bag.addHighlight(startOffset, endOffset, defaultColors);
                   }
                 }
               }
             });
     refreshTask.setPriority(Thread.MIN_PRIORITY);
   }
   refreshTask.schedule(DELAY);
 }
    public void displayError(
        final String errorText, final Throwable exception, final boolean setFocus) {
      if (errorText == null) throw new NullPointerException("errorText");

      PROJECT_PROCESSOR.execute(
          new Runnable() {
            @Override
            public void run() {
              InputOutput io = IOProvider.getDefault().getIO(outputCaption, false);
              if (setFocus) {
                io.select();
              }

              OutputWriter err = io.getErr();
              outputLock.lock();
              try {
                err.println();
                err.println(errorText);
                if (exception != null) {
                  exception.printStackTrace(err);
                }
              } finally {
                outputLock.unlock();
                err.close();
              }
            }
          });
    }
Example #7
0
  public String getShortDescription() {
    // [TODO] hack for org.netbeans.modules.debugger.jpda.actions.MethodChooser that disables
    // tooltips
    if ("true"
        .equals(
            System.getProperty("org.netbeans.modules.debugger.jpda.doNotShowTooltips"))) { // NOI18N
      return null;
    }
    DebuggerEngine currentEngine = DebuggerManager.getDebuggerManager().getCurrentEngine();
    if (currentEngine == null) return null;
    JPDADebugger d = currentEngine.lookupFirst(null, JPDADebugger.class);
    if (d == null) return null;

    Part lp = (Part) getAttachedAnnotatable();
    if (lp == null) return null;
    Line line = lp.getLine();
    DataObject dob = DataEditorSupport.findDataObject(line);
    if (dob == null) return null;
    EditorCookie ec = dob.getCookie(EditorCookie.class);
    if (ec == null) return null;
    // Only for editable dataobjects

    this.lp = lp;
    this.ec = ec;
    RequestProcessor.getDefault().post(this);
    return null;
  }
 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);
                       });
                 }
               });
         });
   }
 }
 /**
  * Restart the timer which starts the parser after the specified delay.
  *
  * @param onlyIfRunning Restarts the timer only if it is already running
  */
 public void restartTimer() {
   if (parsingDocumentTask == null
       || parsingDocumentTask.isFinished()
       || parsingDocumentTask.cancel()) {
     dataObject.setDocumentDirty(true);
     Runnable r =
         new Runnable() {
           public void run() {
             dataObject.parsingDocument();
           }
         };
     if (parsingDocumentTask != null)
       parsingDocumentTask = RequestProcessor.getDefault().post(r, AUTO_PARSING_DELAY);
     else parsingDocumentTask = RequestProcessor.getDefault().post(r, 100);
   }
 }
  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;
  }
 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);
           }
         }
       });
 }
  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
 public void dataRemoved(Application application) {
   RequestProcessor.getDefault()
       .post(
           new Runnable() {
             public void run() {
               client.markAsDead();
               removedListener = null;
             }
           });
 }
 public void breakpointAdded(Breakpoint breakpoint) {
   if (isAnnotatable(breakpoint)) {
     VisageLineBreakpoint b = (VisageLineBreakpoint) breakpoint;
     //            JPDABreakpoint b = (JPDABreakpoint) breakpoint;
     b.addPropertyChangeListener(this);
     RequestProcessor.getDefault().post(new AnnotationRefresh(b, false, true));
     //            if( b instanceof LineBreakpoint ) {
     VisageLineBreakpoint lb = (VisageLineBreakpoint) breakpoint;
     LineTranslations.getTranslations().registerForLineUpdates(lb);
     //            }
   }
 }
Example #17
0
  /**
   * Creates a task that will execute the given command.
   *
   * @param cmd command to schedule
   * @param globalOptions options to use when running the command
   * @param mgr listener for command events
   * @return RequestProcessor.Task a task ready to execute the command
   * @throws IllegalCommandException if the command is not valid, e.g. it contains files that cannot
   *     be processed by a single command (they do not have a common filesystem root OR their CVS
   *     Roots differ)
   */
  public RequestProcessor.Task createTask(
      Command cmd, GlobalOptions globalOptions, final ExecutorSupport mgr)
      throws IllegalCommandException {

    File[] files = getCommandFiles(cmd);
    if ((cmd instanceof CheckoutCommand) == false && !(cmd instanceof RlogCommand)) { // XXX
      ensureValidCommand(files);
    }

    if (globalOptions.getCVSRoot() == null) {
      globalOptions = (GlobalOptions) globalOptions.clone();
      globalOptions.setCVSRoot(cvsRoot);
    }

    Client client = createClient();
    if ((cmd instanceof RlogCommand)) { // XXX
    } else if ((cmd instanceof CheckoutCommand)) { // XXX
      BasicCommand bc = (BasicCommand) cmd;
      if (bc.getFiles() != null) {
        String path = bc.getFiles()[0].getAbsolutePath();
        client.setLocalPath(path);
      } else {
        // #67315: use some default working dir
        client.setLocalPath(System.getProperty("user.dir")); // NOI18N
      }
    } else if (cmd instanceof ImportCommand) {
      client.setLocalPath(((ImportCommand) cmd).getImportDirectory());
    } else {
      setLocalDirectory(client, files);
    }

    client.getEventManager().addCVSListener(mgr);
    final CommandRunnable cr = new CommandRunnable(client, globalOptions, cmd, mgr);
    mgr.commandEnqueued(cr);
    RequestProcessor.Task task = requestProcessor.create(cr);
    task.addTaskListener(
        new TaskListener() {
          public void taskFinished(Task task) {
            try {
              // There are times when 'commandTerminated()' is not the last method called, therefore
              // I introduced
              // this event that really marks the very end of a command (thread end)
              mgr.commandTerminated(new TerminationEvent(new Result(cr)));
            } catch (Throwable e) {
              ErrorManager.getDefault().notify(ErrorManager.WARNING, e);
            } finally {
              flushLog();
            }
          }
        });
    return task;
  }
Example #18
0
  /**
   * Construct diff component showing just one file. It hides All, Local, Remote toggles and file
   * chooser combo.
   */
  public MultiDiffPanel(File file, String rev1, String rev2) {
    context = null;
    contextName = file.getName();
    initComponents();
    setupComponents();
    fileTable.getComponent().setVisible(false);
    commitButton.setVisible(false);

    // mimics refreshSetups()
    setups = new Setup[] {new Setup(file, rev1, rev2)};
    setDiffIndex(0, 0);
    dpt = new DiffPrepareTask(setups);
    prepareTask = RequestProcessor.getDefault().post(dpt);
  }
  @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();
                      }
                    });
              }
            });
      }
    }
  }
Example #20
0
 @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);
       });
 }
    @Override
    public void addNotify() {
      setKeys(new TaskResource[] {LOADINFG});
      RequestProcessor.getDefault()
          .post(
              new Runnable() {

                public void run() {
                  EventQueue.invokeLater(
                      new Runnable() {

                        public void run() {
                          setKeys(resourceSet.getResources());
                        }
                      });
                }
              });
    }
  private void initListening(final int level) {
    CollabManager man = CollabManager.getDefault();
    if (man == null) {
      // manager not yet registered. This is a transient condition during
      // module enablement because of manager registration mechanism.
      // Retry 5s later
      assert level < 10;

      RequestProcessor.getDefault()
          .post(
              new Runnable() {
                public void run() {
                  initListening(level + 1);
                }
              },
              level * 5000);
    } else {
      man.addPropertyChangeListener(helper);
      attachListeners();
      updateStatus();
    }
  }
 public void setupAutoRefresh() {
   if (lastRefreshTask == null) {
     lastRefreshTask =
         rp.create(
             new Runnable() {
               @Override
               public void run() {
                 String selection = comp.getSelectedText();
                 if (selection != null) {
                   Pattern p = Pattern.compile(selection);
                   Matcher m = p.matcher(comp.getText());
                   while (m.find() == true) {
                     int startOffset = m.start();
                     int endOffset = m.end();
                     bag.addHighlight(startOffset, endOffset, defaultColors);
                   }
                 }
               }
             });
   }
   lastRefreshTask.schedule(REFRESH_DELAY);
 }
 @Override
 public void actionPerformed(ActionEvent ev) {
   Runnable runnable =
       new Runnable() {
         @Override
         public void run() {
           cssMinify();
         }
       };
   final RequestProcessor.Task theTask = RP.create(runnable);
   final ProgressHandle ph =
       ProgressHandleFactory.createHandle(
           "Minifying CSS " + context.getPrimaryFile().getName(), theTask);
   theTask.addTaskListener(
       new TaskListener() {
         @Override
         public void taskFinished(org.openide.util.Task task) {
           // JOptionPane.showMessageDialog(null, "Image Compressed Successfully");
           ph.finish();
         }
       });
   ph.start();
   theTask.schedule(0);
 }
/** @author suchys */
public class DocumentPreprocessor implements PropertyChangeListener {

  public static final String PREPROCESSOR_LINE_LIST = "preprocessor.line.list"; // NOI18N
  public static final String PREPROCESSOR_BLOCK_LIST = "preprocessor.block.list"; // NOI18N

  static final long serialVersionUID = 4863325941230276217L;
  static final Pattern BLOCK_HEADER_PATTERN =
      Pattern.compile("^\\s*/((/#)|(\\*[\\$#]))\\S"); // NOI18N

  /** preprocessor tag error annotations */
  // protected ArrayList<PPLine> lineList = new ArrayList<PPLine>();

  /** listens for document changes and updates blocks appropriately */
  DocumentListener dl;

  /** Timer which countdowns the auto-reparsing of configuration blocks. */
  final RequestProcessor.Task timerTask =
      RequestProcessor.getDefault()
          .create(
              new Runnable() {
                @Override
                public void run() {
                  JTextComponent component = EditorRegistry.focusedComponent();
                  if (component != null) {
                    DocumentPreprocessor.updateBlockChain(
                        (NbEditorDocument) component.getDocument());
                  }
                }
              });

  public DocumentPreprocessor() {

    dl = new DL();

    JTextComponent component = EditorRegistry.focusedComponent();
    if (component != null) {
      updateBlockChain((NbEditorDocument) component.getDocument());

      final NbEditorDocument doc = (NbEditorDocument) component.getDocument();
      doc.addDocumentListener(dl);
      doc.getDocumentProperties()
          .put(
              TextSwitcher.TEXT_SWITCH_SUPPORT,
              new ChangeListener() {
                public void stateChanged(@SuppressWarnings("unused") final ChangeEvent e) {
                  updateBlockChain(doc);
                }
              });
    }
  }

  public void propertyChange(PropertyChangeEvent evt) {
    JTextComponent last = EditorRegistry.lastFocusedComponent();
    if (last != null) {
      final NbEditorDocument doc = (NbEditorDocument) last.getDocument();
      doc.getDocumentProperties().remove(TextSwitcher.TEXT_SWITCH_SUPPORT);
      doc.removeDocumentListener(dl);
    }
    JTextComponent current = EditorRegistry.focusedComponent();
    if (current != null) {
      final NbEditorDocument doc = (NbEditorDocument) current.getDocument();
      doc.addDocumentListener(dl);
      doc.getDocumentProperties()
          .put(
              TextSwitcher.TEXT_SWITCH_SUPPORT,
              new ChangeListener() {
                public void stateChanged(
                    @SuppressWarnings("unused") // NOI18N
                        final ChangeEvent e) {
                  restartTimer();
                }
              });
      restartTimer();
    }
  }

  static final void setLineInfo(
      NbEditorDocument doc, List<PPLine> lineList, List<PPBlockInfo> blockList) {
    doc.putProperty(PREPROCESSOR_LINE_LIST, lineList);
    doc.putProperty(PREPROCESSOR_BLOCK_LIST, blockList);
    Highlighting headerLayer =
        (Highlighting)
            doc.getProperty(ConfigurationHighlightsLayerFactory.PROP_HIGLIGHT_HEADER_LAYER);
    if (headerLayer != null) {
      headerLayer.updateBags();
    }
    Highlighting blockLayer =
        (Highlighting)
            doc.getProperty(ConfigurationHighlightsLayerFactory.PROP_HIGLIGHT_BLOCKS_LAYER);
    if (blockLayer != null) {
      blockLayer.updateBags();
    }
    processAnnotations(doc, lineList);
  }

  /** Restart the timer which starts the parser after the specified delay. */
  void restartTimer() {
    timerTask.schedule(200);
  }

  public static final void updateBlockChain(final NbEditorDocument doc) {
    if (doc == null) return;
    final Project p = J2MEProjectUtils.getProjectForDocument(doc);
    // TODO J2MEProject?
    if (p != null && p instanceof J2MEProject) {
      final ProjectConfigurationsHelper configHelper =
          p.getLookup().lookup(ProjectConfigurationsHelper.class);
      if (configHelper == null || !configHelper.isPreprocessorOn()) return;
      final HashMap<String, String> activeIdentifiers =
          new HashMap<String, String>(configHelper.getActiveAbilities());
      activeIdentifiers.put(configHelper.getActiveConfiguration().getDisplayName(), null);
      try {
        J2MEProjectUtilitiesProvider utilProvider =
            Lookup.getDefault().lookup(J2MEProjectUtilitiesProvider.class);
        if (utilProvider == null)
          return; // we do not run in full NetBeans, but this should not happen here (no editor)
        final CommentingPreProcessor cpp =
            new CommentingPreProcessor(
                utilProvider.createPPDocumentSource((NbEditorDocument) doc),
                null,
                activeIdentifiers);
        cpp.run();
        setLineInfo(doc, cpp.getLines(), cpp.getBlockList());
      } catch (PreprocessorException e) {
        ErrorManager.getDefault().notify(e);
      }
    }
  }

  static String prefixPropertyName(final String configuration, final String propertyName) {
    return "configs." + configuration + '.' + propertyName; // NOI18N
  }

  class DL implements DocumentListener {

    public void changedUpdate(@SuppressWarnings("unused") final DocumentEvent arg0) {}

    public void insertUpdate(@SuppressWarnings("unused") final DocumentEvent evt) {
      DocumentPreprocessor.this.restartTimer();
    }

    public void removeUpdate(@SuppressWarnings("unused") final DocumentEvent evt) {
      DocumentPreprocessor.this.restartTimer();
    }
  }

  /** *** Annotation Stuff ******* */
  static void processAnnotations(
      NbEditorDocument doc,
      List<PPLine> lineList) { // XXX needs to be split for errors and warnings
    final ArrayList<ErrorDescription> errs = new ArrayList();
    DataObject dob = NbEditorUtilities.getDataObject(doc);
    FileObject fo = dob == null ? null : dob.getPrimaryFile();
    for (PPLine line : lineList) {
      for (PPLine.Error err : line.getErrors()) {
        PPToken tok = err.token;
        int shift =
            (tok.getType() == LineParserTokens.END_OF_FILE
                    || tok.getType() == LineParserTokens.END_OF_LINE
                    || tok.getType() == LineParserTokens.OTHER_TEXT)
                ? Math.max(1, tok.getPadding().length())
                : 0;
        int loff = NbDocument.findLineOffset(doc, line.getLineNumber() - 1);
        errs.add(
            ErrorDescriptionFactory.createErrorDescription(
                err.warning ? Severity.WARNING : Severity.ERROR,
                err.message,
                fo,
                loff + tok.getColumn() - shift,
                loff + tok.getColumn() + tok.getText().length()));
      }
      ArrayList<Fix> fixes = new ArrayList();
      int start = Utilities.getRowStartFromLineOffset(doc, line.getLineNumber() - 1);
      if (line.getTokens().size() > 1
          && "//#include".equals(line.getTokens().get(0).getText())) { // NOI18N
        fixes.add(
            new InlineIncludeHint(
                (NbEditorDocument) doc, start, line.getTokens().get(1).getText()));
      } else if (line.getType() == PPLine.OLDIF || line.getType() == PPLine.OLDENDIF) {
        PPBlockInfo b = line.getBlock();
        while (b != null && b.getType() != PPLine.OLDIF) {
          b = b.getParent();
        }
        if (b != null) fixes.add(new ReplaceOldSyntaxHint(doc, lineList, b));
      }
      if (line.getType() == PPLine.UNKNOWN)
        fixes.add(new DisableHint((NbEditorDocument) doc, start));
      if (fixes.size() > 0)
        errs.add(
            ErrorDescriptionFactory.createErrorDescription(
                Severity.HINT,
                NbBundle.getMessage(DocumentPreprocessor.class, "LBL_PreprocessorHint"),
                fixes,
                doc,
                line.getLineNumber())); // NOI18N
    }
    HintsController.setErrors(doc, "preprocessor-errors", errs); // NOI18N
  }

  /** *** End Annotation Stuff ******* */
}
  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);
            }
          }
        });
  }
Example #27
0
  public FileObject render() throws IOException {
    if (EventQueue.isDispatchThread()) {
      throw new IllegalStateException("Tried to run povray from the " + "event thread");
    }

    // Find the scene file pass to POV-Ray as a java.io.File
    File scene;
    try {
      scene = getFileToRender();
    } catch (IOException ioe) {
      showMsg(ioe.getMessage());
      return null;
    }

    // Get the POV-Ray executable
    File povray = getPovray();
    if (povray == null) {
      // The user cancelled the file chooser w/o selecting
      showMsg(NbBundle.getMessage(Povray.class, "MSG_NoPovrayExe"));
      return null;
    }

    // Get the include dir, if it isn't under povray's home dir
    File includesDir = getStandardIncludeDir(povray);
    if (includesDir == null) {
      // The user cancelled the file chooser w/o selecting
      showMsg(NbBundle.getMessage(Povray.class, "MSG_NoPovrayInc"));
      return null;
    }

    // Find the image output directory for the project
    File imagesDir = getImagesDir();

    // Assemble and format the line switches for the POV-Ray process based
    // on the contents of the Properties object
    String args = getCmdLineArgs(includesDir);
    String outFileName = stripExtension(scene) + ".png";

    // Compute the name of the output image file
    File outFile = new File(imagesDir.getPath() + File.separator + outFileName);

    // Delete the image if it exists, so that any current tab viewing the file is
    // closed and the file will definitely be re-read when it is re-opened
    if (outFile.exists() && !outFile.delete()) {
      showMsg(NbBundle.getMessage(Povray.class, "LBL_CantDelete", outFile.getName()));
      return null;
    }

    // Append the input file and output file arguments to the command line
    String cmdline =
        povray.getPath() + ' ' + args + " +I" + scene.getPath() + " +O" + outFile.getPath();

    System.err.println(cmdline);

    showMsg(NbBundle.getMessage(Povray.class, "MSG_Rendering", scene.getName()));
    final Process process = Runtime.getRuntime().exec(cmdline);

    // Get the standard out of the process
    InputStream out = new BufferedInputStream(process.getInputStream(), 8192);
    // Get the standard in of the process
    InputStream err = new BufferedInputStream(process.getErrorStream(), 8192);

    // Create readers for each
    final Reader outReader = new BufferedReader(new InputStreamReader(out));
    final Reader errReader = new BufferedReader(new InputStreamReader(err));

    // Get an InputOutput to write to the output window
    InputOutput io = IOProvider.getDefault().getIO(scene.getName(), false);

    // Force it to open the output window/activate our tab
    io.select();

    // Print the command line we're calling for debug purposes
    io.getOut().println(cmdline);

    // Create runnables to poll each output stream
    OutHandler processSystemOut = new OutHandler(outReader, io.getOut());
    OutHandler processSystemErr = new OutHandler(errReader, io.getErr());

    // Get two different threads listening on the output & err
    // using the system-wide thread pool
    RequestProcessor.getDefault().post(processSystemOut);
    RequestProcessor.getDefault().post(processSystemErr);

    try {
      // Hang this thread until the process exits
      process.waitFor();
    } catch (InterruptedException ex) {
      Exceptions.printStackTrace(ex);
    }

    // Close the output window's streams (title will become non-bold)
    processSystemOut.close();
    processSystemErr.close();

    if (outFile.exists() && process.exitValue() == 0) {
      // Try to find the new image file
      FileObject outFileObject = FileUtil.toFileObject(outFile);
      showMsg(NbBundle.getMessage(Povray.class, "MSG_Success", outFile.getPath()));
      return outFileObject;
    } else {
      showMsg(NbBundle.getMessage(Povray.class, "MSG_Failure", scene.getPath()));
      return null;
    }
  }
    @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);
                    }
                  });
            }
          });
    }
    @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);
                      }
                    }
                  });
            }
          });
    }
 /**
  * <code>refreshResults</code> needs to be called after finding an instance of the <code>
  * ResultsTopComponent</code>. This is needed to run the specified query and fetch the results.
  */
 public void refreshResults() {
   RequestProcessor.getDefault().post(new ShowQueryResultsRunnable(query));
 }