import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void init(Lookup mimeLookup) {
    Collection<? extends FoldType> types = 
            new ArrayList<FoldType>((FoldUtilities.getFoldTypes(mime).values()));
    
    result = mimeLookup.lookupResult(ContentReader.Factory.class);
    Collection<? extends ContentReader.Factory> factories = result.allInstances();

    List<ContentReader> l;
    for (FoldType ft : types) {
        l = null;
        for (ContentReader.Factory f : factories) {
            ContentReader cr = f.createReader(ft);
            if (cr != null) {
                if (l == null) {
                    l = new ArrayList<ContentReader>(3);
                }
                l.add(cr);
            }
        }
        if (l != null) {
            readers.put(ft, l);
        }
    }
    result.addLookupListener(this);
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
public List<ContentReader> getReaders(String mime, FoldType ft) {
    N node;
    synchronized (mimeNodes) {
        node = mimeNodes.get(mime);
    }
    if (node == null) {
        node = mimeNodes.get(mime);
        if (node == null) {
            node = new N(mime, MimeLookup.getLookup(mime));
            synchronized (mimeNodes) {
                N n2 = mimeNodes.get(mime);
                if (n2 == null) {
                    mimeNodes.put(mime, node);
                } else {
                    node = n2;
                }
            }
        }
    }
    return node.readers(ft);
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
/**
 * Creates new form DefaultFoldingOptions
 */
public DefaultFoldingOptions(String mime, Preferences preferences) {
    initComponents();
	 
    VerticalFlowLayout vfl = new VerticalFlowLayout();
    localSwitchboard.setLayout(vfl);
    
    vfl = new VerticalFlowLayout();
    localSwitchboard.setLayout(vfl);

    this.mimeType = mime;
    this.preferences = preferences;
    
    String parentMime = MimePath.parse(mime).getInheritedType();
    if (parentMime != null) {
        parentFoldTypes = new HashSet<String>(13);
        for (FoldType ft : FoldUtilities.getFoldTypes(parentMime).values()) {
            parentFoldTypes.add(ft.code());
        }
    } else {
        parentFoldTypes = Collections.emptyList();
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private String updateCheckers(PreferenceChangeEvent evt) {
    String pk = evt.getKey();
    if (pk != null) {
        if (pk.equals(SimpleValueNames.CODE_FOLDING_ENABLE)) {
            updateEnabledState();
            return pk;
        }
        if (pk.equals(PREF_OVERRIDE_DEFAULTS)) {
            updateOverrideChanged();
        } else if (!pk.startsWith(COLLAPSE_PREFIX)) {
            return pk;
        }
    } else {
        updateEnabledState();
    }
    String c = pk == null ? null : pk.substring(COLLAPSE_PREFIX.length());
    for (JCheckBox cb : controls) {
        FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
        FoldType ftp = ft.parent();
        if (c == null || ft.code().equals(c) || (ftp != null && ftp.code().equals(c))) {
            updateChecker(pk, cb, ft);
            return pk;
        }
    }
    return pk;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void updatePref(ItemEvent e) {
    JCheckBox cb = (JCheckBox)e.getSource();
    FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
    
    String prefKey = COLLAPSE_PREFIX + ft.code();
    lastChangedCB = cb;
    LOG.log(Level.FINE, "Updating preference: " + prefKey + ", value = " + cb.isSelected()); // NOI18N
    preferences.putBoolean(prefKey, cb.isSelected());
    
    if (!"".equals(mimeType)) {
        return;
    }
    // legacy setting support in transient prefs:
    String propagate = FoldOptionsController.LEGACY_SETTINGS_MAP.get(ft.code());
    if (propagate != null) {
        prefKey = COLLAPSE_PREFIX + propagate;
        LOG.log(Level.FINE, "Updating LEGACY preference: " + prefKey + ", value = " + cb.isSelected()); // NOI18N
        preferences.putBoolean(prefKey, cb.isSelected());
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void scan(final ParserResult info,
    final Collection<FoldInfo> folds, final Document doc, final
    StructureScanner scanner) {
    
    // #217322, disabled folding -> no folds will be created
    String mime = info.getSnapshot().getMimeType();
    
    if (!FoldUtilities.isFoldingEnabled(mime)) {
        LOG.log(Level.FINER, "Folding is not enabled for MIME: {0}", mime);
        return;
    }
    final Map<String,List<OffsetRange>> collectedFolds = scanner.folds(info);
    final Collection<? extends FoldType> ftypes = FoldUtilities.getFoldTypes(mime).values();
    doc.render(new Runnable() {
        @Override
        public void run() {
            addTree(folds, info, collectedFolds, ftypes);
        }
    });
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private boolean addFoldsOfType(
            String type, Map<String,List<OffsetRange>> folds,
            Collection<FoldInfo> result,
            FoldType foldType) {
    
    List<OffsetRange> ranges = folds.get(type); //NOI18N
    if (ranges != null) {
        if (LOG.isLoggable(Level.FINEST)) {
            LOG.log(Level.FINEST, "Creating folds {0}", new Object[] {
                type
            });
        }
        for (OffsetRange range : ranges) {
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.log(Level.FINEST, "Fold: {0}", range);
            }
            addFold(range, result, foldType);
        }
        folds.remove(type);
        return true;
    } else {
        LOG.log(Level.FINEST, "No folds of type {0}", type);
        return false;
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void addFold(OffsetRange range, Collection<FoldInfo> folds, FoldType type) {
    if (range != OffsetRange.NONE) {
        int start = range.getStart();
        int end = range.getEnd();
        // the readlock will be interrupted before FoldInfos are committed to fold hierarchy,
        // so we don't need to check against doc length here. FoldOp.update checks+ignores under read lock.
        if (start != (-1) && end != (-1)) {
            FoldInfo fi = FoldInfo.range(start, end, type);
            // hack for singular imports fold
            if (fi.getType() == IMPORTS_FOLD_TYPE && imports == null) {
                imports = fi;
            }
            folds.add(fi);
        }
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
/**
 * Creates a new fold and adds to the fold hierarchy.
 */
private Fold createFold(FoldType type, String description, boolean collapsed,
        int startOffset, int endOffset, FoldHierarchyTransaction transaction)
            throws BadLocationException {
    Fold fold = null;
    if ( startOffset >= 0 &&
         endOffset >= 0 &&
         startOffset < endOffset &&
         endOffset <= getDocument().getLength() ) {
        fold = getOperation().addToHierarchy(
                type,
                description.intern(), //save some memory
                collapsed,
                startOffset,
                endOffset,
                description.length(),
                0,
                null,
                transaction);
    }
    return fold;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void cleanupPreferences(String mime, Preferences pref) {
    Collection<? extends FoldType> types = FoldUtilities.getFoldTypes(mime).values();
    String parent = MimePath.parse(mime).getInheritedType();
    if (parent == null) {
        return;
    }
    if (types.isEmpty()) {
        // legacy language, do not erase its settings
        return;
    }
    Preferences pprefs = MimeLookup.getLookup(parent).lookup(Preferences.class);
    for (FoldType ft : types) {
        String key = FoldUtilitiesImpl.PREF_COLLAPSE_PREFIX + ft.code();
        if (isDefinedLocally(pref, key)) {
            if (pprefs.get(key, null) != null) {
                pref.remove(key);
            }
        }
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private Map<String, FoldType> map() {
    Map<String, FoldType> m;
    
    m = valueMap;
    if (m == null) {
        synchronized (this) {
            if (valueMap != null) {
                return valueMap;
            }
            Set<FoldType> vals = enums;
            m = new LinkedHashMap<String, FoldType>();
            for (FoldType e : vals) {
                FoldType old = m.put(e.code(), e);
                if (old != null) {
                    throw new IllegalArgumentException("Two fold types share the same code: " + old + " and " + e);
                }
            }
            this.valueMap = m;
        }
    }
    return m;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private FoldInfo(int start, int end, FoldType ft) {
    Parameters.notNull("ft", ft);
    if (start < 0) {
        throw new IllegalArgumentException("Invalid start offet: " + start);
    }
    if (end < start) {
        throw new IllegalArgumentException("Invalid end offset: " + end + ", start is: " + start);
    }
    this.type = ft;
    this.start = start;
    this.end = end;
    this.template = ft.getTemplate();
    /*
    if ((end - start) < (template.getGuardedStart() + template.getGuardedEnd())) {
        throw new IllegalArgumentException("Invalid fold length: (endOffset=" + end // NOI18N
            + " - startOffset=" + start + ") < " // NOI18N
            + "(startGuardedLength=" + template.getGuardedStart() // NOI18N
            + " + endGuardedLength=" + template.getGuardedEnd() + ")"); // NOI18N
    }
    */
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void addFold(FoldType type, int start, int stop, FoldHierarchyTransaction fht, Object extraInfo) 
        throws BadLocationException {
    Iterator<Fold> it = operation.foldIterator();
    while (it.hasNext()) {
        Fold f = it.next();
        // don't replace existing folds unless they've changed
        if (f.getStartOffset() == start && f.getEndOffset() == stop &&
                f.getType() == type) {
            //logger.info("Fold wasn't changed, skipping add...");
            return;
        }
        // remove if old fold was changed
        if (f.getStartOffset() >= start && f.getStartOffset() <= stop) {
            operation.removeFromHierarchy(f, fht);
        }
    }
    operation.addToHierarchy(type, start, stop, false, null, null, extraInfo, fht);
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void load() {
    types = new ArrayList<FoldType>(FoldUtilities.getFoldTypes(mimeType).values());
    if ("".equals(mimeType)) { // NOI18N
        filterUsedMimeTypes();
    }

    boolean override = isCollapseRedefined();
    boolean currentOverride = 
            isDefinedLocally(PREF_OVERRIDE_DEFAULTS) ? !preferences.getBoolean(PREF_OVERRIDE_DEFAULTS, true) : false;
    if (override != currentOverride) {
        updateOverrideChanged();
    }
    
    for (FoldType ft : types) {
        String name = ft.getLabel();
        
        JCheckBox cb = createCheckBox(ft);
        cb.setText(name);
        cb.putClientProperty("id", ft.code()); // NOI18N
        cb.putClientProperty("type", ft); // NOI18N
        localSwitchboard.add(cb);
        controls.add(cb);
        cb.addItemListener(this);
    }
    
    // watch out for preferences
    this.preferences.addPreferenceChangeListener(this);
    updateEnabledState();
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
/**
 * Checks whether some of the collapse- options is redefined for this MIME type.
 * If so, the checkbox will be selected even though the override option is not
 * present.
 * 
 * @return 
 */
private boolean isCollapseRedefined() {
    for (FoldType ft : types) {
        String pref = k(ft);
        if (((OverridePreferences)preferences).isOverriden(pref)) {
           if (defaultPrefs == null || 
                (parentFoldTypes.contains(ft.code()) || (ft.parent() != null && parentFoldTypes.contains(ft.parent().code())))) {
                return true;
           }
        }
    }
    return false;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void updateValueState() {
    ignoreStateChange = true;
    for (JCheckBox cb : controls) {
        FoldType ft = (FoldType)cb.getClientProperty("type"); // NOI18N
        String k = COLLAPSE_PREFIX + ft.code();
        boolean val = isCollapseEnabled(ft);
        cb.setSelected(val);
    }
    ignoreStateChange = false;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void updateEnabledState() {
    boolean foldEnable = preferences.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, true);
    boolean useDefaults = preferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true);
    
    for (JComponent c : controls) {
        FoldType ft = (FoldType)c.getClientProperty("type"); // NOI18N
        boolean enable = true;
        if (defaultPrefs != null && useDefaults) {
            enable = !isDefinedDefault(ft);
        }
        enable &= foldEnable;
        c.setEnabled(enable);
    }
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void fireChanged(String pk) {
    if (pk == null) {
        isChanged = false;
        return;
    }
    Preferences prefs = MimeLookup.getLookup(mimeType).lookup(Preferences.class);
    boolean changed = preferences.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, true) != prefs.getBoolean(SimpleValueNames.CODE_FOLDING_ENABLE, true)
            || preferences.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true) != prefs.getBoolean(FoldUtilitiesImpl.PREF_OVERRIDE_DEFAULTS, true)
            || preferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true) != prefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_PREVIEW, true)
            || preferences.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true) != prefs.getBoolean(FoldUtilitiesImpl.PREF_CONTENT_SUMMARY, true);
    for (JCheckBox cb : controls) {
        changed |= isFoldTypeChanged((FoldType) cb.getClientProperty("type"), prefs); // NOI18N
    }
    isChanged = changed;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
private void updateChecker(String prefKey, JCheckBox cb, FoldType ft) {
    if (lastChangedCB == cb) {
        // ignore
        lastChangedCB = null;
        return;
    }
    boolean val = isCollapseEnabled(ft);
    ignoreStateChange = true;
    LOG.log(Level.FINE, "Updating checker: " + prefKey + ", setSelected " + val); // NOI18N
    cb.setSelected(val);
    ignoreStateChange = false;
}
 

import org.netbeans.api.editor.fold.FoldType; //导入依赖的package包/类
public void actionPerformed (ActionEvent evt, JTextComponent target) {
    FoldHierarchy hierarchy = FoldHierarchy.get (target);
    // Hierarchy locking done in the utility method
    List<FoldType> types = new ArrayList<FoldType> ();
    types.add (Folds.getFoldType ((String) getValue (NAME)));
    FoldUtilities.collapse (hierarchy, types);
}