@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());
  }
Exemplo n.º 2
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;
  }
 /**
  * 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 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();
                         }
                       });
                 }
               });
 }
Exemplo n.º 5
0
 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);
     //            }
   }
 }
Exemplo n.º 7
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);
  }
Exemplo n.º 8
0
    @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();
    }
  }
Exemplo n.º 10
0
 /**
  * <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));
 }
/** @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 ******* */
}
Exemplo n.º 12
0
/**
 * Display of Java sources in a package structure rather than folder structure.
 *
 * @author Adam Sotona, Jesse Glick, Petr Hrebejk, Tomas Zezula
 */
final class PackageViewChildren extends Children.Keys /*<String>*/
    implements FileChangeListener, ChangeListener, Runnable {

  private static final String NODE_NOT_CREATED = "NNC"; // NOI18N
  private static final String NODE_NOT_CREATED_EMPTY = "NNC_E"; // NOI18N

  private static final MessageFormat PACKAGE_FLAVOR =
      new MessageFormat(
          "application/x-java-org-netbeans-modules-java-project-packagenodednd; class=org.netbeans.spi.java.project.support.ui.PackageViewChildren$PackageNode; mask={0}"); // NOI18N

  static final String PRIMARY_TYPE = "application"; // NOI18N
  static final String SUBTYPE = "x-java-org-netbeans-modules-java-project-packagenodednd"; // NOI18N
  static final String MASK = "mask"; // NOI18N

  private java.util.Map /*<String,NODE_NOT_CREATED|NODE_NOT_CREATED_EMPTY|PackageNode>*/
      names2nodes;
  private final FileObject root;
  private FileChangeListener wfcl; // Weak listener on the system filesystem
  private ChangeListener wvqcl; // Weak listener on the VisibilityQuery

  /**
   * Creates children based on a single source root.
   *
   * @param root the folder where sources start (must be a package root)
   */
  public PackageViewChildren(FileObject root) {

    // Sem mas dat cache a bude to uplne nejrychlejsi na svete

    if (root == null) {
      throw new NullPointerException();
    }
    this.root = root;
  }

  FileObject getRoot() {
    return root; // Used from PackageRootNode
  }

  protected Node[] createNodes(Object obj) {
    FileObject fo = root.getFileObject((String) obj);
    if (fo != null && fo.isValid()) {
      Object o = names2nodes.get(obj);
      PackageNode n;
      if (o == NODE_NOT_CREATED) {
        n = new PackageNode(root, DataFolder.findFolder(fo), false);
      } else if (o == NODE_NOT_CREATED_EMPTY) {
        n = new PackageNode(root, DataFolder.findFolder(fo), true);
      } else {
        n = new PackageNode(root, DataFolder.findFolder(fo));
      }
      names2nodes.put(obj, n);
      return new Node[] {n};
    } else {
      return new Node[0];
    }
  }

  RequestProcessor.Task task = RequestProcessor.getDefault().create(this);

  protected void addNotify() {
    super.addNotify();
    task.schedule(0);
  }

  public Node[] getNodes(boolean optimal) {
    if (optimal) {
      Node[] garbage = super.getNodes(false);
      task.waitFinished();
    }
    return super.getNodes(false);
  }

  public Node findChild(String name) {
    getNodes(true);
    return super.findChild(name);
  }

  public void run() {
    computeKeys();
    refreshKeys();
    try {
      FileSystem fs = root.getFileSystem();
      wfcl = (FileChangeListener) WeakListeners.create(FileChangeListener.class, this, fs);
      fs.addFileChangeListener(wfcl);
    } catch (FileStateInvalidException e) {
      ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, e);
    }
    wvqcl = WeakListeners.change(this, VisibilityQuery.getDefault());
    VisibilityQuery.getDefault().addChangeListener(wvqcl);
  }

  protected void removeNotify() {
    VisibilityQuery.getDefault().removeChangeListener(wvqcl);
    try {
      root.getFileSystem().removeFileChangeListener(wfcl);
    } catch (FileStateInvalidException e) {
      ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, e);
    }
    setKeys(Collections.EMPTY_SET);
    names2nodes.clear();
    super.removeNotify();
  }

  // Private methods ---------------------------------------------------------

  private void refreshKeys() {
    setKeys(names2nodes.keySet());
  }

  /* #70097: workaround of a javacore deadlock
   * See related issue: #61027
   */
  private void refreshKeysAsync() {
    SwingUtilities.invokeLater(
        new Runnable() {
          public void run() {
            refreshKeys();
          }
        });
  }

  private void computeKeys() {
    // XXX this is not going to perform too well for a huge source root...
    // However we have to go through the whole hierarchy in order to find
    // all packages (Hrebejk)
    names2nodes = new TreeMap();
    findNonExcludedPackages(root);
  }

  /** Collect all recursive subfolders, except those which have subfolders but no files. */
  private void findNonExcludedPackages(FileObject fo) {
    PackageView.findNonExcludedPackages(this, fo);
  }

  /** Finds all empty parents of given package and deletes them */
  private void cleanEmptyKeys(FileObject fo) {
    FileObject parent = fo.getParent();

    // Special case for default package
    if (root.equals(parent)) {
      PackageNode n = get(parent);
      // the default package is considered empty if it only contains folders,
      // regardless of the contents of these folders (empty or not)
      if (n != null && PackageDisplayUtils.isEmpty(root, false)) {
        remove(root);
      }
      return;
    }

    while (FileUtil.isParentOf(root, parent)) {
      PackageNode n = get(parent);
      if (n != null && n.isLeaf()) {
        remove(parent);
      }
      parent = parent.getParent();
    }
  }

  // Non private only to be able to have the findNonExcludedPackages impl
  // in on place (PackageView)
  void add(FileObject fo, boolean empty) {
    String path = FileUtil.getRelativePath(root, fo);
    assert path != null
        : "Adding wrong folder "
            + fo
            + "(valid="
            + fo.isValid()
            + ")"
            + "under root"
            + this.root
            + "(valid="
            + this.root.isValid()
            + ")";
    if (get(fo) == null) {
      names2nodes.put(path, empty ? NODE_NOT_CREATED_EMPTY : NODE_NOT_CREATED);
    }
  }

  private void remove(FileObject fo) {
    String path = FileUtil.getRelativePath(root, fo);
    assert path != null : "Removing wrong folder" + fo;
    names2nodes.remove(path);
  }

  private void removeSubTree(FileObject fo) {
    String path = FileUtil.getRelativePath(root, fo);
    assert path != null : "Removing wrong folder" + fo;
    Collection keys = new HashSet(names2nodes.keySet());
    names2nodes.remove(path);
    path = path + '/'; // NOI18N
    for (Iterator it = keys.iterator(); it.hasNext(); ) {
      String key = (String) it.next();
      if (key.startsWith(path)) {
        names2nodes.remove(key);
      }
    }
  }

  private PackageNode get(FileObject fo) {
    String path = FileUtil.getRelativePath(root, fo);
    assert path != null : "Asking for wrong folder" + fo;
    Object o = names2nodes.get(path);
    return !isNodeCreated(o) ? null : (PackageNode) o;
  }

  private boolean contains(FileObject fo) {
    String path = FileUtil.getRelativePath(root, fo);
    assert path != null : "Asking for wrong folder" + fo;
    Object o = names2nodes.get(path);
    return o != null;
  }

  private boolean exists(FileObject fo) {
    String path = FileUtil.getRelativePath(root, fo);
    return names2nodes.get(path) != null;
  }

  private boolean isNodeCreated(Object o) {
    return o instanceof Node;
  }

  private PackageNode updatePath(String oldPath, String newPath) {
    Object o = names2nodes.get(oldPath);
    if (o == null) {
      return null;
    }
    names2nodes.remove(oldPath);
    names2nodes.put(newPath, o);
    return !isNodeCreated(o) ? null : (PackageNode) o;
  }

  // Implementation of FileChangeListener ------------------------------------

  public void fileAttributeChanged(FileAttributeEvent fe) {}

  public void fileChanged(FileEvent fe) {}

  public void fileFolderCreated(FileEvent fe) {
    FileObject fo = fe.getFile();
    if (FileUtil.isParentOf(root, fo) && isVisible(root, fo)) {
      cleanEmptyKeys(fo);
      //            add( fo, false);
      findNonExcludedPackages(fo);
      refreshKeys();
    }
  }

  public void fileDataCreated(FileEvent fe) {
    FileObject fo = fe.getFile();
    if (FileUtil.isParentOf(root, fo) && isVisible(root, fo)) {
      FileObject parent = fo.getParent();
      if (!VisibilityQuery.getDefault().isVisible(parent)) {
        return; // Adding file into ignored directory
      }
      PackageNode n = get(parent);
      if (n == null && !contains(parent)) {
        add(parent, false);
        refreshKeys();
      } else if (n != null) {
        n.updateChildren();
      }
    }
  }

  public void fileDeleted(FileEvent fe) {
    FileObject fo = fe.getFile();
    if (FileUtil.isParentOf(root, fo) && isVisible(root, fo)) {
      if (fo.isFolder() || get(fo) != null) {
        removeSubTree(fo);
        // Now add the parent if necessary
        FileObject parent = fo.getParent();
        if ((FileUtil.isParentOf(root, parent) || root.equals(parent))
            && get(parent) == null
            && parent.isValid()) {
          // Candidate for adding
          if (!toBeRemoved(parent)) {
            add(parent, true);
          }
        }
        refreshKeysAsync();
      } else {
        FileObject parent = fo.getParent();
        final PackageNode n = get(parent);
        if (n != null) {
          // #61027: workaround to a deadlock when the package is being changed from non-leaf to
          // leaf:
          boolean leaf = n.isLeaf();
          DataFolder df = n.getDataFolder();
          boolean empty = n.isEmpty(df);

          if (leaf != empty) {
            SwingUtilities.invokeLater(
                new Runnable() {
                  public void run() {
                    n.updateChildren();
                  }
                });
          } else {
            n.updateChildren();
          }
        }
        // If the parent folder only contains folders remove it
        if (toBeRemoved(parent)) {
          remove(parent);
          refreshKeysAsync();
        }
      }
    }
  }

  /**
   * Returns true if the folder should be removed from the view i.e. it has some unignored children
   * and the children are folders only
   */
  private boolean toBeRemoved(FileObject folder) {
    boolean ignoredOnly = true;
    boolean foldersOnly = true;
    FileObject kids[] = folder.getChildren();
    for (int i = 0; i < kids.length; i++) {
      if (VisibilityQuery.getDefault().isVisible(kids[i])) {
        ignoredOnly = false;
        if (!kids[i].isFolder()) {
          foldersOnly = false;
          break;
        }
      }
    }
    if (ignoredOnly) {
      return false; // It is either empty or it only contains ignored files
      // thus is leaf and it means package
    } else {
      return foldersOnly;
    }
  }

  public void fileRenamed(FileRenameEvent fe) {
    FileObject fo = fe.getFile();
    if (FileUtil.isParentOf(root, fo) && fo.isFolder()) {
      String rp = FileUtil.getRelativePath(root, fo.getParent());
      String oldPath = rp + (rp.length() == 0 ? "" : "/") + fe.getName() + fe.getExt(); // NOI18N

      boolean visible = VisibilityQuery.getDefault().isVisible(fo);
      boolean doUpdate = false;

      // Find all entries which have to be updated
      ArrayList needsUpdate = new ArrayList();
      for (Iterator it = names2nodes.keySet().iterator(); it.hasNext(); ) {
        String p = (String) it.next();
        if (p.startsWith(oldPath)) {
          if (visible) {
            needsUpdate.add(p);
          } else {
            names2nodes.remove(p);
            doUpdate = true;
          }
        }
      }

      // If the node does not exists then there might have been update
      // from ignored to non ignored
      if (get(fo) == null && visible) {
        cleanEmptyKeys(fo);
        findNonExcludedPackages(fo);
        doUpdate = true; // force refresh
      }

      int oldPathLen = oldPath.length();
      String newPath = FileUtil.getRelativePath(root, fo);
      for (Iterator it = needsUpdate.iterator(); it.hasNext(); ) {
        String p = (String) it.next();
        StringBuffer np = new StringBuffer(p);
        np.replace(0, oldPathLen, newPath);
        PackageNode n = updatePath(p, np.toString()); // Replace entries in cache
        if (n != null) {
          n.updateDisplayName(); // Update nodes
        }
      }

      if (needsUpdate.size() > 1 || doUpdate) {
        // Sorting might change
        refreshKeys();
      }
    }
    /*
    else if ( FileUtil.isParentOf( root, fo ) && fo.isFolder() ) {
        FileObject parent = fo.getParent();
        PackageNode n = get( parent );
        if ( n != null && VisibilityQuery.getDefault().isVisible( parent ) ) {
            n.updateChildren();
        }

    }
    */

  }

  /** Test whether file and all it's parent up to parent paremeter are visible */
  private boolean isVisible(FileObject parent, FileObject file) {

    do {
      if (!VisibilityQuery.getDefault().isVisible(file)) {
        return false;
      }
      file = file.getParent();
    } while (file != null && file != parent);

    return true;
  }

  // Implementation of ChangeListener ------------------------------------

  public void stateChanged(ChangeEvent e) {
    computeKeys();
    refreshKeys();
  }

  /*
  private void debugKeySet() {
      for( Iterator it = names2nodes.keySet().iterator(); it.hasNext(); ) {
          String k = (String)it.next();
      }
  }
   */

  static final class PackageNode extends FilterNode {

    private static final DataFilter NO_FOLDERS_FILTER = new NoFoldersDataFilter();

    private final FileObject root;
    private DataFolder dataFolder;
    private boolean isDefaultPackage;

    private static Action actions[];

    public PackageNode(FileObject root, DataFolder dataFolder) {
      this(root, dataFolder, isEmpty(dataFolder));
    }

    public PackageNode(FileObject root, DataFolder dataFolder, boolean empty) {
      super(
          dataFolder.getNodeDelegate(),
          empty ? Children.LEAF : dataFolder.createNodeChildren(NO_FOLDERS_FILTER),
          new ProxyLookup(
              new Lookup[] {
                Lookups.singleton(new NoFoldersContainer(dataFolder)),
                dataFolder.getNodeDelegate().getLookup(),
                Lookups.singleton(
                    PackageRootNode.alwaysSearchableSearchInfo(
                        SearchInfoFactory.createSearchInfo(
                            dataFolder.getPrimaryFile(),
                            false, // not recursive
                            new FileObjectFilter[] {SearchInfoFactory.VISIBILITY_FILTER}))),
              }));
      this.root = root;
      this.dataFolder = dataFolder;
      this.isDefaultPackage = root.equals(dataFolder.getPrimaryFile());
    }

    FileObject getRoot() {
      return root; // Used from PackageRootNode
    }

    public String getName() {
      String relativePath = FileUtil.getRelativePath(root, dataFolder.getPrimaryFile());
      return relativePath == null ? null : relativePath.replace('/', '.'); // NOI18N
    }

    public Action[] getActions(boolean context) {

      if (!context) {
        if (actions == null) {
          // Copy actions and leave out the PropertiesAction and FileSystemAction.
          Action superActions[] = super.getActions(context);
          ArrayList actionList = new ArrayList(superActions.length);

          for (int i = 0; i < superActions.length; i++) {

            if (superActions[i] == null
                && superActions[i + 1] instanceof org.openide.actions.PropertiesAction) {
              i++;
              continue;
            } else if (superActions[i] instanceof org.openide.actions.PropertiesAction) {
              continue;
            }
            // This will disable the Refactor node!
            else if (superActions[i] != null
                && superActions[i]
                    .getClass()
                    .getName()
                    .equals("org.netbeans.modules.refactoring.ui.RSMJavaDOAction")) {
              continue;
            }
            //                        else if ( superActions[i] instanceof
            // org.openide.actions.FileSystemAction ) {
            //                            actionList.add (null); // insert separator and new action
            //                            actionList.add
            // (FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_COMPILE_SINGLE,
            //                                NbBundle.getMessage( PackageViewChildren.class,
            // "LBL_CompilePackage_Action" ), // NOI18N
            //                                null ));
            //                        }

            actionList.add(superActions[i]);
          }

          actions = new Action[actionList.size()];
          actionList.toArray(actions);
        }
        return actions;
      } else {
        return super.getActions(context);
      }
    }

    public boolean canRename() {

      if (isDefaultPackage) {
        return false;
      } else {
        return true;
      }
    }

    public boolean canCut() {
      return !isDefaultPackage;
    }

    /** Copy handling */
    public Transferable clipboardCopy() throws IOException {
      try {
        return new PackageTransferable(this, DnDConstants.ACTION_COPY);
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      }
    }

    public Transferable clipboardCut() throws IOException {
      try {
        return new PackageTransferable(this, DnDConstants.ACTION_MOVE);
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      }
    }

    public /*@Override*/ Transferable drag() throws IOException {
      try {
        return new PackageTransferable(this, DnDConstants.ACTION_NONE);
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      }
    }

    public PasteType[] getPasteTypes(Transferable t) {
      if (t.isDataFlavorSupported(ExTransferable.multiFlavor)) {
        try {
          MultiTransferObject mto =
              (MultiTransferObject) t.getTransferData(ExTransferable.multiFlavor);
          boolean hasPackageFlavor = false;
          for (int i = 0; i < mto.getCount(); i++) {
            DataFlavor[] flavors = mto.getTransferDataFlavors(i);
            if (isPackageFlavor(flavors)) {
              hasPackageFlavor = true;
            }
          }
          return hasPackageFlavor ? new PasteType[0] : super.getPasteTypes(t);
        } catch (UnsupportedFlavorException e) {
          ErrorManager.getDefault().notify(e);
          return new PasteType[0];
        } catch (IOException e) {
          ErrorManager.getDefault().notify(e);
          return new PasteType[0];
        }
      } else {
        DataFlavor[] flavors = t.getTransferDataFlavors();
        if (isPackageFlavor(flavors)) {
          return new PasteType[0];
        } else {
          return super.getPasteTypes(t);
        }
      }
    }

    public /*@Override*/ PasteType getDropType(Transferable t, int action, int index) {
      if (t.isDataFlavorSupported(ExTransferable.multiFlavor)) {
        try {
          MultiTransferObject mto =
              (MultiTransferObject) t.getTransferData(ExTransferable.multiFlavor);
          boolean hasPackageFlavor = false;
          for (int i = 0; i < mto.getCount(); i++) {
            DataFlavor[] flavors = mto.getTransferDataFlavors(i);
            if (isPackageFlavor(flavors)) {
              hasPackageFlavor = true;
            }
          }
          return hasPackageFlavor ? null : super.getDropType(t, action, index);
        } catch (UnsupportedFlavorException e) {
          ErrorManager.getDefault().notify(e);
          return null;
        } catch (IOException e) {
          ErrorManager.getDefault().notify(e);
          return null;
        }
      } else {
        DataFlavor[] flavors = t.getTransferDataFlavors();
        if (isPackageFlavor(flavors)) {
          return null;
        } else {
          return super.getDropType(t, action, index);
        }
      }
    }

    private boolean isPackageFlavor(DataFlavor[] flavors) {
      for (int i = 0; i < flavors.length; i++) {
        if (SUBTYPE.equals(flavors[i].getSubType())
            && PRIMARY_TYPE.equals(flavors[i].getPrimaryType())) {
          return true;
        }
      }
      return false;
    }

    private static synchronized PackageRenameHandler getRenameHandler() {
      Lookup.Result renameImplementations =
          Lookup.getDefault().lookup(new Lookup.Template(PackageRenameHandler.class));
      List handlers = (List) renameImplementations.allInstances();
      if (handlers.size() == 0) return null;
      if (handlers.size() > 1)
        ErrorManager.getDefault()
            .log(
                ErrorManager.WARNING,
                "Multiple instances of PackageRenameHandler found in Lookup; only using first one: "
                    + handlers); // NOI18N
      return (PackageRenameHandler) handlers.get(0);
    }

    public void setName(String name) {
      PackageRenameHandler handler = getRenameHandler();
      if (handler != null) {
        handler.handleRename(this, name);
        return;
      }

      if (isDefaultPackage) {
        return;
      }
      String oldName = getName();
      if (oldName.equals(name)) {
        return;
      }
      if (!isValidPackageName(name)) {
        DialogDisplayer.getDefault()
            .notify(
                new NotifyDescriptor.Message(
                    NbBundle.getMessage(PackageViewChildren.class, "MSG_InvalidPackageName"),
                    NotifyDescriptor.INFORMATION_MESSAGE));
        return;
      }
      name = name.replace('.', '/') + '/'; // NOI18N
      oldName = oldName.replace('.', '/') + '/'; // NOI18N
      int i;
      for (i = 0; i < oldName.length() && i < name.length(); i++) {
        if (oldName.charAt(i) != name.charAt(i)) {
          break;
        }
      }
      i--;
      int index = oldName.lastIndexOf('/', i); // NOI18N
      String commonPrefix = index == -1 ? null : oldName.substring(0, index);
      String toCreate = (index + 1 == name.length()) ? "" : name.substring(index + 1); // NOI18N
      try {
        FileObject commonFolder =
            commonPrefix == null ? this.root : this.root.getFileObject(commonPrefix);
        FileObject destination = commonFolder;
        StringTokenizer dtk = new StringTokenizer(toCreate, "/"); // NOI18N
        while (dtk.hasMoreTokens()) {
          String pathElement = dtk.nextToken();
          FileObject tmp = destination.getFileObject(pathElement);
          if (tmp == null) {
            tmp = destination.createFolder(pathElement);
          }
          destination = tmp;
        }
        FileObject source = this.dataFolder.getPrimaryFile();
        DataFolder sourceFolder = DataFolder.findFolder(source);
        DataFolder destinationFolder = DataFolder.findFolder(destination);
        DataObject[] children = sourceFolder.getChildren();
        for (int j = 0; j < children.length; j++) {
          if (children[j].getPrimaryFile().isData()) {
            children[j].move(destinationFolder);
          }
        }
        while (!commonFolder.equals(source)) {
          if (source.getChildren().length == 0) {
            FileObject tmp = source;
            source = source.getParent();
            tmp.delete();
          } else {
            break;
          }
        }
      } catch (IOException ioe) {
        ErrorManager.getDefault().notify(ioe);
      }
    }

    public boolean canDestroy() {
      if (isDefaultPackage) {
        return false;
      } else {
        return true;
      }
    }

    public void destroy() throws IOException {
      FileObject parent = dataFolder.getPrimaryFile().getParent();
      // First; delete all files except packages
      DataObject ch[] = dataFolder.getChildren();
      boolean empty = true;
      for (int i = 0; ch != null && i < ch.length; i++) {
        if (!ch[i].getPrimaryFile().isFolder()) {
          ch[i].delete();
        } else {
          empty = false;
        }
      }

      // If empty delete itself
      if (empty) {
        super.destroy();
      }

      // Second; delete empty super packages
      while (!parent.equals(root) && parent.getChildren().length == 0) {
        FileObject newParent = parent.getParent();
        parent.delete();
        parent = newParent;
      }
    }

    /**
     * Initially overridden to support CVS status labels in package nodes.
     *
     * @return annotated display name
     */
    public String getHtmlDisplayName() {
      String name = getDisplayName();
      try {
        FileObject fo = dataFolder.getPrimaryFile();
        Set set = new NonResursiveFolderSet(fo);
        org.openide.filesystems.FileSystem.Status status = fo.getFileSystem().getStatus();
        if (status instanceof org.openide.filesystems.FileSystem.HtmlStatus) {
          name =
              ((org.openide.filesystems.FileSystem.HtmlStatus) status).annotateNameHtml(name, set);
        } else {
          name = status.annotateName(name, set);
        }
      } catch (FileStateInvalidException e) {
        // no fs, do nothing
      }
      return name;
    }

    public String getDisplayName() {
      FileObject folder = dataFolder.getPrimaryFile();
      String path = FileUtil.getRelativePath(root, folder);
      if (path == null) {
        // ???
        return "";
      }
      return PackageDisplayUtils.getDisplayLabel(path.replace('/', '.'));
    }

    public String getShortDescription() {
      FileObject folder = dataFolder.getPrimaryFile();
      String path = FileUtil.getRelativePath(root, folder);
      if (path == null) {
        // ???
        return "";
      }
      return PackageDisplayUtils.getToolTip(folder, path.replace('/', '.'));
    }

    public java.awt.Image getIcon(int type) {
      java.awt.Image img = getMyIcon(type);

      try {
        FileObject fo = dataFolder.getPrimaryFile();
        Set set = new NonResursiveFolderSet(fo);
        img = fo.getFileSystem().getStatus().annotateIcon(img, type, set);
      } catch (FileStateInvalidException e) {
        // no fs, do nothing
      }

      return img;
    }

    public java.awt.Image getOpenedIcon(int type) {
      java.awt.Image img = getMyOpenedIcon(type);

      try {
        FileObject fo = dataFolder.getPrimaryFile();
        Set set = new NonResursiveFolderSet(fo);
        img = fo.getFileSystem().getStatus().annotateIcon(img, type, set);
      } catch (FileStateInvalidException e) {
        // no fs, do nothing
      }

      return img;
    }

    private Image getMyIcon(int type) {
      FileObject folder = dataFolder.getPrimaryFile();
      String path = FileUtil.getRelativePath(root, folder);
      if (path == null) {
        // ???
        return null;
      }
      return PackageDisplayUtils.getIcon(folder, path.replace('/', '.'), isLeaf());
    }

    private Image getMyOpenedIcon(int type) {
      return getIcon(type);
    }

    public void update() {
      fireIconChange();
      fireOpenedIconChange();
    }

    public void updateDisplayName() {
      //  fireNameChange(null, null);
      //   fireDisplayNameChange(null, null);
      //   fireShortDescriptionChange(null, null);
    }

    public void updateChildren() {
      boolean leaf = isLeaf();
      DataFolder df = getDataFolder();
      boolean empty = isEmpty(df);
      if (leaf != empty) {
        setChildren(empty ? Children.LEAF : df.createNodeChildren(NO_FOLDERS_FILTER));
        update();
      }
    }

    public /*@Override*/ Node.PropertySet[] getPropertySets() {
      Node.PropertySet[] properties = super.getPropertySets();
      for (int i = 0; i < properties.length; i++) {
        if (Sheet.PROPERTIES.equals(properties[i].getName())) {
          // Replace the Sheet.PROPERTIES by the new one
          // having only the name property which does refactoring
          properties[i] = Sheet.createPropertiesSet();
          ((Sheet.Set) properties[i])
              .put(
                  new PropertySupport.ReadWrite(
                      DataObject.PROP_NAME,
                      String.class,
                      NbBundle.getMessage(PackageViewChildren.class, "PROP_name"),
                      NbBundle.getMessage(PackageViewChildren.class, "HINT_name")) {

                    public /*@Override*/ Object getValue() {
                      return PackageViewChildren.PackageNode.this.getName();
                    }

                    public /*@Override*/ void setValue(Object val)
                        throws IllegalAccessException, IllegalArgumentException,
                            InvocationTargetException {
                      if (!canRename()) throw new IllegalAccessException();
                      if (!(val instanceof String)) throw new IllegalArgumentException();
                      PackageViewChildren.PackageNode.this.setName((String) val);
                    }

                    public /*@Override*/ boolean canWrite() {
                      return PackageViewChildren.PackageNode.this.canRename();
                    }
                  });
        }
      }
      return properties;
    }

    private DataFolder getDataFolder() {
      return (DataFolder) getCookie(DataFolder.class);
    }

    private static boolean isEmpty(DataFolder dataFolder) {
      if (dataFolder == null) {
        return true;
      }
      return PackageDisplayUtils.isEmpty(dataFolder.getPrimaryFile());
    }

    private static boolean isValidPackageName(String name) {
      if (name.length() == 0) {
        // Fast check of default pkg
        return true;
      }
      StringTokenizer tk = new StringTokenizer(name, ".", true); // NOI18N
      boolean delimExpected = false;
      while (tk.hasMoreTokens()) {
        String namePart = tk.nextToken();
        if (!delimExpected) {
          if (namePart.equals(".")) { // NOI18N
            return false;
          }
          for (int i = 0; i < namePart.length(); i++) {
            char c = namePart.charAt(i);
            if (i == 0) {
              if (!Character.isJavaIdentifierStart(c)) {
                return false;
              }
            } else {
              if (!Character.isJavaIdentifierPart(c)) {
                return false;
              }
            }
          }
        } else {
          if (!namePart.equals(".")) { // NOI18N
            return false;
          }
        }
        delimExpected = !delimExpected;
      }
      return delimExpected;
    }
  }

  private static final class NoFoldersContainer
      implements DataObject.Container, java.beans.PropertyChangeListener, NonRecursiveFolder {
    private DataFolder folder;
    private PropertyChangeSupport prop = new PropertyChangeSupport(this);

    public NoFoldersContainer(DataFolder folder) {
      this.folder = folder;
    }

    public FileObject getFolder() {
      return folder.getPrimaryFile();
    }

    public DataObject[] getChildren() {
      DataObject[] arr = folder.getChildren();
      ArrayList list = new ArrayList(arr.length);
      for (int i = 0; i < arr.length; i++) {
        if (arr[i] instanceof DataFolder) continue;

        list.add(arr[i]);
      }
      return list.size() == arr.length ? arr : (DataObject[]) list.toArray(new DataObject[0]);
    }

    public void addPropertyChangeListener(java.beans.PropertyChangeListener l) {
      prop.addPropertyChangeListener(l);
    }

    public void removePropertyChangeListener(java.beans.PropertyChangeListener l) {
      prop.removePropertyChangeListener(l);
    }

    public void propertyChange(java.beans.PropertyChangeEvent evt) {
      if (DataObject.Container.PROP_CHILDREN.equals(evt.getPropertyName())) {
        prop.firePropertyChange(PROP_CHILDREN, null, null);
      }
    }
  }

  static final class NoFoldersDataFilter implements ChangeListener, ChangeableDataFilter {

    EventListenerList ell = new EventListenerList();

    public NoFoldersDataFilter() {
      VisibilityQuery.getDefault().addChangeListener(this);
    }

    public boolean acceptDataObject(DataObject obj) {
      FileObject fo = obj.getPrimaryFile();
      return VisibilityQuery.getDefault().isVisible(fo) && !(obj instanceof DataFolder);
    }

    public void stateChanged(ChangeEvent e) {
      Object[] listeners = ell.getListenerList();
      ChangeEvent event = null;
      for (int i = listeners.length - 2; i >= 0; i -= 2) {
        if (listeners[i] == ChangeListener.class) {
          if (event == null) {
            event = new ChangeEvent(this);
          }
          ((ChangeListener) listeners[i + 1]).stateChanged(event);
        }
      }
    }

    public void addChangeListener(ChangeListener listener) {
      ell.add(ChangeListener.class, listener);
    }

    public void removeChangeListener(ChangeListener listener) {
      ell.remove(ChangeListener.class, listener);
    }
  }

  static class PackageTransferable extends ExTransferable.Single {

    private PackageNode node;

    public PackageTransferable(PackageNode node, int operation) throws ClassNotFoundException {
      super(
          new DataFlavor(
              PACKAGE_FLAVOR.format(new Object[] {new Integer(operation)}),
              null,
              PackageNode.class.getClassLoader()));
      this.node = node;
    }

    protected Object getData() throws IOException, UnsupportedFlavorException {
      return this.node;
    }
  }

  static class PackagePasteType extends PasteType {

    private int op;
    private PackageNode[] nodes;
    private FileObject srcRoot;

    public PackagePasteType(FileObject srcRoot, PackageNode[] node, int op) {
      assert op == DnDConstants.ACTION_COPY
              || op == DnDConstants.ACTION_MOVE
              || op == DnDConstants.ACTION_NONE
          : "Invalid DnD operation"; // NOI18N
      this.nodes = node;
      this.op = op;
      this.srcRoot = srcRoot;
    }

    public void setOperation(int op) {
      this.op = op;
    }

    public Transferable paste() throws IOException {
      assert this.op != DnDConstants.ACTION_NONE;
      for (int ni = 0; ni < nodes.length; ni++) {
        FileObject fo = srcRoot;
        if (!nodes[ni].isDefaultPackage) {
          String pkgName = nodes[ni].getName();
          StringTokenizer tk = new StringTokenizer(pkgName, "."); // NOI18N
          while (tk.hasMoreTokens()) {
            String name = tk.nextToken();
            FileObject tmp = fo.getFileObject(name, null);
            if (tmp == null) {
              tmp = fo.createFolder(name);
            }
            fo = tmp;
          }
        }
        DataFolder dest = DataFolder.findFolder(fo);
        DataObject[] children = nodes[ni].dataFolder.getChildren();
        boolean cantDelete = false;
        for (int i = 0; i < children.length; i++) {
          if (children[i].getPrimaryFile().isData()
              && VisibilityQuery.getDefault().isVisible(children[i].getPrimaryFile())) {
            // Copy only the package level
            children[i].copy(dest);
            if (this.op == DnDConstants.ACTION_MOVE) {
              try {
                children[i].delete();
              } catch (IOException ioe) {
                cantDelete = true;
              }
            }
          } else {
            cantDelete = true;
          }
        }
        if (this.op == DnDConstants.ACTION_MOVE && !cantDelete) {
          try {
            FileObject tmpFo = nodes[ni].dataFolder.getPrimaryFile();
            FileObject originalRoot = nodes[ni].root;
            assert tmpFo != null && originalRoot != null;
            while (!tmpFo.equals(originalRoot)) {
              if (tmpFo.getChildren().length == 0) {
                FileObject tmpFoParent = tmpFo.getParent();
                tmpFo.delete();
                tmpFo = tmpFoParent;
              } else {
                break;
              }
            }
          } catch (IOException ioe) {
            // Not important
          }
        }
      }
      return ExTransferable.EMPTY;
    }

    public String getName() {
      return NbBundle.getMessage(PackageViewChildren.class, "TXT_PastePackage");
    }
  }

  /**
   * FileObject set that represents package. It means that it's content must not be processed
   * recursively.
   */
  private static class NonResursiveFolderSet extends HashSet implements NonRecursiveFolder {

    private final FileObject folder;

    /** Creates set with one element, the folder. */
    public NonResursiveFolderSet(FileObject folder) {
      this.folder = folder;
      add(folder);
    }

    public FileObject getFolder() {
      return folder;
    }
  }
}
  public void initValues(
      final Project project, final FileObject template, final FileObject preselectedFolder) {
    this.project = project;
    this.helper = project.getLookup().lookup(AntProjectHelper.class);
    final Object obj = template.getAttribute(IS_MIDLET_TEMPLATE_ATTRIBUTE);
    isMIDlet = false;
    if (obj instanceof Boolean) isMIDlet = ((Boolean) obj).booleanValue();

    projectTextField.setText(ProjectUtils.getInformation(project).getDisplayName());

    final Sources sources = ProjectUtils.getSources(project);
    final SourceGroup[] groups = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    final SourceGroup preselectedGroup = getPreselectedGroup(groups, preselectedFolder);
    if (preselectedGroup != null) {
      final ModelItem groupItem = new ModelItem(preselectedGroup);
      final ModelItem[] nodes = groupItem.getChildren();
      packageComboBox.setModel(new DefaultComboBoxModel(nodes));
      final Object folderItem = getPreselectedPackage(groupItem, preselectedFolder);
      if (folderItem != null) packageComboBox.setSelectedItem(folderItem);
    } else {
      packageComboBox.setModel(new DefaultComboBoxModel());
    }

    // Determine the extension
    final String ext = template == null ? "" : template.getExt(); // NOI18N
    expectedExtension = ext.length() == 0 ? "" : "." + ext; // NOI18N

    lName.setVisible(isMIDlet);
    tName.setVisible(isMIDlet);
    lIcon.setVisible(isMIDlet);
    cIcon.setVisible(isMIDlet);
    lNote.setVisible(isMIDlet);
    org.openide.awt.Mnemonics.setLocalizedText(
        lClassName,
        NbBundle.getMessage(
            MIDPTargetChooserPanelGUI.class,
            isMIDlet ? "LBL_File_MIDletClassName" : "LBL_File_MIDPClassName")); // NOI18N

    // Show name of the project
    if (isMIDlet) {
      tName.getDocument().removeDocumentListener(this);
      tName.setText(template.getName());
      updateClassNameAndIcon();
      if (testIfFileNameExists(preselectedGroup) && updateClassName) {
        String name = tName.getText();
        int i = 1;
        for (; ; ) {
          tName.setText(name + "_" + i); // NOI18N
          updateClassNameAndIcon();
          if (!testIfFileNameExists(preselectedGroup) || !updateClassName) break;
          i++;
        }
      }
      tName.getDocument().addDocumentListener(this);
    } else {
      tClassName.setText(template.getName());
      if (testIfFileNameExists(preselectedGroup)) {
        String name = tClassName.getText();
        int i = 1;
        for (; ; ) {
          tClassName.setText(name + "_" + i); // NOI18N
          if (!testIfFileNameExists(preselectedGroup)) break;
          i++;
        }
      }
      tClassName.getDocument().addDocumentListener(this);
    }
    updateText();

    // Find all icons
    if (loadIcons) {
      loadIcons = false;
      final DefaultComboBoxModel icons = new DefaultComboBoxModel();
      cIcon.setModel(icons);
      cIcon.setSelectedItem(""); // NOI18N
      RequestProcessor.getDefault()
          .post(
              new Runnable() {
                public void run() {
                  final ArrayList<FileObject> roots = new ArrayList<FileObject>();
                  roots.add(
                      helper.resolveFileObject(
                          helper.getStandardPropertyEvaluator().getProperty("src.dir"))); // NOI18N
                  final String libs =
                      J2MEProjectUtils.evaluateProperty(
                          helper, DefaultPropertiesDescriptor.LIBS_CLASSPATH);
                  if (libs != null) {
                    final String elements[] = PropertyUtils.tokenizePath(helper.resolvePath(libs));
                    for (int i = 0; i < elements.length; i++)
                      try {
                        final FileObject root =
                            FileUtil.toFileObject(FileUtil.normalizeFile(new File(elements[i])));
                        if (root != null)
                          roots.add(
                              FileUtil.isArchiveFile(root) ? FileUtil.getArchiveRoot(root) : root);
                      } catch (Exception e) {
                      }
                  }
                  for (FileObject root : roots) {
                    if (root != null) {
                      final int rootLength = root.getPath().length();
                      final Enumeration en = root.getChildren(true);
                      while (en.hasMoreElements()) {
                        final FileObject fo = (FileObject) en.nextElement();
                        if (fo.isData()) {
                          final String ext = fo.getExt().toLowerCase();
                          if ("png".equals(ext)) { // NOI18N
                            String name = fo.getPath().substring(rootLength);
                            if (!name.startsWith("/")) name = "/" + name; // NOI18N
                            if (icons.getIndexOf(name) < 0) icons.addElement(name);
                          }
                        }
                      }
                    }
                  }
                }
              });
    }
  }
