* Copyright (c) 2000, 2007 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* Provides access to the collection of defined editors for resource types.

*/

    IExtensionChangeHandler {

 

  private final static IEditorDescriptor [] EMPTY = new IEditorDescriptor[0];

 

  class RelatedRegistry {

    /**

         * Return the objects related to the type.

         *

         * @param type

         * @return the objects related to the type

     */

    public IEditorDescriptor[] getRelatedObjects(IContentType type) {     

      IEditorDescriptor[] relatedObjects = (IEditorDescriptor[]) contentTypeToEditorMappings.get(type);

      if (relatedObjects == null) {

        return EMPTY;

      }

      return relatedObjects;

    }

    /**

         * Return the objects related to the filename

         * @param fileName

         * @return the objects related to the filename

     */

    public IEditorDescriptor[] getRelatedObjects(String fileName) {

      IFileEditorMapping mapping = getMappingFor(fileName);

      if (mapping == null) {

        return EMPTY;

      }

     

      return mapping.getEditors();

    }

   

  }

 

  private Map contentTypeToEditorMappings = new HashMap();

 

    /*

     * Cached images - these include images from registered editors (via

     * plugins) and others hence this table is not one to one with the mappings

     * table. It is in fact a superset of the keys one would find in

     * typeEditorMappings

     */

    private Map extensionImages = new HashMap();

    /**

     * Vector of EditorDescriptor - all the editors loaded from plugin files.

     * The list is kept in order to be able to show in the editor selection

     * dialog of the resource associations page.  This list is sorted based on the

     * human readable label of the editor descriptor.

     *

     * @see #comparer

     */

    private List sortedEditorsFromPlugins = new ArrayList();

    // Map of EditorDescriptor - map editor id to editor.

    private Map mapIDtoEditor = initialIdToEditorMap(10);

    // Map of FileEditorMapping (extension to FileEditorMapping)

    private EditorMap typeEditorMappings;

    /*

     * Compares the labels from two IEditorDescriptor objects

     */

    private static final Comparator comparer = new Comparator() {

        private Collator collator = Collator.getInstance();

        public int compare(Object arg0, Object arg1) {

            String s1 = ((IEditorDescriptor) arg0).getLabel();

            String s2 = ((IEditorDescriptor) arg1).getLabel();

            return collator.compare(s1, s2);

        }

    };

  private RelatedRegistry relatedRegistry;

  public static final String EMPTY_EDITOR_ID = "org.eclipse.ui.internal.emptyEditorTab"; //$NON-NLS-1$

    /**

     * Return an instance of the receiver. Adds listeners into the extension

     * registry for dynamic UI purposes.

     */

    public EditorRegistry() {

        super();

        initializeFromStorage();

        IExtensionTracker tracker = PlatformUI.getWorkbench().getExtensionTracker();

        tracker.registerHandler(this, ExtensionTracker.createExtensionPointFilter(getExtensionPointFilter()));

    relatedRegistry = new RelatedRegistry();

    }

    /**

     * Add an editor for the given extensions with the specified (possibly null)

     * extended type. The editor is being registered from a plugin

     *

     * @param editor

     *            The description of the editor (as obtained from the plugin

     *            file and built by the registry reader)

     * @param extensions

     *            Collection of file extensions the editor applies to

     * @param filenames

     *            Collection of filenames the editor applies to

     * @param contentTypeVector

     * @param bDefault

     *            Indicates whether the editor should be made the default editor

     *            and hence appear first inside a FileEditorMapping

     *

     * This method is not API and should not be called outside the workbench

     * code.

     */

    public void addEditorFromPlugin(EditorDescriptor editor, List extensions,

            List filenames, List contentTypeVector, boolean bDefault) {

      PlatformUI.getWorkbench().getExtensionTracker().registerObject(

        editor.getConfigurationElement().getDeclaringExtension(),

        editor, IExtensionTracker.REF_WEAK);

        // record it in our quick reference list

        sortedEditorsFromPlugins.add(editor);

        // add it to the table of mappings

        Iterator itr = extensions.iterator();

        while (itr.hasNext()) {

            String fileExtension = (String) itr.next();

            if (fileExtension != null && fileExtension.length() > 0) {

                FileEditorMapping mapping = getMappingFor("*." + fileExtension); //$NON-NLS-1$

                if (mapping == null) { // no mapping for that extension

                    mapping = new FileEditorMapping(fileExtension);

                    typeEditorMappings.putDefault(mappingKeyFor(mapping),

                            mapping);

                }

                mapping.addEditor(editor);

                if (bDefault) {

          mapping.setDefaultEditor(editor);

        }

            }

        }

        // add it to the table of mappings

        itr = filenames.iterator();

        while (itr.hasNext()) {

            String filename = (String) itr.next();

            if (filename != null && filename.length() > 0) {

                FileEditorMapping mapping = getMappingFor(filename);

                if (mapping == null) { // no mapping for that extension

                    String name;

                    String extension;

                    int index = filename.indexOf('.');

                    if (index < 0) {

                        name = filename;

                        extension = ""; //$NON-NLS-1$

                    } else {

                        name = filename.substring(0, index);

                        extension = filename.substring(index + 1);

                    }

                    mapping = new FileEditorMapping(name, extension);

                    typeEditorMappings.putDefault(mappingKeyFor(mapping),

                            mapping);

                }

                mapping.addEditor(editor);

                if (bDefault) {

          mapping.setDefaultEditor(editor);

        }

            }

        }

   

   

    itr = contentTypeVector.iterator();

    while(itr.hasNext()) {

      String contentTypeId = (String) itr.next();

      if (contentTypeId != null && contentTypeId.length() > 0) {

        IContentType contentType = Platform.getContentTypeManager().getContentType(contentTypeId);

        if (contentType != null) {

          IEditorDescriptor [] editorArray = (IEditorDescriptor[]) contentTypeToEditorMappings.get(contentType);

          if (editorArray == null) {

            editorArray = new IEditorDescriptor[] {editor};

            contentTypeToEditorMappings.put(contentType, editorArray);

          }

          else {

            IEditorDescriptor [] newArray = new IEditorDescriptor[editorArray.length + 1];

            if (bDefault) { // default editors go to the front of the line

              newArray[0] = editor;

              System.arraycopy(editorArray, 0, newArray, 1, editorArray.length);

            }

            else {

              newArray[editorArray.length] = editor;

              System.arraycopy(editorArray, 0, newArray, 0, editorArray.length);

            }

            contentTypeToEditorMappings.put(contentType, newArray);

          }

        }

      }

    }

        // Update editor map.

        mapIDtoEditor.put(editor.getId(), editor);

    }

    /**

     * Add external editors to the editor mapping.

     */

    private void addExternalEditorsToEditorMap() {

        IEditorDescriptor desc = null;

        // Add registered editors (may include external editors).

        FileEditorMapping maps[] = typeEditorMappings.allMappings();

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

            FileEditorMapping map = maps[i];

            IEditorDescriptor[] descArray = map.getEditors();

            for (int n = 0; n < descArray.length; n++) {

                desc = descArray[n];

                mapIDtoEditor.put(desc.getId(), desc);

            }

        }

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public void addPropertyListener(IPropertyListener l) {

        addListenerObject(l);

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public IEditorDescriptor findEditor(String id) {

        return (IEditorDescriptor) mapIDtoEditor.get(id);

    }

    /**

     * Fires a property changed event to all registered listeners.

     *

     * @param type the type of event

     * @see IEditorRegistry#PROP_CONTENTS

     */

    private void firePropertyChange(final int type) {

        Object[] array = getListeners();

        for (int nX = 0; nX < array.length; nX++) {

            final IPropertyListener l = (IPropertyListener) array[nX];

            Platform.run(new SafeRunnable() {

                public void run() {

                    l.propertyChanged(EditorRegistry.this, type);

                }

            });

        }

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     *

     * @deprecated

     */

    public IEditorDescriptor getDefaultEditor() {

        // the default editor will always be the system external editor

        // this should never return null

        return findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public IEditorDescriptor getDefaultEditor(String filename) {

    return getDefaultEditor(filename, guessAtContentType(filename));

    }

  /**

   * Return the (approximated) content type for a file with the given name.

   *

   * @param filename the filename

   * @return the content type or <code>null</code> if it could not be determined

   * @since 3.1

   */

  private IContentType guessAtContentType(String filename) {

    return Platform.getContentTypeManager().findContentTypeFor(filename);

  }

    /**

     * Returns the default file image descriptor.

     *

     * @return the image descriptor

     */

    private ImageDescriptor getDefaultImage() {

        // @issue what should be the default image?

        return WorkbenchImages.getImageDescriptor(ISharedImages.IMG_OBJ_FILE);

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public IEditorDescriptor[] getEditors(String filename) {

    return getEditors(filename, guessAtContentType(filename));

  }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public IFileEditorMapping[] getFileEditorMappings() {

        FileEditorMapping[] array = typeEditorMappings.allMappings();

        final Collator collator = Collator.getInstance();

        Arrays.sort(array, new Comparator() {

           

            /* (non-Javadoc)

             * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)

             */

            public int compare(Object o1, Object o2) {

                String s1 = ((FileEditorMapping) o1).getLabel();

                String s2 = ((FileEditorMapping) o2).getLabel();

                return collator.compare(s1, s2);

            }

        });

        return array;

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public ImageDescriptor getImageDescriptor(String filename) {

    return getImageDescriptor(filename, guessAtContentType(filename));

  }

  /**

     * Find the file editor mapping for the file extension. Returns

     * <code>null</code> if not found.

     *

     * @param ext

     *            the file extension

     * @return the mapping, or <code>null</code>

     */

    private FileEditorMapping getMappingFor(String ext) {

        if (ext == null) {

      return null;

    }

        String key = mappingKeyFor(ext);

        return typeEditorMappings.get(key);

    }

    /**

     * Find the file editor mappings for the given filename.

     * <p>

     * Return an array of two FileEditorMapping items, where the first mapping

     * is for the entire filename, and the second mapping is for the filename's

     * extension only. These items can be null if no mapping exist on the

     * filename and/or filename's extension.</p>

     *

     * @param filename the filename

     * @return the mappings

     */

    private FileEditorMapping[] getMappingForFilename(String filename) {

        FileEditorMapping[] mapping = new FileEditorMapping[2];

        // Lookup on entire filename

        mapping[0] = getMappingFor(filename);

        // Lookup on filename's extension

        int index = filename.lastIndexOf('.');

        if (index > -1) {

            String extension = filename.substring(index);

            mapping[1] = getMappingFor("*" + extension); //$NON-NLS-1$

        }

        return mapping;

    }

    /**

     * Return the editor descriptors pulled from the OS.

     * <p>

     * WARNING! The image described by each editor descriptor is *not* known by

     * the workbench's graphic registry. Therefore clients must take care to

     * ensure that if they access any of the images held by these editors that

     * they also dispose them

     * </p>

     * @return the editor descriptors

     */

    public IEditorDescriptor[] getSortedEditorsFromOS() {

        List externalEditors = new ArrayList();

        Program[] programs = Program.getPrograms();

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

            //1FPLRL2: ITPUI:WINNT - NOTEPAD editor cannot be launched

            //Some entries start with %SystemRoot%

            //For such cases just use the file name as they are generally

            //in directories which are on the path

            /*

             * if (fileName.charAt(0) == '%') { fileName = name + ".exe"; }

             */

            EditorDescriptor editor = new EditorDescriptor();

            editor.setOpenMode(EditorDescriptor.OPEN_EXTERNAL);

            editor.setProgram(programs[i]);

            // determine the program icon this editor would need (do not let it

            // be cached in the workbench registry)

            ImageDescriptor desc = new ExternalProgramImageDescriptor(

                    programs[i]);

            editor.setImageDescriptor(desc);

            externalEditors.add(editor);

        }

        Object[] tempArray = sortEditors(externalEditors);

        IEditorDescriptor[] array = new IEditorDescriptor[externalEditors

                .size()];

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

            array[i] = (IEditorDescriptor) tempArray[i];

        }

        return array;

    }

    /**

     * Return the editors loaded from plugins.

     *

     * @return the sorted array of editors declared in plugins

     * @see #comparer

     */

    public IEditorDescriptor[] getSortedEditorsFromPlugins() {

        IEditorDescriptor[] array = new IEditorDescriptor[sortedEditorsFromPlugins

                .size()];

        sortedEditorsFromPlugins.toArray(array);

        return array;

    }

    /**

     * Answer an intial id to editor map. This will create a new map and

     * populate it with the default system editors.

     *

     * @param initialSize

     *            the initial size of the map

     * @return the new map

     */

    private HashMap initialIdToEditorMap(int initialSize) {

        HashMap map = new HashMap(initialSize);

        addSystemEditors(map);

        return map;

    }

    /**

     * Add the system editors to the provided map. This will always add an

     * editor with an id of {@link #SYSTEM_EXTERNAL_EDITOR_ID} and may also add

     * an editor with id of {@link #SYSTEM_INPLACE_EDITOR_ID} if the system

     * configuration supports it.

     *

     * @param map the map to augment

     */

    private void addSystemEditors(HashMap map) {

        // there will always be a system external editor descriptor

        EditorDescriptor editor = new EditorDescriptor();

        editor.setID(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);

        editor.setName(WorkbenchMessages.SystemEditorDescription_name);

        editor.setOpenMode(EditorDescriptor.OPEN_EXTERNAL);

        // @issue we need a real icon for this editor?

        map.put(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID, editor);

        // there may be a system in-place editor if supported by platform

        if (ComponentSupport.inPlaceEditorSupported()) {

            editor = new EditorDescriptor();

            editor.setID(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID);

            editor.setName(WorkbenchMessages.SystemInPlaceDescription_name);

            editor.setOpenMode(EditorDescriptor.OPEN_INPLACE);

            // @issue we need a real icon for this editor?

            map.put(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID, editor);

        }

       

    EditorDescriptor emptyEditorDescriptor = new EditorDescriptor();

    emptyEditorDescriptor.setID(EMPTY_EDITOR_ID);

    emptyEditorDescriptor.setName("(Empty)"); //$NON-NLS-1$

    emptyEditorDescriptor

        .setImageDescriptor(WorkbenchImages

            .getImageDescriptor(IWorkbenchGraphicConstants.IMG_OBJ_ELEMENT));

    map.put(EMPTY_EDITOR_ID, emptyEditorDescriptor);

    }

    /**

     * Initialize the registry state from plugin declarations and preference

     * overrides.

     */

    private void initializeFromStorage() {

        typeEditorMappings = new EditorMap();

        extensionImages = new HashMap();

        //Get editors from the registry

        EditorRegistryReader registryReader = new EditorRegistryReader();

        registryReader.addEditors(this);

        sortInternalEditors();

        rebuildInternalEditorMap();

        IPreferenceStore store = PlatformUI.getPreferenceStore();

        String defaultEditors = store

                .getString(IPreferenceConstants.DEFAULT_EDITORS);

        String chachedDefaultEditors = store

                .getString(IPreferenceConstants.DEFAULT_EDITORS_CACHE);

        //If defaults has changed load it afterwards so it overrides the users

        // associations.

        if (defaultEditors == null

                || defaultEditors.equals(chachedDefaultEditors)) {

            setProductDefaults(defaultEditors);

            loadAssociations(); //get saved earlier state

        } else {

            loadAssociations(); //get saved earlier state

            setProductDefaults(defaultEditors);

            store.putValue(IPreferenceConstants.DEFAULT_EDITORS_CACHE,

                    defaultEditors);

        }

        addExternalEditorsToEditorMap();

    }

    /**

     * Set the default editors according to the preference store which can be

     * overwritten in the file properties.ini.  In the form:

     * <p>

     * <code>ext1:id1;ext2:id2;...</code>

     * </p>

     *

     * @param defaultEditors the default editors to set

     */

    private void setProductDefaults(String defaultEditors) {

        if (defaultEditors == null || defaultEditors.length() == 0) {

      return;

    }

        StringTokenizer extEditors = new StringTokenizer(defaultEditors,

                new Character(IPreferenceConstants.SEPARATOR).toString());

        while (extEditors.hasMoreTokens()) {

            String extEditor = extEditors.nextToken().trim();

            int index = extEditor.indexOf(':');

            if (extEditor.length() < 3 || index <= 0

                    || index >= (extEditor.length() - 1)) {

                //Extension and id must have at least one char.

                WorkbenchPlugin

                        .log("Error setting default editor. Could not parse '" + extEditor + "'. Default editors should be specified as '*.ext1:editorId1;*.ext2:editorId2'"); //$NON-NLS-1$ //$NON-NLS-2$

                return;

            }

            String ext = extEditor.substring(0, index).trim();

            String editorId = extEditor.substring(index + 1).trim();

            FileEditorMapping mapping = getMappingFor(ext);

            if (mapping == null) {

                WorkbenchPlugin

                        .log("Error setting default editor. Could not find mapping for '" + ext + "'."); //$NON-NLS-1$ //$NON-NLS-2$

                continue;

            }

            EditorDescriptor editor = (EditorDescriptor) findEditor(editorId);

            if (editor == null) {

                WorkbenchPlugin

                        .log("Error setting default editor. Could not find editor: '" + editorId + "'."); //$NON-NLS-1$ //$NON-NLS-2$

                continue;

            }

            mapping.setDefaultEditor(editor);

        }

    }

    /**

     * Read the editors defined in the preferences store.

     *

     * @param editorTable

     *            Editor table to store the editor definitions.

     * @return true if the table is built succesfully.

     */

    private boolean readEditors(Map editorTable) {

        //Get the workbench plugin's working directory

        IPath workbenchStatePath = WorkbenchPlugin.getDefault().getDataLocation();

        if(workbenchStatePath == null) {

      return false;

    }       

        IPreferenceStore store = WorkbenchPlugin.getDefault()

                .getPreferenceStore();

        Reader reader = null;

        try {

            // Get the editors defined in the preferences store

            String xmlString = store.getString(IPreferenceConstants.EDITORS);

            if (xmlString == null || xmlString.length() == 0) {

                FileInputStream stream = new FileInputStream(workbenchStatePath

                        .append(IWorkbenchConstants.EDITOR_FILE_NAME)

                        .toOSString());

                reader = new BufferedReader(new InputStreamReader(stream,

                        "utf-8")); //$NON-NLS-1$

            } else {

                reader = new StringReader(xmlString);

            }

            XMLMemento memento = XMLMemento.createReadRoot(reader);

            EditorDescriptor editor;

            IMemento[] edMementos = memento

                    .getChildren(IWorkbenchConstants.TAG_DESCRIPTOR);

            // Get the editors and validate each one

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

                editor = new EditorDescriptor();

                boolean valid = editor.loadValues(edMementos[i]);

                if (!valid) {

                    continue;

                }

                if (editor.getPluginID() != null) {

                    //If the editor is from a plugin we use its ID to look it

                    // up in the mapping of editors we

                    //have obtained from plugins. This allows us to verify that

                    // the editor is still valid

                    //and allows us to get the editor description from the

                    // mapping table which has

                    //a valid config element field.

                    EditorDescriptor validEditorDescritor = (EditorDescriptor) mapIDtoEditor

                            .get(editor.getId());

                    if (validEditorDescritor != null) {

                        editorTable.put(validEditorDescritor.getId(),

                                validEditorDescritor);

                    }

                } else { //This is either from a program or a user defined

                    // editor

                    ImageDescriptor descriptor;

                    if (editor.getProgram() == null) {

            descriptor = new ProgramImageDescriptor(editor

                                .getFileName(), 0);

          } else {

            descriptor = new ExternalProgramImageDescriptor(editor

                                .getProgram());

          }

                    editor.setImageDescriptor(descriptor);

                    editorTable.put(editor.getId(), editor);

                }

            }

        } catch (IOException e) {

            try {

                if (reader != null) {

          reader.close();

        }

            } catch (IOException ex) {

                e.printStackTrace();

            }

            //Ignore this as the workbench may not yet have saved any state

            return false;

        } catch (WorkbenchException e) {

            ErrorDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,

                    WorkbenchMessages.EditorRegistry_errorMessage,

                    e.getStatus());

            return false;

        }

        return true;

    }

    /**

     * Read the file types and associate them to their defined editor(s).

     *

     * @param editorTable

     *            The editor table containing the defined editors.

     * @param reader

     *            Reader containing the preferences content for the resources.

     *

     * @throws WorkbenchException

     */

    public void readResources(Map editorTable, Reader reader)

            throws WorkbenchException {

        XMLMemento memento = XMLMemento.createReadRoot(reader);

        String versionString = memento.getString(IWorkbenchConstants.TAG_VERSION);

        boolean versionIs31 = "3.1".equals(versionString); //$NON-NLS-1$

       

        IMemento[] extMementos = memento

                .getChildren(IWorkbenchConstants.TAG_INFO);

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

            String name = extMementos[i]

                    .getString(IWorkbenchConstants.TAG_NAME);

            if (name == null) {

        name = "*"; //$NON-NLS-1$

      }

            String extension = extMementos[i]

                    .getString(IWorkbenchConstants.TAG_EXTENSION);

            IMemento[] idMementos = extMementos[i]

                    .getChildren(IWorkbenchConstants.TAG_EDITOR);

            String[] editorIDs = new String[idMementos.length];

            for (int j = 0; j < idMementos.length; j++) {

                editorIDs[j] = idMementos[j]

                        .getString(IWorkbenchConstants.TAG_ID);

            }

            idMementos = extMementos[i]

                    .getChildren(IWorkbenchConstants.TAG_DELETED_EDITOR);

            String[] deletedEditorIDs = new String[idMementos.length];

            for (int j = 0; j < idMementos.length; j++) {

                deletedEditorIDs[j] = idMementos[j]

                        .getString(IWorkbenchConstants.TAG_ID);

            }

            FileEditorMapping mapping = getMappingFor(name + "." + extension); //$NON-NLS-1$

            if (mapping == null) {

                mapping = new FileEditorMapping(name, extension);

            }

            List editors = new ArrayList();

            for (int j = 0; j < editorIDs.length; j++) {

                if (editorIDs[j] != null) {

                    EditorDescriptor editor = (EditorDescriptor) editorTable

                            .get(editorIDs[j]);

                    if (editor != null) {

                        editors.add(editor);

                    }

                }

            }

            List deletedEditors = new ArrayList();

            for (int j = 0; j < deletedEditorIDs.length; j++) {

                if (deletedEditorIDs[j] != null) {

                    EditorDescriptor editor = (EditorDescriptor) editorTable

                            .get(deletedEditorIDs[j]);

                    if (editor != null) {

                        deletedEditors.add(editor);

                    }

                }

            }

           

            List defaultEditors = new ArrayList();

           

            if (versionIs31) { // parse the new format

        idMementos = extMementos[i]

            .getChildren(IWorkbenchConstants.TAG_DEFAULT_EDITOR);

        String[] defaultEditorIds = new String[idMementos.length];

        for (int j = 0; j < idMementos.length; j++) {

          defaultEditorIds[j] = idMementos[j]

              .getString(IWorkbenchConstants.TAG_ID);

        }

        for (int j = 0; j < defaultEditorIds.length; j++) {

          if (defaultEditorIds[j] != null) {

            EditorDescriptor editor = (EditorDescriptor) editorTable

                .get(defaultEditorIds[j]);

            if (editor != null) {

              defaultEditors.add(editor);

            }

          }

        }

      }

            else { // guess at pre 3.1 format defaults

                if (!editors.isEmpty()) {

                  EditorDescriptor editor = (EditorDescriptor) editors.get(0);

                  if (editor != null) {

                      defaultEditors.add(editor); 

                    }

                }

                defaultEditors.addAll(Arrays.asList(mapping.getDeclaredDefaultEditors()));

            }

           

            // Add any new editors that have already been read from the registry

            // which were not deleted.

            IEditorDescriptor[] editorsArray = mapping.getEditors();

            for (int j = 0; j < editorsArray.length; j++) {

                if (!contains(editors, editorsArray[j])

                        && !deletedEditors.contains(editorsArray[j])) {

                    editors.add(editorsArray[j]);

                }

            }

            // Map the editor(s) to the file type

            mapping.setEditorsList(editors);

            mapping.setDeletedEditorsList(deletedEditors);

            mapping.setDefaultEditors(defaultEditors);

            typeEditorMappings.put(mappingKeyFor(mapping), mapping);

        }

    }

    /**

     * Determine if the editors list contains the editor descriptor.

     *

     * @param editorsArray

     *       The list of editors

     * @param editorDescriptor

     *       The editor descriptor

     * @return <code>true</code> if the editors list contains the editor descriptor

     */

    private boolean contains(List editorsArray,

            IEditorDescriptor editorDescriptor) {

        IEditorDescriptor currentEditorDescriptor = null;

        Iterator i = editorsArray.iterator();

        while (i.hasNext()) {

            currentEditorDescriptor = (IEditorDescriptor) i.next();

            if (currentEditorDescriptor.getId()

                    .equals(editorDescriptor.getId())) {

        return true;

      }

        }

        return false;

    }

    /**

     * Creates the reader for the resources preferences defined in the

     * preference store.

     *

     * @param editorTable

     *            The editor table containing the defined editors.

     * @return true if the resources are read succesfully.

     */

    private boolean readResources(Map editorTable) {

        //Get the workbench plugin's working directory

        IPath workbenchStatePath = WorkbenchPlugin.getDefault().getDataLocation();

        // XXX: nobody cares about this return value

        if(workbenchStatePath == null) {

      return false;

    }

        IPreferenceStore store = WorkbenchPlugin.getDefault()

                .getPreferenceStore();

        Reader reader = null;

        try {

            // Get the resource types

            String xmlString = store.getString(IPreferenceConstants.RESOURCES);

            if (xmlString == null || xmlString.length() == 0) {

                FileInputStream stream = new FileInputStream(workbenchStatePath

                        .append(IWorkbenchConstants.RESOURCE_TYPE_FILE_NAME)

                        .toOSString());

                reader = new BufferedReader(new InputStreamReader(stream,

                        "utf-8")); //$NON-NLS-1$

            } else {

                reader = new StringReader(xmlString);

            }

            // Read the defined resources into the table

            readResources(editorTable, reader);

        } catch (IOException e) {

            try {

                if (reader != null) {

          reader.close();

        }

            } catch (IOException ex) {

                ex.printStackTrace();

            }

            MessageDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,

                    WorkbenchMessages.EditorRegistry_errorMessage);

            return false;

        } catch (WorkbenchException e) {

            ErrorDialog.openError((Shell) null, WorkbenchMessages.EditorRegistry_errorTitle,

                    WorkbenchMessages.EditorRegistry_errorMessage,

                    e.getStatus());

            return false;

        }

        return true;

    }

    /**

     * Load the serialized resource associations Return true if the operation

     * was successful, false otherwise

     */

    private boolean loadAssociations() {

        Map editorTable = new HashMap();

        if (!readEditors(editorTable)) {

            return false;

        }

        return readResources(editorTable);

    }

    /**

     * Return a friendly version of the given key suitable for use in the editor

     * map.

     */

    private String mappingKeyFor(String type) {

        // keep everyting lower case for case-sensitive platforms

        return type.toLowerCase();

    }

    /**

     * Return a key that combines the file's name and extension of the given

     * mapping

     *

     * @param mapping the mapping to generate a key for

     */

    private String mappingKeyFor(FileEditorMapping mapping) {

        return mappingKeyFor(mapping.getName()

                + (mapping.getExtension().length() == 0 ? "" : "." + mapping.getExtension())); //$NON-NLS-1$ //$NON-NLS-2$

    }

    /**

     * Rebuild the editor map

     */

    private void rebuildEditorMap() {

        rebuildInternalEditorMap();

        addExternalEditorsToEditorMap();

    }

    /**

     * Rebuild the internal editor mapping.

     */

    private void rebuildInternalEditorMap() {

        Iterator itr = null;

        IEditorDescriptor desc = null;

        // Allocate a new map.

        mapIDtoEditor = initialIdToEditorMap(mapIDtoEditor.size());

        // Add plugin editors.

        itr = sortedEditorsFromPlugins.iterator();

        while (itr.hasNext()) {

            desc = (IEditorDescriptor) itr.next();

            mapIDtoEditor.put(desc.getId(), desc);

        }

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public void removePropertyListener(IPropertyListener l) {

        removeListenerObject(l);

    }

    /**

     * Save the registry to the filesystem by serializing the current resource

     * associations.

     */

    public void saveAssociations() {

        //Save the resource type descriptions

        List editors = new ArrayList();

        IPreferenceStore store = WorkbenchPlugin.getDefault()

                .getPreferenceStore();

        XMLMemento memento = XMLMemento

                .createWriteRoot(IWorkbenchConstants.TAG_EDITORS);

        memento.putString(IWorkbenchConstants.TAG_VERSION, "3.1"); //$NON-NLS-1$

        FileEditorMapping maps[] = typeEditorMappings.userMappings();

        for (int mapsIndex = 0; mapsIndex < maps.length; mapsIndex++) {

            FileEditorMapping type = maps[mapsIndex];

            IMemento editorMemento = memento

                    .createChild(IWorkbenchConstants.TAG_INFO);

            editorMemento.putString(IWorkbenchConstants.TAG_NAME, type

                    .getName());

            editorMemento.putString(IWorkbenchConstants.TAG_EXTENSION, type

                    .getExtension());

            IEditorDescriptor[] editorArray = type.getEditors();

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

                EditorDescriptor editor = (EditorDescriptor) editorArray[i];

                if (!editors.contains(editor)) {

                    editors.add(editor);

                }

                IMemento idMemento = editorMemento

                        .createChild(IWorkbenchConstants.TAG_EDITOR);

                idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]

                        .getId());

            }

            editorArray = type.getDeletedEditors();

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

                EditorDescriptor editor = (EditorDescriptor) editorArray[i];

                if (!editors.contains(editor)) {

                    editors.add(editor);

                }

                IMemento idMemento = editorMemento

                        .createChild(IWorkbenchConstants.TAG_DELETED_EDITOR);

                idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]

                        .getId());

            }

            editorArray = type.getDeclaredDefaultEditors();

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

                EditorDescriptor editor = (EditorDescriptor) editorArray[i];

                if (!editors.contains(editor)) {

                    editors.add(editor);

                }

                IMemento idMemento = editorMemento

                        .createChild(IWorkbenchConstants.TAG_DEFAULT_EDITOR);

                idMemento.putString(IWorkbenchConstants.TAG_ID, editorArray[i]

                        .getId());

            }

        }

        Writer writer = null;

        try {

            writer = new StringWriter();

            memento.save(writer);

            writer.close();

            store.setValue(IPreferenceConstants.RESOURCES, writer.toString());

        } catch (IOException e) {

            try {

                if (writer != null) {

          writer.close();

        }

            } catch (IOException ex) {

                ex.printStackTrace();

            }

            MessageDialog.openError((Shell) null, "Saving Problems", //$NON-NLS-1$

                    "Unable to save resource associations."); //$NON-NLS-1$

            return;

        }

        memento = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_EDITORS);

        Iterator itr = editors.iterator();

        while (itr.hasNext()) {

            EditorDescriptor editor = (EditorDescriptor) itr.next();

            IMemento editorMemento = memento

                    .createChild(IWorkbenchConstants.TAG_DESCRIPTOR);

            editor.saveValues(editorMemento);

        }

        writer = null;

        try {

            writer = new StringWriter();

            memento.save(writer);

            writer.close();

            store.setValue(IPreferenceConstants.EDITORS, writer.toString());

        } catch (IOException e) {

            try {

                if (writer != null) {

          writer.close();

        }

            } catch (IOException ex) {

                ex.printStackTrace();

            }

            MessageDialog.openError((Shell) null,

                    "Error", "Unable to save resource associations."); //$NON-NLS-1$ //$NON-NLS-2$

            return;

        }

    }

    /**

     * Set the collection of FileEditorMappings. The given collection is

     * converted into the internal hash table for faster lookup Each mapping

     * goes from an extension to the collection of editors that work on it. This

     * operation will rebuild the internal editor mappings.

     *

     * @param newResourceTypes

     *            te new file editor mappings.

     */

    public void setFileEditorMappings(FileEditorMapping[] newResourceTypes) {

        typeEditorMappings = new EditorMap();

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

            FileEditorMapping mapping = newResourceTypes[i];

            typeEditorMappings.put(mappingKeyFor(mapping), mapping);

        }

        extensionImages = new HashMap();

        rebuildEditorMap();

        firePropertyChange(PROP_CONTENTS);

    }

    /*

     * (non-Javadoc) Method declared on IEditorRegistry.

     */

    public void setDefaultEditor(String fileName, String editorId) {

        EditorDescriptor desc = (EditorDescriptor) findEditor(editorId);

        FileEditorMapping[] mapping = getMappingForFilename(fileName);

        if (mapping[0] != null) {

      mapping[0].setDefaultEditor(desc);

    }

        if (mapping[1] != null) {

      mapping[1].setDefaultEditor(desc);

    }

    }

    /**

     * Alphabetically sort the internal editors.

     *

     * @see #comparer

     */

    private Object[] sortEditors(List unsortedList) {

        Object[] array = new Object[unsortedList.size()];

        unsortedList.toArray(array);

        Collections.sort(Arrays.asList(array), comparer);

        return array;

    }

    /**

     * Alphabetically sort the internal editors.

     *

     * @see #comparer

     */

    private void sortInternalEditors() {

        Object[] array = sortEditors(sortedEditorsFromPlugins);

        sortedEditorsFromPlugins = new ArrayList();

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

            sortedEditorsFromPlugins.add(array[i]);

        }

    }

    /**

     * Map of FileEditorMapping (extension to FileEditorMapping) Uses two

     * java.util.HashMap: one keeps the default which are set by the plugins and

     * the other keeps the changes made by the user through the preference page.

     */

    private static class EditorMap {

        HashMap defaultMap = new HashMap();

        HashMap map = new HashMap();

        /**

         * Put a default mapping into the editor map.

         *

         * @param key the key to set

         * @param value the value to associate

         */

        public void putDefault(String key, FileEditorMapping value) {

            defaultMap.put(key, value);

        }

        /**

         * Put a mapping into the user editor map.

         *

         * @param key the key to set

         * @param value the value to associate

         */

        public void put(String key, FileEditorMapping value) {

            Object result = defaultMap.get(key);

            if (value.equals(result)) {

        map.remove(key);

      } else {

        map.put(key, value);

      }

        }

        /**

         * Return the mapping associated to the key. First searches user

         * map, and then falls back to the default map if there is no match. May

         * return <code>null</code>

         *

         * @param key

         *            the key to search for

         * @return the mapping associated to the key or <code>null</code>

         */

        public FileEditorMapping get(String key) {

            Object result = map.get(key);

            if (result == null) {

        result = defaultMap.get(key);

      }

            return (FileEditorMapping) result;

        }

        /**

         * Return all mappings. This will return default mappings overlayed with

         * user mappings.

         *

         * @return the mappings

         */

        public FileEditorMapping[] allMappings() {

            HashMap merge = (HashMap) defaultMap.clone();

            merge.putAll(map);

            Collection values = merge.values();

            FileEditorMapping result[] = new FileEditorMapping[values.size()];

            return (FileEditorMapping[]) values.toArray(result);

        }

        /**

         * Return all user mappings.

         *

         * @return the mappings

         */

        public FileEditorMapping[] userMappings() {

            Collection values = map.values();

            FileEditorMapping result[] = new FileEditorMapping[values.size()];

            return (FileEditorMapping[]) values.toArray(result);

        }

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.ui.IEditorRegistry#isSystemInPlaceEditorAvailable(String)

     */

    public boolean isSystemInPlaceEditorAvailable(String filename) {

        return ComponentSupport.inPlaceEditorAvailable(filename);

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.ui.IEditorRegistry#isSystemExternalEditorAvailable(String)

     */

    public boolean isSystemExternalEditorAvailable(String filename) {

        int nDot = filename.lastIndexOf('.');

        if (nDot >= 0) {

            String strName = filename.substring(nDot);

            return Program.findProgram(strName) != null;

        }

        return false;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.eclipse.ui.IEditorRegistry#getSystemExternalEditorImageDescriptor(java.lang.String)

     */

    public ImageDescriptor getSystemExternalEditorImageDescriptor(

            String filename) {

        Program externalProgram = null;

        int extensionIndex = filename.lastIndexOf('.');

        if (extensionIndex >= 0) {

            externalProgram = Program.findProgram(filename

                    .substring(extensionIndex));