Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common
   * Development and Distribution License("CDDL") (collectively, the
   * "License"). You may not use this file except in compliance with the
  * License. You can obtain a copy of the License at
  * http://www.netbeans.org/cddl-gplv2.html
  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
  * specific language governing permissions and limitations under the
  * License.  When distributing the software, include this License Header
  * Notice in each file and include the License file at
  * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Sun in the GPL Version 2 section of the License file that
  * accompanied this code. If applicable, add the following below the
  * License Header, with the fields enclosed by brackets [] replaced by
  * your own identifying information:
  * "Portions Copyrighted [year] [name of copyright owner]"
  *
  * Contributor(s):
  *
  * The Original Software is NetBeans. The Initial Developer of the Original
  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
  * Microsystems, Inc. All Rights Reserved.
  *
  * If you wish your version of this file to be governed by only the CDDL
  * or only the GPL Version 2, indicate your decision by adding
  * "[Contributor] elects to include this software in this distribution
  * under the [CDDL or GPL Version 2] license." If you do not indicate a
  * single choice of license, a recipient has the option to distribute
  * your version of this file under either the CDDL, the GPL Version 2 or
  * to extend the choice of license to its licensees as provided above.
  * However, if you add GPL Version 2 code and therefore, elected the GPL
  * Version 2 license, then the option applies only if the new code is
  * made subject to such option by the copyright holder.
  */
 package org.netbeans.modules.cnd.makeproject.api.configurations;
 
 import java.io.File;
 import java.util.List;
 
 public class Item implements NativeFileItemPropertyChangeListener {
 
     private final String path;
     //private final String sortName;
     private Folder folder;
     private File file = null;
     private DataObject lastDataObject = null;
 
     public Item(String path) {
         this. = path;
         //this.sortName = IpeUtils.getBaseName(path);
 //        int i = sortName.lastIndexOf("."); // NOI18N
 //        if (i > 0) {
 //            this.sortName = sortName.substring(0, i);
 //        } else {
 //            this.sortName = sortName;
 //        }
          = null;
     }

    
Rename item.

Parameters:
newname new name without suffic or path
 
     public void rename(String newname) {
         rename(newnametrue);
     }
 
     private void rename(String newnameboolean nameWithoutExtension) {
         if (newname == null || newname.length() == 0 || getFolder() == null) {
            return;
        }
        if (.equals(newname)) {
            return;
        }
        // Rename name in path
        int indexName = .lastIndexOf('/');
        if (indexName < 0) {
            indexName = 0;
        } else {
            indexName++;
        }
        int indexDot = .lastIndexOf('.');
        if (indexDot < indexName || !nameWithoutExtension) {
            indexDot = -1;
        }
        String oldname;
        if (indexDot >= 0) {
            oldname = .substring(indexNameindexDot);
        } else {
            oldname = .substring(indexName);
        }
        if (oldname.equals(newname)) {
            return;
        }
        String newPath = ""// NOI18N
        if (indexName > 0) {
            newPath = .substring(0, indexName);
        }
        newPath += newname;
        if (indexDot >= 0) {
            newPath += .substring(indexDot);
        }
        // Remove old item and insert new with new name
        moveTo(newPath);
    }
    public void moveTo(String newPath) {
        Folder f = getFolder();
        if (f.isDiskFolder()) {
            return;
        }
        String oldPath = getAbsPath();
        Item item = new Item(newPath);
        f.addItem(item);
        if (item.getFolder().isProjectFiles()) {
            copyItemConfigurations(thisitem);
        }
        f.removeItem(this);
        f.renameItemAction(oldPathitem);
    }
    public String getPath() {
        return ;
    }
    public String getSortName() {
        //return sortName;
        return getName();
    }
    public String getName() {
        return IpeUtils.getBaseName();
    }
    public String getPath(boolean norm) {
        String pat = "./"// UNIX path  // NOI18N
        if (norm && getPath().startsWith(pat)) {
            return getPath().substring(2);
        } else {
            return getPath();
        }
    }
    public String getAbsPath() {
        String retPath = null;
        if (IpeUtils.isPathAbsolute(getPath())) {// UNIX path
            retPath = getPath();
            retPath = FilePathAdaptor.mapToLocal(retPath);
        } else if (getFolder() != null) {
            retPath = getFolder().getConfigurationDescriptor().getBaseDir() + '/' + getPath(); // UNIX path
        }
        return retPath;
    }
    public void setFolder(Folder folder) {
        if (folder == null &&  == null) {
            // store file in field. method getFile() will works after removing item
            getCanonicalFile();
        }
        this. = folder;
        if (folder == null) { // Item is removed, let's clean up.
            synchronized (this) {
                if ( != null) {
                    .removePropertyChangeListener(this);
                     = null;
                }
            }
        }
    }
    public void propertyChange(PropertyChangeEvent evt) {
        if (evt.getPropertyName().equals("name")) { // NOI18N
            // File has been renamed
            boolean nameWithoutExtension = true;
            Object o = evt.getSource();
            if (o instanceof DataObject) {
                String nodeName = ((DataObjecto).getName();
                FileObject fo = ((DataObjecto).getPrimaryFile();
                if (fo != null) {
                    String fileName = fo.getNameExt();
                    if (nodeName.equals(fileName)) {
                        nameWithoutExtension = false;
                    }
                }
            }
            rename((Stringevt.getNewValue(), nameWithoutExtension);
        } else if (evt.getPropertyName().equals("valid")) { // NOI18N
            // File has been deleted
            // Do nothing (IZ 87557, 94935)
            if (!((Booleanevt.getNewValue()).booleanValue()) {
//                getFolder().removeItemAction(this);
                Folder containingFolder = getFolder();
                if (containingFolder != null) {
                    containingFolder.refresh(this);
                }
            }
        } else if (evt.getPropertyName().equals("primaryFile")) { // NOI18N
            // File has been moved
            FileObject fo = (FileObjectevt.getNewValue();
            String newPath = FileUtil.toFile(fo).getPath();
            if (!IpeUtils.isPathAbsolute(getPath())) {
                newPath = IpeUtils.toRelativePath(getFolder().getConfigurationDescriptor().getBaseDir(), newPath);
            }
            newPath = FilePathAdaptor.normalize(newPath);
            moveTo(newPath);
        }
    }
    public Folder getFolder() {
        return ;
    }
    public File getNormalizedFile() {
        String aPath = getAbsPath();
        if (aPath != null) {
            return CndFileUtils.normalizeFile(new File(aPath));
        }
        return ;
    }
    public File getFile() {
        // let's try to use normalized, not canonical paths
        return getNormalizedFile();
    }
    public File getCanonicalFile() {
        if ( == null) {
            try {
                 = new File(getAbsPath()).getCanonicalFile();
            } catch (IOException ioe) {
                 = CndFileUtils.normalizeFile(new File(getAbsPath()));
            }
        }
        return ;
    }
    public String getId() {
        // ID of other objects shouldn't be like to path
        return getPath();
    }
    public ItemConfiguration getItemConfiguration(Configuration configuration) {
        if (configuration != null) {
            return (ItemConfigurationconfiguration.getAuxObject(getId());
        }
        return null;
    }
        ItemConfiguration[] itemConfigurations;
        MakeConfigurationDescriptor makeConfigurationDescriptor = getMakeConfigurationDescriptor();
        if (makeConfigurationDescriptor == null) {
            return new ItemConfiguration[0];
        }
        Configuration[] configurations = makeConfigurationDescriptor.getConfs().getConfs();
        itemConfigurations = new ItemConfiguration[configurations.length];
        for (int i = 0; i < configurations.lengthi++) {
            itemConfigurations[i] = getItemConfiguration(configurations[i]);
        }
        return itemConfigurations;
    }
    public void copyConfigurations(Item src) {
        if (src.getFolder() == null) {
            return;
        }
        MakeConfigurationDescriptor makeConfigurationDescriptor = src.getFolder().getConfigurationDescriptor();
        if (makeConfigurationDescriptor == null) {
            return;
        }
        for (Configuration conf : makeConfigurationDescriptor.getConfs().getConfs()) {
            ItemConfiguration srcItemConfiguration = src.getItemConfiguration(conf);
            ItemConfiguration dstItemConfiguration = getItemConfiguration(conf);
            if (srcItemConfiguration != null && dstItemConfiguration != null) {
                dstItemConfiguration.assignValues(srcItemConfiguration);
            }
        }
    }

    
Copies configuration from src item to dst item. Both items must be assigned to folders to correctly operate with their configurations. Otherwise NPEs will be thrown.

Parameters:
src item to copy configuration from
dst item to copy configuration to
    private static void copyItemConfigurations(Item srcItem dst) {
        MakeConfigurationDescriptor makeConfigurationDescriptor = src.getMakeConfigurationDescriptor();
        if (makeConfigurationDescriptor != null) {
            for (Configuration conf : makeConfigurationDescriptor.getConfs().getConfs()) {
                ItemConfiguration newConf = new ItemConfiguration(confdst);
                newConf.assignValues(src.getItemConfiguration(conf));
                conf.addAuxObject(newConf);
            }
        }
    }
    public FileObject getFileObject() {
        File curFile = getNormalizedFile();
        FileObject fo = FileUtil.toFileObject(curFile);
        if (fo == null) {
            fo = FileUtil.toFileObject(getCanonicalFile());
        }
        return fo;
    }
    public DataObject getDataObject() {
        synchronized (this) {
            if ( != null && .isValid()){
                return ;
            }
        }
        DataObject dataObject = null;
        FileObject fo = getFileObject();
        if (fo != null) {
            try {
                dataObject = DataObject.find(fo);
            } catch (DataObjectNotFoundException e) {
                // should not happen
                ErrorManager.getDefault().notify(e);
            }
        }
        synchronized (this) {
            if (dataObject != ) {
                // DataObject can change without notification. We need to track this
                // and properly attach/detach listeners.
                if ( != null) {
                    .removePropertyChangeListener(this);
                }
                if (dataObject != null) {
                    dataObject.addPropertyChangeListener(this);
                }
                 = dataObject;
            }
        }
        return dataObject;
    }
    public final String getMIMEType() {
        DataObject dataObject = getDataObject();
        FileObject fo = dataObject == null ? null : dataObject.getPrimaryFile();
        String mimeType = "";
        if (fo == null) {
            mimeType = MIMESupport.getFileMIMEType(getNormalizedFile());
        } else {
            mimeType = MIMESupport.getFileMIMEType(fo);
        }
        return mimeType;
    }
    public int getDefaultTool() {
        int tool;
        String mimeType = getMIMEType();
        if (..equals(mimeType)) {
            tool = .;
        } else if (..equals(mimeType)) {
            tool = .;
        } else if (..equals(mimeType)) {
            tool = .;
        } else if (..equals(mimeType)) {
            tool = .;
        } else if (..equals(mimeType)) {
            tool = .;
        } else {
            tool = .;
        }
        return tool;
    }
        if (getFolder() == null) {
            return null;
        }
        return getFolder().getConfigurationDescriptor();
    }
        MakeConfigurationDescriptor makeConfigurationDescriptor = getMakeConfigurationDescriptor();
        if (makeConfigurationDescriptor == null) {
            return null;
        }
        return makeConfigurationDescriptor.getActiveConfiguration();
    }
    public NativeProject getNativeProject() {
        Folder curFolder = getFolder();
        if (curFolder != null) {
            Project project = curFolder.getProject();
            if (project != null) {
                return project.getLookup().lookup(NativeProject.class);
            }
        }
        return null;
    }
    public List<StringgetSystemIncludePaths() {
        List<Stringvec = new ArrayList<String>();
        MakeConfiguration makeConfiguration = getMakeConfiguration();
        ItemConfiguration itemConfiguration = getItemConfiguration(makeConfiguration);//ItemConfiguration)makeConfiguration.getAuxObject(ItemConfiguration.getId(getPath()));
        if (itemConfiguration == null || !itemConfiguration.isCompilerToolConfiguration()) // FIXUP: sometimes itemConfiguration is null (should not happen)
        {
            return vec;
        }
        CompilerSet compilerSet = makeConfiguration.getCompilerSet().getCompilerSet();
        if (compilerSet == null) {
            return vec;
        }
        BasicCompiler compiler = (BasicCompilercompilerSet.getTool(itemConfiguration.getTool());
        BasicCompilerConfiguration compilerConfiguration = itemConfiguration.getCompilerConfiguration();
        if (compilerConfiguration instanceof CCCCompilerConfiguration) {
            // Get include paths from compiler
            if (compiler != null && compiler.getPath() != null && compiler.getPath().length() > 0) {
                vec.addAll(compiler.getSystemIncludeDirectories());
            }
        }
        return vec;
    }
    public List<StringgetUserIncludePaths() {
        List<Stringvec = new ArrayList<String>();
        MakeConfiguration makeConfiguration = getMakeConfiguration();
        ItemConfiguration itemConfiguration = getItemConfiguration(makeConfiguration);//ItemConfiguration)makeConfiguration.getAuxObject(ItemConfiguration.getId(getPath()));
        if (itemConfiguration == null || !itemConfiguration.isCompilerToolConfiguration()) // FIXUP: sometimes itemConfiguration is null (should not happen)
        {
            return vec;
        }
        CompilerSet compilerSet = makeConfiguration.getCompilerSet().getCompilerSet();
        if (compilerSet == null) {
            return vec;
        }
        BasicCompiler compiler = (BasicCompilercompilerSet.getTool(itemConfiguration.getTool());
        BasicCompilerConfiguration compilerConfiguration = itemConfiguration.getCompilerConfiguration();
        if (compilerConfiguration instanceof CCCCompilerConfiguration) {
            // Get include paths from project/file
            List<Stringvec2 = new ArrayList<String>();
            CCCCompilerConfiguration cccCompilerConfiguration = (CCCCompilerConfigurationcompilerConfiguration;
            CCCCompilerConfiguration master = (CCCCompilerConfigurationcccCompilerConfiguration.getMaster();
            while (master != null && cccCompilerConfiguration.getInheritIncludes().getValue()) {
                vec2.addAll(master.getIncludeDirectories().getValue());
                if (master.getInheritIncludes().getValue()) {
                    master = (CCCCompilerConfigurationmaster.getMaster();
                } else {
                    master = null;
                }
            }
            vec2.addAll(cccCompilerConfiguration.getIncludeDirectories().getValue());
            // Convert all paths to absolute paths
            Iterator iter = vec2.iterator();
            while (iter.hasNext()) {
                vec.add(IpeUtils.toAbsolutePath(getFolder().getConfigurationDescriptor().getBaseDir(), (Stringiter.next()));
            }
            if (cccCompilerConfiguration instanceof AllOptionsProvider) {
                vec = .getItemUserIncludePaths(vec, (AllOptionsProvidercccCompilerConfigurationcompilermakeConfiguration);
            }
        }
        return vec;
    }
        List<Stringvec = new ArrayList<String>();
        MakeConfiguration makeConfiguration = getMakeConfiguration();
        ItemConfiguration itemConfiguration = getItemConfiguration(makeConfiguration); //ItemConfiguration)makeConfiguration.getAuxObject(ItemConfiguration.getId(getPath()));
        if (itemConfiguration == null || !itemConfiguration.isCompilerToolConfiguration()) // FIXUP: itemConfiguration should never be null
        {
            return vec;
        }
        CompilerSet compilerSet = makeConfiguration.getCompilerSet().getCompilerSet();
        if (compilerSet == null) {
            return vec;
        }
        BasicCompiler compiler = (BasicCompilercompilerSet.getTool(itemConfiguration.getTool());
        BasicCompilerConfiguration compilerConfiguration = itemConfiguration.getCompilerConfiguration();
        if (compilerConfiguration instanceof CCCCompilerConfiguration) {
            if (compiler != null && compiler.getPath() != null && compiler.getPath().length() > 0) {
                // Get macro definitions from compiler
                vec.addAll(compiler.getSystemPreprocessorSymbols());
            }
        }
        return vec;
    }
    public List<StringgetUserMacroDefinitions() {
        List<Stringvec = new ArrayList<String>();
        MakeConfiguration makeConfiguration = getMakeConfiguration();
        ItemConfiguration itemConfiguration = getItemConfiguration(makeConfiguration); //ItemConfiguration)makeConfiguration.getAuxObject(ItemConfiguration.getId(getPath()));
        if (itemConfiguration == null || !itemConfiguration.isCompilerToolConfiguration()) // FIXUP: itemConfiguration should never be null
        {
            return vec;
        }
        CompilerSet compilerSet = makeConfiguration.getCompilerSet().getCompilerSet();
        if (compilerSet == null) {
            return vec;
        }
        BasicCompiler compiler = (BasicCompilercompilerSet.getTool(itemConfiguration.getTool());
        BasicCompilerConfiguration compilerConfiguration = itemConfiguration.getCompilerConfiguration();
        if (compilerConfiguration instanceof CCCCompilerConfiguration) {
            CCCCompilerConfiguration cccCompilerConfiguration = (CCCCompilerConfigurationcompilerConfiguration;
            CCCCompilerConfiguration master = (CCCCompilerConfigurationcccCompilerConfiguration.getMaster();
            while (master != null && cccCompilerConfiguration.getInheritPreprocessor().getValue()) {
                vec.addAll(master.getPreprocessorConfiguration().getValue());
                if (master.getInheritIncludes().getValue()) {
                    master = (CCCCompilerConfigurationmaster.getMaster();
                } else {
                    master = null;
                }
            }
            vec.addAll(cccCompilerConfiguration.getPreprocessorConfiguration().getValue());
            if (cccCompilerConfiguration instanceof AllOptionsProvider) {
                vec = .getItemUserMacros(vec, (AllOptionsProvidercccCompilerConfigurationcompilermakeConfiguration);
            }
        }
        return vec;
    }
    public boolean hasHeaderOrSourceExtension(boolean cFilesboolean ccFiles) {
        // Method return true for source files also.
        String mimeType = getMIMEType();
        return ..equals(mimeType) ||
                (ccFiles && ..equals(mimeType)) ||
                (cFiles && ..equals(mimeType));
    }

    
NativeFileItem interface
    public Language getLanguage() {
        int tool;
        Language language;
        ItemConfiguration itemConfiguration = null;
        MakeConfiguration makeConfiguration = getMakeConfiguration();
        if (makeConfiguration != null) {
            itemConfiguration = getItemConfiguration(makeConfiguration); //ItemConfiguration)makeConfiguration.getAuxObject(ItemConfiguration.getId(getPath()));
        }
        if (itemConfiguration != null) {
            tool = itemConfiguration.getTool();
        } else {
            tool = getDefaultTool();
        }
        if (tool == .) {
            language = ..;
        } else if (tool == .) {
            language = ..;
        } else if (tool == .) {
            language = ..;
        } else if (hasHeaderOrSourceExtension(truetrue)) {
            language = ..;
        } else {
            language = ..;
        }
        return language;
    }

    
NativeFileItem interface
    public LanguageFlavor getLanguageFlavor() {
        return ..;
    }

    
NativeFileItem interface
    public boolean isExcluded() {
        ItemConfiguration itemConfiguration = getItemConfiguration(getMakeConfiguration());
        if (itemConfiguration != null) {
            return itemConfiguration.getExcluded().getValue();
        }
        return true;
    }
    @Override
    public String toString() {
        return ;
    }
    private static final SpiAccessor SPI_ACCESSOR = new SpiAccessor();
    private static final class SpiAccessor {
        private UserOptionsProvider provider;
        private synchronized UserOptionsProvider getProvider() {
            if ( == null) {
                 = Lookup.getDefault().lookup(UserOptionsProvider.class);
            }
            return ;
        }
        private SpiAccessor() {
        }
        private List<StringgetItemUserIncludePaths(List<StringincludesAllOptionsProvider compilerOptionsBasicCompiler compilerMakeConfiguration makeConfiguration) {
            if (getProvider() != null) {
                return getProvider().getItemUserIncludePaths(includescompilerOptionscompilermakeConfiguration);
            } else {
                return includes;
            }
        }
        private List<StringgetItemUserMacros(List<StringmacrosAllOptionsProvider compilerOptionsBasicCompiler compilerMakeConfiguration makeConfiguration) {
            if (getProvider() != null) {
                return getProvider().getItemUserMacros(macroscompilerOptionscompilermakeConfiguration);
            } else {
                return macros;
            }
        }
    }
New to GrepCode? Check out our FAQ X