Exemplo n.º 14
0
  @Override
  public void actionPerformed(ActionEvent e) {
    JFileChooser fc = new JFileChooser();
    fc.setFileFilter(ImportAction.getFileFilter());
    fc.setCurrentDirectory(
        new File(Settings.get().get(Settings.DIRECTORY, Settings.DIRECTORY_DEFAULT)));
    fc.setMultiSelectionEnabled(true);

    if (fc.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
      for (final File file : fc.getSelectedFiles()) {
        File dir = file;
        if (!dir.isDirectory()) {
          dir = dir.getParentFile();
        }

        Settings.get().put(Settings.DIRECTORY, dir.getAbsolutePath());
        try {
          final FileChannel channel = FileChannel.open(file.toPath(), StandardOpenOption.READ);
          final ProgressHandle handle =
              ProgressHandleFactory.createHandle("Opening file " + file.getName());
          handle.start(WORKUNITS);
          final long startTime = System.currentTimeMillis();
          final long start = channel.size();
          ParseMonitor monitor =
              new ParseMonitor() {
                @Override
                public void updateProgress() {
                  try {
                    int prog = (int) (WORKUNITS * (double) channel.position() / (double) start);
                    handle.progress(prog);
                  } catch (IOException ex) {
                  }
                }

                @Override
                public void setState(String state) {
                  updateProgress();
                  handle.progress(state);
                }
              };
          final GraphParser parser;
          final OutlineTopComponent component = OutlineTopComponent.findInstance();
          if (file.getName().endsWith(".xml")) {
            parser = new Parser(channel, monitor, null);
          } else if (file.getName().endsWith(".bgv")) {
            parser = new BinaryParser(channel, monitor, component.getDocument(), null);
          } else {
            parser = null;
          }
          RequestProcessor.getDefault()
              .post(
                  new Runnable() {
                    @Override
                    public void run() {
                      try {
                        final GraphDocument document = parser.parse();
                        if (document != null) {
                          SwingUtilities.invokeLater(
                              new Runnable() {
                                @Override
                                public void run() {
                                  component.requestActive();
                                  component.getDocument().addGraphDocument(document);
                                }
                              });
                        }
                      } catch (IOException ex) {
                        Exceptions.printStackTrace(ex);
                      }
                      handle.finish();
                      long stop = System.currentTimeMillis();
                      Logger.getLogger(getClass().getName())
                          .log(
                              Level.INFO,
                              "Loaded in "
                                  + file
                                  + " in "
                                  + ((stop - startTime) / 1000.0)
                                  + " seconds");
                    }
                  });
        } catch (FileNotFoundException ex) {
          Exceptions.printStackTrace(ex);
        } catch (IOException ex) {
          Exceptions.printStackTrace(ex);
        }
      }
    }
  }
Exemplo n.º 15
0
  public void actionPerformed(ActionEvent e) {
    final JButton source = (e.getSource() instanceof JButton) ? (JButton) e.getSource() : null;
    final TopComponent mainWindow =
        WindowManager.getDefault().findTopComponent("KenaiTopComponent"); // NOI18N
    mainWindow.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
    final ProgressHandle progress =
        ProgressHandleFactory.createHandle(
            NbBundle.getMessage(CreateChatAction.class, "LBL_CheckPermissions"));
    progress.setInitialDelay(0);
    progress.start();
    if (source != null) source.setEnabled(true);
    RequestProcessor.getDefault()
        .post(
            new Runnable() {

              public void run() {
                try {
                  if (!project.getKenai().isAuthorized(project, KenaiActivity.PROJECTS_ADMIN)) {
                    SwingUtilities.invokeLater(
                        new Runnable() {

                          public void run() {
                            progress.finish();
                            JOptionPane.showMessageDialog(
                                null,
                                NbBundle.getMessage(
                                    CreateChatAction.class,
                                    "CTL_NotAuthorizedToCreateChat",
                                    getValue(NAME)));
                            mainWindow.setCursor(Cursor.getDefaultCursor());
                            if (source != null) source.setEnabled(true);
                          }
                        });
                    return;
                  }
                } catch (KenaiException ex) {
                  Exceptions.printStackTrace(ex);
                }

                SwingUtilities.invokeLater(
                    new Runnable() {

                      public void run() {
                        int value =
                            JOptionPane.showOptionDialog(
                                null,
                                NbBundle.getMessage(
                                    CreateChatAction.class, "LBL_CreateChatQuestions"),
                                NbBundle.getMessage(CreateChatAction.class, "LBL_CreateChatTitle"),
                                JOptionPane.YES_NO_OPTION,
                                JOptionPane.QUESTION_MESSAGE,
                                null,
                                null,
                                null);
                        if (value == JOptionPane.YES_OPTION) {
                          progress.setDisplayName(
                              NbBundle.getMessage(
                                  CreateChatAction.class, "CTL_CreatingChatProgress"));
                          RequestProcessor.getDefault()
                              .post(
                                  new Runnable() {

                                    public void run() {
                                      try {
                                        final KenaiFeature f =
                                            project.createProjectFeature(
                                                project.getName(),
                                                NbBundle.getMessage(
                                                    CreateChatAction.class,
                                                    "CTL_ChatRoomName",
                                                    project.getName()),
                                                NbBundle.getMessage(
                                                    CreateChatAction.class,
                                                    "CTL_ChatRoomDescription",
                                                    project.getName()),
                                                KenaiService.Names.XMPP_CHAT,
                                                null,
                                                null,
                                                null);

                                        SwingUtilities.invokeLater(
                                            new Runnable() {

                                              public void run() {
                                                final ChatTopComponent chatTc =
                                                    ChatTopComponent.findInstance();
                                                chatTc.open();
                                                chatTc.addChat(
                                                    new ChatPanel(
                                                        KenaiConnection.getDefault(
                                                                project.getKenai())
                                                            .getChat(f)));
                                                mainWindow.setCursor(Cursor.getDefaultCursor());
                                                progress.finish();
                                                if (source != null) source.setEnabled(true);
                                                chatTc.requestActive();
                                              }
                                            });
                                      } catch (KenaiException kenaiException) {
                                        Exceptions.printStackTrace(kenaiException);
                                        mainWindow.setCursor(Cursor.getDefaultCursor());
                                        progress.finish();
                                        if (source != null) source.setEnabled(true);
                                      }
                                    }
                                  });

                        } else {
                          mainWindow.setCursor(Cursor.getDefaultCursor());
                          progress.finish();
                          if (source != null) source.setEnabled(true);
                        }
                      }
                    });
              }
            });
  }
Exemplo n.º 16
0
  private void refreshSetups() {
    if (dpt != null) {
      prepareTask.cancel();
    }

    File[] files;
    switch (currentType) {
      case Setup.DIFFTYPE_LOCAL:
        displayStatuses = StatusInfo.STATUS_LOCAL_CHANGE;
        break;
      case Setup.DIFFTYPE_REMOTE:
        displayStatuses = StatusInfo.STATUS_REMOTE_CHANGE;
        break;
      case Setup.DIFFTYPE_ALL:
        displayStatuses = StatusInfo.STATUS_LOCAL_CHANGE | StatusInfo.STATUS_REMOTE_CHANGE;
        break;
      default:
        throw new IllegalStateException("Unknown DIFF type:" + currentType); // NOI18N
    }
    files = GitUtils.getModifiedFiles(context, displayStatuses);

    setups = computeSetups(files);
    boolean propertyColumnVisible = false;
    for (Setup setup : setups) {
      if (setup.getPropertyName() != null) {
        propertyColumnVisible = true;
        break;
      }
    }
    fileTable.setColumns(
        propertyColumnVisible
            ? new String[] {
              DiffNode.COLUMN_NAME_NAME,
              DiffNode.COLUMN_NAME_PROPERTY,
              DiffNode.COLUMN_NAME_STATUS,
              DiffNode.COLUMN_NAME_LOCATION
            }
            : new String[] {
              DiffNode.COLUMN_NAME_NAME, DiffNode.COLUMN_NAME_STATUS, DiffNode.COLUMN_NAME_LOCATION
            });
    fileTable.setTableModel(setupToNodes(setups));

    if (setups.length == 0) {
      String noContentLabel;
      switch (currentType) {
        case Setup.DIFFTYPE_LOCAL:
          noContentLabel =
              NbBundle.getMessage(MultiDiffPanel.class, "MSG_DiffPanel_NoLocalChanges");
          break;
        case Setup.DIFFTYPE_REMOTE:
          noContentLabel =
              NbBundle.getMessage(MultiDiffPanel.class, "MSG_DiffPanel_NoRemoteChanges");
          break;
        case Setup.DIFFTYPE_ALL:
          noContentLabel = NbBundle.getMessage(MultiDiffPanel.class, "MSG_DiffPanel_NoAllChanges");
          break;
        default:
          throw new IllegalStateException("Unknown DIFF type:" + currentType); // NOI18N
      }
      setups = null;
      fileTable.setTableModel(new Node[0]);
      fileTable.getComponent().setEnabled(false);
      fileTable.getComponent().setPreferredSize(null);
      Dimension dim = fileTable.getComponent().getPreferredSize();
      fileTable.getComponent().setPreferredSize(new Dimension(dim.width + 1, dim.height));
      diffView = null;
      diffView = new NoContentPanel(noContentLabel);
      setBottomComponent();
      nextAction.setEnabled(false);
      prevAction.setEnabled(false);
      revalidate();
      repaint();
    } else {
      fileTable.getComponent().setEnabled(true);
      fileTable.getComponent().setPreferredSize(null);
      Dimension dim = fileTable.getComponent().getPreferredSize();
      fileTable.getComponent().setPreferredSize(new Dimension(dim.width + 1, dim.height));
      setDiffIndex(0, 0);
      dpt = new DiffPrepareTask(setups);
      prepareTask = RequestProcessor.getDefault().post(dpt);
    }
  }
Exemplo n.º 17
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;
    }
  }
 public Task analyzePatterns() {
   checkState(0);
   task = RequestProcessor.getDefault().post(this);
   return task;
 }