directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From fel...@apache.org
Subject svn commit: r592094 [20/35] - in /directory/sandbox/felixk/studio-schemaeditor: ./ META-INF/ src/ src/main/ src/main/java/ src/main/java/org/ src/main/java/org/apache/ src/main/java/org/apache/directory/ src/main/java/org/apache/directory/studio/ src/m...
Date Mon, 05 Nov 2007 17:15:02 GMT
Added: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewContentProvider.java
URL: http://svn.apache.org/viewvc/directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewContentProvider.java?rev=592094&view=auto
==============================================================================
--- directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewContentProvider.java (added)
+++ directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewContentProvider.java Mon Nov  5 09:14:24 2007
@@ -0,0 +1,1377 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+package org.apache.directory.studio.schemaeditor.view.views;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.collections.map.MultiValueMap;
+import org.apache.directory.studio.schemaeditor.Activator;
+import org.apache.directory.studio.schemaeditor.PluginConstants;
+import org.apache.directory.studio.schemaeditor.controller.SchemaHandler;
+import org.apache.directory.studio.schemaeditor.model.AttributeTypeImpl;
+import org.apache.directory.studio.schemaeditor.model.ObjectClassImpl;
+import org.apache.directory.studio.schemaeditor.model.Schema;
+import org.apache.directory.studio.schemaeditor.model.hierarchy.HierarchyManager;
+import org.apache.directory.studio.schemaeditor.view.wrappers.AttributeTypeWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.FirstNameSorter;
+import org.apache.directory.studio.schemaeditor.view.wrappers.Folder;
+import org.apache.directory.studio.schemaeditor.view.wrappers.ObjectClassWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.OidSorter;
+import org.apache.directory.studio.schemaeditor.view.wrappers.SchemaSorter;
+import org.apache.directory.studio.schemaeditor.view.wrappers.SchemaViewRoot;
+import org.apache.directory.studio.schemaeditor.view.wrappers.SchemaWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.TreeNode;
+import org.apache.directory.studio.schemaeditor.view.wrappers.Folder.FolderType;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.Viewer;
+
+
+/**
+ * This class implements the ContentProvider for the SchemaView.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$, $Date$
+ */
+public class SchemaViewContentProvider implements IStructuredContentProvider, ITreeContentProvider
+{
+    /** The preferences store */
+    private IPreferenceStore store;
+
+    /** The FirstName Sorter */
+    private FirstNameSorter firstNameSorter;
+
+    /** The OID Sorter */
+    private OidSorter oidSorter;
+
+    /** The Schema Sorter */
+    private SchemaSorter schemaSorter;
+
+    /** The RootWrapper */
+    private SchemaViewRoot root;
+
+    /** The 'Elements To Wrappers' Map */
+    private MultiValueMap elementsToWrappersMap;
+
+    private HierarchyManager hierarchyManager;
+
+
+    /**
+     * Creates a new instance of DifferencesWidgetSchemaContentProvider.
+     */
+    public SchemaViewContentProvider()
+    {
+        store = Activator.getDefault().getPreferenceStore();
+
+        firstNameSorter = new FirstNameSorter();
+        oidSorter = new OidSorter();
+        schemaSorter = new SchemaSorter();
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
+     */
+    public Object[] getElements( Object inputElement )
+    {
+        return getChildren( inputElement );
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.IContentProvider#dispose()
+     */
+    public void dispose()
+    {
+        // Nothing to do
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
+     */
+    public void inputChanged( Viewer viewer, Object oldInput, Object newInput )
+    {
+        // Nothing to do
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
+     */
+    public Object[] getChildren( Object parentElement )
+    {
+        List<TreeNode> children = new ArrayList<TreeNode>();
+
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+        int sortBy = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY );
+        int sortOrder = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER );
+
+        if ( parentElement instanceof SchemaViewRoot )
+        {
+            root = ( SchemaViewRoot ) parentElement;
+
+            if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+            {
+                if ( root.getChildren().isEmpty() )
+                {
+                    elementsToWrappersMap = new MultiValueMap();
+
+                    SchemaHandler schemaHandler = Activator.getDefault().getSchemaHandler();
+                    if ( schemaHandler != null )
+                    {
+                        List<Schema> schemas = schemaHandler.getSchemas();
+                        for ( Schema schema : schemas )
+                        {
+                            addSchemaFlatPresentation( schema );
+                        }
+                    }
+                }
+
+                children = root.getChildren();
+
+                Collections.sort( children, schemaSorter );
+            }
+            else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+            {
+                if ( root.getChildren().isEmpty() )
+                {
+                    elementsToWrappersMap = new MultiValueMap();
+
+                    hierarchyManager = new HierarchyManager();
+
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        Folder atFolder = new Folder( FolderType.ATTRIBUTE_TYPE, root );
+                        Folder ocFolder = new Folder( FolderType.OBJECT_CLASS, root );
+                        root.addChild( atFolder );
+                        root.addChild( ocFolder );
+
+                        List<Object> rootChildren = hierarchyManager.getChildren( hierarchyManager.getRootObject() );
+                        if ( ( rootChildren != null ) && ( rootChildren.size() > 0 ) )
+                        {
+                            for ( Object rootChild : rootChildren )
+                            {
+                                TreeNode childNode = null;
+
+                                // Creating the wrapper
+                                if ( rootChild instanceof AttributeTypeImpl )
+                                {
+                                    AttributeTypeImpl at = ( AttributeTypeImpl ) rootChild;
+                                    childNode = new AttributeTypeWrapper( at, atFolder );
+                                    atFolder.addChild( childNode );
+                                }
+                                else if ( rootChild instanceof ObjectClassImpl )
+                                {
+                                    ObjectClassImpl oc = ( ObjectClassImpl ) rootChild;
+                                    childNode = new ObjectClassWrapper( oc, ocFolder );
+                                    ocFolder.addChild( childNode );
+                                }
+
+                                // Filling the 'Elements To Wrappers' Map
+                                elementsToWrappersMap.put( rootChild, childNode );
+
+                                // Recursively creating the hierarchy for all children
+                                // of the root element.
+                                addHierarchyChildren( childNode, hierarchyManager.getChildren( rootChild ) );
+                            }
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        addHierarchyChildren( root, hierarchyManager.getChildren( hierarchyManager.getRootObject() ) );
+                    }
+                }
+
+                children = root.getChildren();
+
+                if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                {
+                    // Sort by
+                    if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME )
+                    {
+                        Collections.sort( children, firstNameSorter );
+                    }
+                    else if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID )
+                    {
+                        Collections.sort( children, oidSorter );
+                    }
+
+                    // Sort Order
+                    if ( sortOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING )
+                    {
+                        Collections.reverse( children );
+                    }
+                }
+            }
+
+        }
+        else if ( parentElement instanceof Folder )
+        {
+            children = ( ( TreeNode ) parentElement ).getChildren();
+
+            // Sort by
+            if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME )
+            {
+                Collections.sort( children, firstNameSorter );
+            }
+            else if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID )
+            {
+                Collections.sort( children, oidSorter );
+            }
+
+            // Sort Order
+            if ( sortOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING )
+            {
+                Collections.reverse( children );
+            }
+        }
+        else if ( ( parentElement instanceof AttributeTypeWrapper ) || ( parentElement instanceof ObjectClassWrapper ) )
+        {
+            children = ( ( TreeNode ) parentElement ).getChildren();
+
+            // Sort by
+            if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME )
+            {
+                Collections.sort( children, firstNameSorter );
+            }
+            else if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID )
+            {
+                Collections.sort( children, oidSorter );
+            }
+
+            // Sort Order
+            if ( sortOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING )
+            {
+                Collections.reverse( children );
+            }
+        }
+        else if ( parentElement instanceof SchemaWrapper )
+        {
+            children = ( ( TreeNode ) parentElement ).getChildren();
+
+            if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+            {
+                // Sort by
+                if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME )
+                {
+                    Collections.sort( children, firstNameSorter );
+                }
+                else if ( sortBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID )
+                {
+                    Collections.sort( children, oidSorter );
+                }
+
+                // Sort Order
+                if ( sortOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING )
+                {
+                    Collections.reverse( children );
+                }
+            }
+        }
+
+        return children.toArray();
+    }
+
+
+    /**
+     * Converts the given children and adds them to the given node.
+     *
+     * @param node
+     *      the parent node.
+     * @param children
+     *      the children
+     */
+    private void addHierarchyChildren( TreeNode node, List<Object> children )
+    {
+        if ( ( children != null ) && ( children.size() > 0 ) )
+        {
+            for ( Object child : children )
+            {
+                TreeNode childNode = null;
+                if ( child instanceof AttributeTypeImpl )
+                {
+                    AttributeTypeImpl at = ( AttributeTypeImpl ) child;
+                    childNode = new AttributeTypeWrapper( at, node );
+                    node.addChild( childNode );
+                }
+                else if ( child instanceof ObjectClassImpl )
+                {
+                    ObjectClassImpl oc = ( ObjectClassImpl ) child;
+                    childNode = new ObjectClassWrapper( oc, node );
+                    node.addChild( childNode );
+                }
+
+                // Filling the 'Elements To Wrappers' Map
+                elementsToWrappersMap.put( child, childNode );
+
+                // Recursively creating the hierarchy for all children
+                // of the given element.
+                addHierarchyChildren( childNode, hierarchyManager.getChildren( child ) );
+            }
+        }
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)
+     */
+    public Object getParent( Object element )
+    {
+        if ( element instanceof TreeNode )
+        {
+            return ( ( TreeNode ) element ).getParent();
+        }
+
+        // Default
+        return null;
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)
+     */
+    public boolean hasChildren( Object element )
+    {
+        if ( element instanceof TreeNode )
+        {
+            return ( ( TreeNode ) element ).hasChildren();
+        }
+
+        // Default
+        return false;
+    }
+
+
+    /**
+     * Gets the wrappers associated with the given object.
+     *
+     * @param o
+     *      the object
+     * @return
+     *      the wrappers associated with the given object
+     */
+    @SuppressWarnings("unchecked")
+    public List<TreeNode> getWrappers( Object o )
+    {
+        return ( List<TreeNode> ) elementsToWrappersMap.get( o );
+    }
+
+
+    /**
+     * Gets the wrapper associated with the given object.
+     *
+     * @param o
+     *      the object
+     * @return
+     *      the wrapper associated with the given object
+     */
+    public TreeNode getWrapper( Object o )
+    {
+        List<TreeNode> wrappers = getWrappers( o );
+        if ( ( wrappers != null ) && ( wrappers.size() > 0 ) )
+        {
+            return wrappers.get( 0 );
+        }
+
+        // Default
+        return null;
+    }
+
+
+    /**
+     * Gets the Root Element.
+     *
+     * @return
+     *      the Root Element
+     */
+    public SchemaViewRoot getRoot()
+    {
+        return root;
+    }
+
+
+    /**
+     * Adds the given <element, wrapper> association.
+     *
+     * @param element
+     *      the element
+     * @param wrapper
+     *      the wrapper
+     */
+    public void addElementToWrapper( Object element, TreeNode wrapper )
+    {
+        elementsToWrappersMap.put( element, wrapper );
+    }
+
+
+    /**
+     * Removes the given <element, wrapper> association.
+     *
+     * @param element
+     *      the element
+     * @param wrapper
+     *      the wrapper
+     */
+    public void removeElementToWrapper( Object element, TreeNode wrapper )
+    {
+        elementsToWrappersMap.remove( element, wrapper );
+    }
+
+
+    /**
+     * Remove all <element, wrapper> association for the given element.
+     *
+     * @param element
+     *      the element
+     */
+    public void removeElementToWrapper( Object element )
+    {
+        elementsToWrappersMap.remove( element );
+    }
+
+
+    /**
+     * This method is called when an attribute type is added.
+     *
+     * @param at
+     *      the added attribute type
+     */
+    public void attributeTypeAdded( AttributeTypeImpl at )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            attributeTypeAddedFlatPresentation( at );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            attributeTypeAddedHierarchicalPresentation( at );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is added and the
+     * presentation is set as 'Flat'.
+     *
+     * @param at
+     *      the added attribute type
+     */
+    public void attributeTypeAddedFlatPresentation( AttributeTypeImpl at )
+    {
+        SchemaWrapper schemaWrapper = ( SchemaWrapper ) getWrapper( Activator.getDefault().getSchemaHandler()
+            .getSchema( at.getSchema() ) );
+        if ( schemaWrapper != null )
+        {
+            AttributeTypeWrapper atw = null;
+            int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+            if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+            {
+                for ( TreeNode child : schemaWrapper.getChildren() )
+                {
+                    if ( ( ( Folder ) child ).getType() == FolderType.ATTRIBUTE_TYPE )
+                    {
+                        atw = new AttributeTypeWrapper( at, child );
+                        break;
+                    }
+                }
+            }
+            else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+            {
+                atw = new AttributeTypeWrapper( at, schemaWrapper );
+            }
+
+            atw.getParent().addChild( atw );
+            elementsToWrappersMap.put( at, atw );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is added and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param at
+     *      the added attribute type
+     */
+    public void attributeTypeAddedHierarchicalPresentation( AttributeTypeImpl at )
+    {
+        hierarchyManager.attributeTypeAdded( at );
+
+        List<TreeNode> createdWrappers = new ArrayList<TreeNode>();
+
+        List<Object> parents = hierarchyManager.getParents( at );
+
+        if ( parents != null )
+        {
+            for ( Object parent : parents )
+            {
+                AttributeTypeWrapper parentATW = ( AttributeTypeWrapper ) getWrapper( parent );
+                AttributeTypeWrapper atw = null;
+                if ( parentATW == null )
+                {
+                    int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        for ( TreeNode child : root.getChildren() )
+                        {
+                            if ( child instanceof Folder )
+                            {
+                                Folder folder = ( Folder ) child;
+                                if ( folder.getType().equals( FolderType.ATTRIBUTE_TYPE ) )
+                                {
+                                    atw = new AttributeTypeWrapper( at, folder );
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        atw = new AttributeTypeWrapper( at, root );
+                    }
+
+                }
+                else
+                {
+                    atw = new AttributeTypeWrapper( at, parentATW );
+                }
+                atw.getParent().addChild( atw );
+                createdWrappers.add( atw );
+                elementsToWrappersMap.put( at, atw );
+            }
+        }
+
+        List<Object> children = hierarchyManager.getChildren( at );
+        if ( children != null )
+        {
+            for ( Object child : children )
+            {
+                AttributeTypeWrapper childATW = ( AttributeTypeWrapper ) getWrapper( child );
+                elementsToWrappersMap.remove( child );
+                childATW.getParent().removeChild( childATW );
+
+                for ( TreeNode createdWrapper : createdWrappers )
+                {
+                    AttributeTypeWrapper atw = new AttributeTypeWrapper( ( AttributeTypeImpl ) child, createdWrapper );
+                    atw.getParent().addChild( atw );
+                    elementsToWrappersMap.put( ( AttributeTypeImpl ) child, atw );
+                }
+            }
+        }
+    }
+
+
+    /**
+     * This method is called when an attribute type is modified.
+     *
+     * @param at
+     *      the modified attribute type
+     */
+    public void attributeTypeModified( AttributeTypeImpl at )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            attributeTypeModifiedFlatPresentation( at );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            attributeTypeModifiedHierarchicalPresentation( at );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is modified and the
+     * presentation is set as 'Flat'.
+     *
+     * @param at
+     *      the modified attribute type
+     */
+    public void attributeTypeModifiedFlatPresentation( AttributeTypeImpl at )
+    {
+        // Nothing to do
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is modified and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param at
+     *      the modified attribute type
+     */
+    public void attributeTypeModifiedHierarchicalPresentation( AttributeTypeImpl at )
+    {
+        // Propagating the modification to the hierarchy manager
+        hierarchyManager.attributeTypeModified( at );
+
+        // Removing the Wrappers
+        List<TreeNode> wrappers = getWrappers( at );
+        if ( wrappers != null )
+        {
+            for ( TreeNode wrapper : wrappers )
+            {
+                wrapper.getParent().removeChild( wrapper );
+            }
+
+            elementsToWrappersMap.remove( at );
+        }
+
+        // Creating the wrapper
+        List<Object> parents = hierarchyManager.getParents( at );
+        if ( parents != null )
+        {
+            for ( Object parent : parents )
+            {
+                AttributeTypeWrapper parentATW = ( AttributeTypeWrapper ) getWrapper( parent );
+                AttributeTypeWrapper atw = null;
+                if ( parentATW == null )
+                {
+                    int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        for ( TreeNode child : root.getChildren() )
+                        {
+                            if ( child instanceof Folder )
+                            {
+                                Folder folder = ( Folder ) child;
+                                if ( folder.getType().equals( FolderType.ATTRIBUTE_TYPE ) )
+                                {
+                                    atw = new AttributeTypeWrapper( at, folder );
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        atw = new AttributeTypeWrapper( at, root );
+                    }
+
+                }
+                else
+                {
+                    atw = new AttributeTypeWrapper( at, parentATW );
+                }
+                atw.getParent().addChild( atw );
+                elementsToWrappersMap.put( at, atw );
+                addHierarchyChildren( atw, hierarchyManager.getChildren( at ) );
+            }
+        }
+    }
+
+
+    /**
+     * This method is called when an attribute type is removed.
+     *
+     * @param at
+     *      the removed attribute type
+     */
+    public void attributeTypeRemoved( AttributeTypeImpl at )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            attributeTypeRemovedFlatPresentation( at );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            attributeTypeRemovedHierarchicalPresentation( at );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is removed and the
+     * presentation is set as 'Flat'.
+     *
+     * @param at
+     *      the removed attribute type
+     */
+    private void attributeTypeRemovedFlatPresentation( AttributeTypeImpl at )
+    {
+        AttributeTypeWrapper atw = ( AttributeTypeWrapper ) getWrapper( at );
+        if ( atw != null )
+        {
+            atw.getParent().removeChild( atw );
+            elementsToWrappersMap.remove( at, atw );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an attribute type is removed and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param at
+     *      the removed attribute type
+     */
+    private void attributeTypeRemovedHierarchicalPresentation( AttributeTypeImpl at )
+    {
+        // Creating children nodes of the AT 
+        // and attaching them to the root
+        List<Object> children = hierarchyManager.getChildren( at );
+        if ( children != null )
+        {
+            for ( Object child : children )
+            {
+                AttributeTypeWrapper atw = null;
+                int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                {
+                    for ( TreeNode rootChild : root.getChildren() )
+                    {
+                        if ( rootChild instanceof Folder )
+                        {
+                            Folder folder = ( Folder ) rootChild;
+                            if ( folder.getType().equals( FolderType.ATTRIBUTE_TYPE ) )
+                            {
+                                atw = new AttributeTypeWrapper( ( AttributeTypeImpl ) child, folder );
+                                break;
+                            }
+                        }
+                    }
+                }
+                else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                {
+                    atw = new AttributeTypeWrapper( ( AttributeTypeImpl ) child, root );
+                }
+
+                atw.getParent().addChild( atw );
+                elementsToWrappersMap.put( ( AttributeTypeImpl ) child, atw );
+            }
+        }
+
+        // Removing the Wrappers
+        List<TreeNode> wrappers = getWrappers( at );
+        if ( wrappers != null )
+        {
+            for ( TreeNode wrapper : wrappers )
+            {
+                wrapper.getParent().removeChild( wrapper );
+                removeRecursiveChildren( wrapper );
+            }
+
+            elementsToWrappersMap.remove( at );
+        }
+
+        // Propagating the removal to the hierarchy manager
+        hierarchyManager.attributeTypeRemoved( at );
+    }
+
+
+    /**
+     * Recursively removes the children of the given wrapper.
+     *
+     * @param wrapper
+     *      the wrapper
+     */
+    private void removeRecursiveChildren( TreeNode wrapper )
+    {
+        for ( TreeNode child : wrapper.getChildren() )
+        {
+            if ( child instanceof AttributeTypeWrapper )
+            {
+                AttributeTypeWrapper atw = ( AttributeTypeWrapper ) child;
+                elementsToWrappersMap.remove( atw.getAttributeType(), child );
+                removeRecursiveChildren( atw );
+            }
+            else if ( child instanceof ObjectClassWrapper )
+            {
+                ObjectClassWrapper ocw = ( ObjectClassWrapper ) child;
+                elementsToWrappersMap.remove( ocw.getObjectClass(), child );
+                removeRecursiveChildren( ocw );
+            }
+            else
+            {
+                removeRecursiveChildren( child );
+            }
+        }
+    }
+
+
+    /**
+     * This method is called when an object class is added.
+     *
+     * @param oc
+     *      the added object class
+     */
+    public void objectClassAdded( ObjectClassImpl oc )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            objectClassAddedFlatPresentation( oc );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            objectClassAddedHierarchicalPresentation( oc );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is added and the
+     * presentation is set as 'Flat'.
+     *
+     * @param oc
+     *      the added object class
+     */
+    public void objectClassAddedFlatPresentation( ObjectClassImpl oc )
+    {
+        SchemaWrapper schemaWrapper = ( SchemaWrapper ) getWrapper( Activator.getDefault().getSchemaHandler()
+            .getSchema( oc.getSchema() ) );
+        if ( schemaWrapper != null )
+        {
+            ObjectClassWrapper ocw = null;
+            int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+            if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+            {
+                for ( TreeNode child : schemaWrapper.getChildren() )
+                {
+                    if ( ( ( Folder ) child ).getType() == FolderType.OBJECT_CLASS )
+                    {
+                        ocw = new ObjectClassWrapper( oc, child );
+                        break;
+                    }
+                }
+            }
+            else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+            {
+                ocw = new ObjectClassWrapper( oc, schemaWrapper );
+            }
+
+            ocw.getParent().addChild( ocw );
+            elementsToWrappersMap.put( oc, ocw );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is added and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param oc
+     *      the added object class
+     */
+    public void objectClassAddedHierarchicalPresentation( ObjectClassImpl oc )
+    {
+        // Removing unattached nodes for "top"
+        List<Object> ocChildren = new ArrayList<Object>();
+        List<Object> ocChildren2 = null;
+        if ( "2.5.6.0".equals( oc.getOid() ) )
+        {
+            ocChildren2 = hierarchyManager.getChildren( "2.5.6.0" );
+            if ( ocChildren2 != null )
+            {
+                ocChildren.addAll( ocChildren2 );
+            }
+            ocChildren2 = hierarchyManager.getChildren( "top" );
+            if ( ocChildren2 != null )
+            {
+                ocChildren.addAll( ocChildren2 );
+            }
+        }
+        ocChildren2 = hierarchyManager.getChildren( oc );
+        if ( ocChildren2 != null )
+        {
+            ocChildren.addAll( ocChildren2 );
+        }
+        for ( Object ocChild : ocChildren )
+        {
+            List<TreeNode> wrappers = getWrappers( ocChild );
+            if ( wrappers != null )
+            {
+                for ( TreeNode wrapper : wrappers )
+                {
+                    int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        if ( wrapper.getParent().getParent().equals( root ) )
+                        {
+                            wrapper.getParent().removeChild( wrapper );
+                            elementsToWrappersMap.remove( oc, wrapper );
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        if ( wrapper.getParent().equals( root ) )
+                        {
+                            wrapper.getParent().removeChild( wrapper );
+                            elementsToWrappersMap.remove( oc, wrapper );
+                        }
+                    }
+                    removeRecursiveChildren( wrapper );
+                }
+            }
+        }
+
+        // Propagating the addition to the hierarchy manager
+        hierarchyManager.objectClassAdded( oc );
+
+        List<TreeNode> createdWrappers = new ArrayList<TreeNode>();
+
+        List<Object> parents = hierarchyManager.getParents( oc );
+
+        if ( parents != null )
+        {
+            for ( Object parent : parents )
+            {
+                ObjectClassWrapper parentOCW = ( ObjectClassWrapper ) getWrapper( parent );
+                ObjectClassWrapper ocw = null;
+                if ( parentOCW == null )
+                {
+                    int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        for ( TreeNode child : root.getChildren() )
+                        {
+                            if ( child instanceof Folder )
+                            {
+                                Folder folder = ( Folder ) child;
+                                if ( folder.getType().equals( FolderType.OBJECT_CLASS ) )
+                                {
+                                    ocw = new ObjectClassWrapper( oc, folder );
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        ocw = new ObjectClassWrapper( oc, root );
+                    }
+
+                }
+                else
+                {
+                    ocw = new ObjectClassWrapper( oc, parentOCW );
+                }
+                ocw.getParent().addChild( ocw );
+                createdWrappers.add( ocw );
+                elementsToWrappersMap.put( oc, ocw );
+            }
+        }
+
+        List<Object> children = hierarchyManager.getChildren( oc );
+        if ( children != null )
+        {
+            for ( Object child : children )
+            {
+                List<TreeNode> childOCWs = getWrappers( child );
+                if ( childOCWs != null )
+                {
+                    for ( TreeNode childOCW : childOCWs )
+                    {
+                        if ( root.equals( childOCW.getParent() ) )
+                        {
+                            elementsToWrappersMap.remove( child );
+                            childOCW.getParent().removeChild( childOCW );
+                        }
+                    }
+                }
+
+                for ( TreeNode createdWrapper : createdWrappers )
+                {
+                    ObjectClassWrapper ocw = new ObjectClassWrapper( ( ObjectClassImpl ) child, createdWrapper );
+                    ocw.getParent().addChild( ocw );
+                    elementsToWrappersMap.put( ( ObjectClassImpl ) child, ocw );
+                    addHierarchyChildren( ocw, hierarchyManager.getChildren( child ) );
+                }
+            }
+        }
+    }
+
+
+    /**
+     * This method is called when an object class is modified.
+     *
+     * @param oc
+     *      the modified object class
+     */
+    public void objectClassModified( ObjectClassImpl oc )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            objectClassModifiedFlatPresentation( oc );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            objectClassModifiedHierarchicalPresentation( oc );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is modified and the
+     * presentation is set as 'Flat'.
+     *
+     * @param oc
+     *      the modified object class
+     */
+    public void objectClassModifiedFlatPresentation( ObjectClassImpl oc )
+    {
+        // Nothing to do
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is modified and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param oc
+     *      the modified object class
+     */
+    public void objectClassModifiedHierarchicalPresentation( ObjectClassImpl oc )
+    {
+        // Propagating the modification to the hierarchy manager
+        hierarchyManager.objectClassModified( oc );
+
+        // Removing the Wrappers
+        List<TreeNode> wrappers = getWrappers( oc );
+        if ( wrappers != null )
+        {
+            for ( TreeNode wrapper : wrappers )
+            {
+                wrapper.getParent().removeChild( wrapper );
+            }
+
+            elementsToWrappersMap.remove( oc );
+        }
+
+        // Creating the wrapper
+        List<Object> parents = hierarchyManager.getParents( oc );
+        if ( parents != null )
+        {
+            for ( Object parent : parents )
+            {
+                ObjectClassWrapper parentOCW = ( ObjectClassWrapper ) getWrapper( parent );
+                ObjectClassWrapper ocw = null;
+                if ( parentOCW == null )
+                {
+                    int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                    if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                    {
+                        for ( TreeNode child : root.getChildren() )
+                        {
+                            if ( child instanceof Folder )
+                            {
+                                Folder folder = ( Folder ) child;
+                                if ( folder.getType().equals( FolderType.ATTRIBUTE_TYPE ) )
+                                {
+                                    ocw = new ObjectClassWrapper( oc, folder );
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                    {
+                        ocw = new ObjectClassWrapper( oc, root );
+                    }
+
+                }
+                else
+                {
+                    ocw = new ObjectClassWrapper( oc, parentOCW );
+                }
+                ocw.getParent().addChild( ocw );
+                elementsToWrappersMap.put( oc, ocw );
+                addHierarchyChildren( ocw, hierarchyManager.getChildren( oc ) );
+            }
+        }
+    }
+
+
+    /**
+     * This method is called when an object class is removed.
+     *
+     * @param oc
+     *      the removed object class
+     */
+    public void objectClassRemoved( ObjectClassImpl oc )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            objectClassRemovedFlatPresentation( oc );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            objectClassRemovedHierarchicalPresentation( oc );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is removed and the
+     * presentation is set as 'Flat'.
+     *
+     * @param oc
+     *      the removed object class
+     */
+    public void objectClassRemovedFlatPresentation( ObjectClassImpl oc )
+    {
+        ObjectClassWrapper ocw = ( ObjectClassWrapper ) getWrapper( oc );
+        if ( ocw != null )
+        {
+            ocw.getParent().removeChild( ocw );
+            elementsToWrappersMap.remove( oc, ocw );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when an object class is removed and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param oc
+     *      the removed object class
+     */
+    public void objectClassRemovedHierarchicalPresentation( ObjectClassImpl oc )
+    {
+        // Creating children nodes of the OC 
+        // and attaching them to the root
+        List<Object> children = hierarchyManager.getChildren( oc );
+        if ( children != null )
+        {
+            for ( Object child : children )
+            {
+                ObjectClassWrapper ocw = null;
+                int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+                if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+                {
+                    for ( TreeNode rootChild : root.getChildren() )
+                    {
+                        if ( rootChild instanceof Folder )
+                        {
+                            Folder folder = ( Folder ) rootChild;
+                            if ( folder.getType().equals( FolderType.OBJECT_CLASS ) )
+                            {
+                                ocw = new ObjectClassWrapper( ( ObjectClassImpl ) child, folder );
+                                break;
+                            }
+                        }
+                    }
+                }
+                else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+                {
+                    ocw = new ObjectClassWrapper( ( ObjectClassImpl ) child, root );
+                }
+
+                ocw.getParent().addChild( ocw );
+                elementsToWrappersMap.put( ( ObjectClassImpl ) child, ocw );
+                addHierarchyChildren( ocw, hierarchyManager.getChildren( child ) );
+            }
+        }
+
+        // Removing the Wrappers
+        List<TreeNode> wrappers = getWrappers( oc );
+        if ( wrappers != null )
+        {
+            for ( TreeNode wrapper : wrappers )
+            {
+                wrapper.getParent().removeChild( wrapper );
+                removeRecursiveChildren( wrapper );
+            }
+
+            elementsToWrappersMap.remove( oc );
+        }
+
+        // Propagating the removal to the hierarchy manager
+        hierarchyManager.objectClassRemoved( oc );
+    }
+
+
+    /**
+     * This method is called when a schema is added.
+     *
+     * @param schema
+     *      the added schema
+     */
+    public void schemaAdded( Schema schema )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            schemaAddedFlatPresentation( schema );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            schemaAddedHierarchicalPresentation( schema );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when a schema is added and the
+     * presentation is set as 'Flat'.
+     *
+     * @param oc
+     *      the added schema
+     */
+    private void schemaAddedFlatPresentation( Schema schema )
+    {
+        addSchemaFlatPresentation( schema );
+    }
+
+
+    /**
+     * Updates the TreeNodes when a schema is added and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param oc
+     *      the added schema
+     */
+    private void schemaAddedHierarchicalPresentation( Schema schema )
+    {
+        for ( AttributeTypeImpl at : schema.getAttributeTypes() )
+        {
+            attributeTypeAddedHierarchicalPresentation( at );
+        }
+
+        for ( ObjectClassImpl oc : schema.getObjectClasses() )
+        {
+            objectClassAddedHierarchicalPresentation( oc );
+        }
+    }
+
+
+    /**
+     * This method is called when a schema is removed.
+     *
+     * @param schema
+     *      the removed schema
+     */
+    public void schemaRemoved( Schema schema )
+    {
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+        {
+            schemaRemovedFlatPresentation( schema );
+        }
+        else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            schemaRemovedHierarchicalPresentation( schema );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when a schema is removed and the
+     * presentation is set as 'Flat'.
+     *
+     * @param schema
+     *      the removed schema
+     */
+    private void schemaRemovedFlatPresentation( Schema schema )
+    {
+        SchemaWrapper sw = ( SchemaWrapper ) getWrapper( schema );
+        if ( sw != null )
+        {
+            sw.getParent().removeChild( sw );
+            elementsToWrappersMap.remove( schema, sw );
+            removeRecursiveChildren( sw );
+        }
+    }
+
+
+    /**
+     * Updates the TreeNodes when a schema is removed and the
+     * presentation is set as 'Hierarchical'.
+     *
+     * @param schema
+     *      the removed schema
+     */
+    private void schemaRemovedHierarchicalPresentation( Schema schema )
+    {
+        for ( AttributeTypeImpl at : schema.getAttributeTypes() )
+        {
+            attributeTypeRemovedHierarchicalPresentation( at );
+        }
+
+        for ( ObjectClassImpl oc : schema.getObjectClasses() )
+        {
+            objectClassRemovedHierarchicalPresentation( oc );
+        }
+    }
+
+
+    /**
+     * Adds a schema in 'Flat' Presentation.
+     *
+     * @param schema
+     */
+    public void addSchemaFlatPresentation( Schema schema )
+    {
+        SchemaWrapper schemaWrapper = new SchemaWrapper( schema, root );
+        root.addChild( schemaWrapper );
+        elementsToWrappersMap.put( schema, schemaWrapper );
+
+        int group = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+        if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+        {
+            Folder atFolder = new Folder( FolderType.ATTRIBUTE_TYPE, schemaWrapper );
+            schemaWrapper.addChild( atFolder );
+
+            for ( AttributeTypeImpl attributeType : schema.getAttributeTypes() )
+            {
+                AttributeTypeWrapper atw = new AttributeTypeWrapper( attributeType, atFolder );
+                atw.getParent().addChild( atw );
+                elementsToWrappersMap.put( attributeType, atw );
+            }
+
+            Folder ocFolder = new Folder( FolderType.OBJECT_CLASS, schemaWrapper );
+            schemaWrapper.addChild( ocFolder );
+
+            for ( ObjectClassImpl objectClass : schema.getObjectClasses() )
+            {
+                ObjectClassWrapper ocw = new ObjectClassWrapper( objectClass, ocFolder );
+                ocw.getParent().addChild( ocw );
+                elementsToWrappersMap.put( objectClass, ocw );
+            }
+        }
+        else if ( group == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+        {
+            for ( AttributeTypeImpl attributeType : schema.getAttributeTypes() )
+            {
+                AttributeTypeWrapper atw = new AttributeTypeWrapper( attributeType, schemaWrapper );
+                atw.getParent().addChild( atw );
+                elementsToWrappersMap.put( attributeType, atw );
+            }
+
+            for ( ObjectClassImpl objectClass : schema.getObjectClasses() )
+            {
+                ObjectClassWrapper ocw = new ObjectClassWrapper( objectClass, schemaWrapper );
+                ocw.getParent().addChild( ocw );
+                elementsToWrappersMap.put( objectClass, ocw );
+            }
+        }
+    }
+}

Propchange: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewContentProvider.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewLabelProvider.java
URL: http://svn.apache.org/viewvc/directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewLabelProvider.java?rev=592094&view=auto
==============================================================================
--- directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewLabelProvider.java (added)
+++ directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewLabelProvider.java Mon Nov  5 09:14:24 2007
@@ -0,0 +1,360 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+package org.apache.directory.studio.schemaeditor.view.views;
+
+
+import java.util.List;
+
+import org.apache.directory.studio.schemaeditor.Activator;
+import org.apache.directory.studio.schemaeditor.PluginConstants;
+import org.apache.directory.studio.schemaeditor.model.AttributeTypeImpl;
+import org.apache.directory.studio.schemaeditor.model.ObjectClassImpl;
+import org.apache.directory.studio.schemaeditor.view.ViewUtils;
+import org.apache.directory.studio.schemaeditor.view.wrappers.AttributeTypeWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.Folder;
+import org.apache.directory.studio.schemaeditor.view.wrappers.ObjectClassWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.SchemaWrapper;
+import org.apache.directory.studio.schemaeditor.view.wrappers.TreeNode;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+
+
+/**
+ * This class implements the LabelProvider for the SchemaView.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$, $Date$
+ */
+public class SchemaViewLabelProvider extends LabelProvider
+{
+    private static final String NONE = "(None)";
+
+    /** The preferences store */
+    private IPreferenceStore store;
+
+
+    /**
+     * Creates a new instance of DifferencesWidgetSchemaLabelProvider.
+     */
+    public SchemaViewLabelProvider()
+    {
+        store = Activator.getDefault().getPreferenceStore();
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
+     */
+    public String getText( Object element )
+    {
+        String label = ""; //$NON-NLS-1$
+
+        int presentation = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION );
+        int labelValue = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_LABEL );
+        boolean abbreviate = store.getBoolean( PluginConstants.PREFS_SCHEMA_VIEW_ABBREVIATE );
+        int abbreviateMaxLength = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_ABBREVIATE_MAX_LENGTH );
+        boolean secondaryLabelDisplay = store.getBoolean( PluginConstants.PREFS_SCHEMA_VIEW_SECONDARY_LABEL_DISPLAY );
+        int secondaryLabelValue = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SECONDARY_LABEL );
+        boolean secondaryLabelAbbreviate = store
+            .getBoolean( PluginConstants.PREFS_SCHEMA_VIEW_SECONDARY_LABEL_ABBREVIATE );
+        int secondaryLabelAbbreviateMaxLength = store
+            .getInt( PluginConstants.PREFS_SCHEMA_VIEW_SECONDARY_LABEL_ABBREVIATE_MAX_LENGTH );
+        boolean schemaLabelDisplay = store.getBoolean( PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_LABEL_DISPLAY );
+
+        if ( element instanceof SchemaWrapper )
+        {
+            SchemaWrapper sw = ( SchemaWrapper ) element;
+
+            return sw.getSchema().getName();
+        }
+        else if ( element instanceof AttributeTypeWrapper )
+        {
+            AttributeTypeImpl at = ( ( AttributeTypeWrapper ) element ).getAttributeType();
+
+            // Label
+            if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_FIRST_NAME )
+            {
+                String[] names = at.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = names[0];
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+            else if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_ALL_ALIASES )
+            {
+                String[] names = at.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = ViewUtils.concateAliases( names );
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+            else if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_OID )
+            {
+                label = at.getOid();
+            }
+            else
+            // Default
+            {
+                String[] names = at.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = names[0];
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+
+            // Abbreviate
+            if ( abbreviate && ( abbreviateMaxLength < label.length() ) )
+            {
+                label = label.substring( 0, abbreviateMaxLength ) + "..."; //$NON-NLS-1$
+            }
+        }
+        else if ( element instanceof ObjectClassWrapper )
+        {
+            ObjectClassImpl oc = ( ( ObjectClassWrapper ) element ).getObjectClass();
+
+            // Label
+            if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_FIRST_NAME )
+            {
+                String[] names = oc.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = names[0];
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+            else if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_ALL_ALIASES )
+            {
+                String[] names = oc.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = ViewUtils.concateAliases( names );
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+            else if ( labelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_OID )
+            {
+                label = oc.getOid();
+            }
+            else
+            // Default
+            {
+                String[] names = oc.getNames();
+                if ( ( names != null ) && ( names.length > 0 ) )
+                {
+                    label = names[0];
+                }
+                else
+                {
+                    label = NONE;
+                }
+            }
+
+            // Abbreviate
+            if ( abbreviate && ( abbreviateMaxLength < label.length() ) )
+            {
+                label = label.substring( 0, abbreviateMaxLength ) + "..."; //$NON-NLS-1$
+            }
+        }
+        else if ( element instanceof Folder )
+        {
+            Folder folder = ( Folder ) element;
+
+            if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_FLAT )
+            {
+                return folder.getName() + " (" + folder.getChildren().size() + ")";
+            }
+            else if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+            {
+                return folder.getName();
+            }
+        }
+
+        // Secondary Label
+        if ( secondaryLabelDisplay )
+        {
+            String secondaryLabel = ""; //$NON-NLS-1$
+            if ( element instanceof AttributeTypeWrapper )
+            {
+                AttributeTypeImpl at = ( ( AttributeTypeWrapper ) element ).getAttributeType();
+
+                if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_FIRST_NAME )
+                {
+                    String[] names = at.getNames();
+                    if ( ( names != null ) && ( names.length > 0 ) )
+                    {
+                        secondaryLabel = names[0];
+                    }
+                    else
+                    {
+                        secondaryLabel = NONE;
+                    }
+                }
+                else if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_ALL_ALIASES )
+                {
+                    String[] names = at.getNames();
+                    if ( ( names != null ) && ( names.length > 0 ) )
+                    {
+                        secondaryLabel = ViewUtils.concateAliases( names );
+                    }
+                    else
+                    {
+                        secondaryLabel = NONE;
+                    }
+                }
+                else if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_OID )
+                {
+                    secondaryLabel = at.getOid();
+                }
+            }
+            else if ( element instanceof ObjectClassWrapper )
+            {
+                ObjectClassImpl oc = ( ( ObjectClassWrapper ) element ).getObjectClass();
+
+                if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_FIRST_NAME )
+                {
+                    String[] names = oc.getNames();
+                    if ( ( names != null ) && ( names.length > 0 ) )
+                    {
+                        secondaryLabel = names[0];
+                    }
+                    else
+                    {
+                        secondaryLabel = NONE;
+                    }
+                }
+                else if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_ALL_ALIASES )
+                {
+                    String[] names = oc.getNames();
+                    if ( ( names != null ) && ( names.length > 0 ) )
+                    {
+                        secondaryLabel = ViewUtils.concateAliases( names );
+                    }
+                    else
+                    {
+                        secondaryLabel = NONE;
+                    }
+                }
+                else if ( secondaryLabelValue == PluginConstants.PREFS_SCHEMA_VIEW_LABEL_OID )
+                {
+                    secondaryLabel = oc.getOid();
+                }
+            }
+
+            if ( secondaryLabelAbbreviate && ( secondaryLabelAbbreviateMaxLength < secondaryLabel.length() ) )
+            {
+                secondaryLabel = secondaryLabel.substring( 0, secondaryLabelAbbreviateMaxLength ) + "..."; //$NON-NLS-1$
+            }
+
+            label += "  [" + secondaryLabel + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+        }
+
+        // Number of children
+        if ( presentation == PluginConstants.PREFS_SCHEMA_VIEW_SCHEMA_PRESENTATION_HIERARCHICAL )
+        {
+            if ( ( element instanceof AttributeTypeWrapper ) || ( element instanceof ObjectClassWrapper ) )
+            {
+                List<TreeNode> children = ( ( TreeNode ) element ).getChildren();
+
+                if ( ( children != null ) && ( children.size() > 0 ) )
+                {
+                    label += "  (" + children.size() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
+                }
+            }
+        }
+
+        // Schema Label
+        if ( schemaLabelDisplay )
+        {
+            if ( element instanceof AttributeTypeWrapper )
+            {
+                label += "  [" + ( ( AttributeTypeWrapper ) element ).getAttributeType().getSchema() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+            }
+            else if ( element instanceof ObjectClassWrapper )
+            {
+                label += "  [" + ( ( ObjectClassWrapper ) element ).getObjectClass().getSchema() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
+            }
+        }
+
+        return label;
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
+     */
+    public Image getImage( Object element )
+    {
+        if ( element instanceof SchemaWrapper )
+        {
+            return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID, PluginConstants.IMG_SCHEMA )
+                .createImage();
+        }
+        else if ( element instanceof AttributeTypeWrapper )
+        {
+            return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID, PluginConstants.IMG_ATTRIBUTE_TYPE )
+                .createImage();
+        }
+        else if ( element instanceof ObjectClassWrapper )
+        {
+            return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID, PluginConstants.IMG_OBJECT_CLASS )
+                .createImage();
+        }
+        else if ( element instanceof Folder )
+        {
+            Folder folder = ( Folder ) element;
+
+            switch ( folder.getType() )
+            {
+                case ATTRIBUTE_TYPE:
+                    return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID,
+                        PluginConstants.IMG_FOLDER_AT ).createImage();
+                case OBJECT_CLASS:
+                    return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID,
+                        PluginConstants.IMG_FOLDER_OC ).createImage();
+                case NONE:
+                    return AbstractUIPlugin.imageDescriptorFromPlugin( Activator.PLUGIN_ID, PluginConstants.IMG_FOLDER )
+                        .createImage();
+            }
+        }
+
+        // Default
+        return null;
+    }
+}

Propchange: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewLabelProvider.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewSortingDialog.java
URL: http://svn.apache.org/viewvc/directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewSortingDialog.java?rev=592094&view=auto
==============================================================================
--- directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewSortingDialog.java (added)
+++ directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewSortingDialog.java Mon Nov  5 09:14:24 2007
@@ -0,0 +1,235 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+
+package org.apache.directory.studio.schemaeditor.view.views;
+
+
+import org.apache.directory.studio.schemaeditor.Activator;
+import org.apache.directory.studio.schemaeditor.PluginConstants;
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+
+
+/**
+ * This class implements the SchemaView Sorting Dialog.
+ *
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ * @version $Rev$, $Date$
+ */
+public class SchemaViewSortingDialog extends Dialog
+{
+    /** The title of the dialog */
+    private static final String DIALOG_TITLE = "Schema View Sorting";
+
+    /** The Sorting First Name category */
+    private static final String SORTING_FISTNAME = "First Name";
+
+    /** The Sorting OID category */
+    private static final String SORTING_OID = "OID";
+
+    // UI Fields
+    private Button inFoldersButton;
+    private Button mixedButton;
+    private Combo sortingCombo;
+    private Button ascendingButton;
+    private Button descendingButton;
+
+
+    /**
+     * Creates a new instance of SchemasViewSorterDialog.
+     *
+     * @param parentShell
+     *      the parent shell
+     */
+    public SchemaViewSortingDialog( Shell parentShell )
+    {
+        super( parentShell );
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)
+     */
+    protected void configureShell( Shell newShell )
+    {
+        super.configureShell( newShell );
+        newShell.setText( DIALOG_TITLE );
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
+     */
+    protected Control createDialogArea( Composite parent )
+    {
+        Composite composite = ( Composite ) super.createDialogArea( parent );
+        composite.setLayoutData( new GridData( SWT.FILL, SWT.FILL, true, true ) );
+
+        // Grouping Group
+        Group groupingGroup = new Group( composite, SWT.NONE );
+        groupingGroup.setLayoutData( new GridData( SWT.FILL, SWT.FILL, true, true ) );
+        groupingGroup.setText( "Grouping" );
+        groupingGroup.setLayout( new GridLayout() );
+
+        // Attribute Types first Button
+        inFoldersButton = new Button( groupingGroup, SWT.RADIO );
+        inFoldersButton.setText( "Group attribute types and object classes in folders" );
+        inFoldersButton.setEnabled( true );
+
+        // Mixed Button
+        mixedButton = new Button( groupingGroup, SWT.RADIO );
+        mixedButton.setText( "Mixed" );
+        mixedButton.setEnabled( true );
+
+        // Sorting Group
+        Group sortingGroup = new Group( composite, SWT.NONE );
+        sortingGroup.setLayoutData( new GridData( SWT.FILL, SWT.FILL, true, true ) );
+        sortingGroup.setText( "Sorting" );
+        sortingGroup.setLayout( new GridLayout() );
+        Composite sortingGroupComposite = new Composite( sortingGroup, SWT.NONE );
+        GridLayout gl = new GridLayout( 4, false );
+        gl.marginHeight = gl.marginWidth = 0;
+        sortingGroupComposite.setLayout( gl );
+        sortingGroupComposite.setLayoutData( new GridData( SWT.FILL, SWT.NONE, true, false ) );
+
+        // Sort by Label
+        Label sortByLabel = new Label( sortingGroupComposite, SWT.NONE );
+        sortByLabel.setText( "Sort by" );
+
+        // Sorting Combo
+        sortingCombo = new Combo( sortingGroupComposite, SWT.DROP_DOWN | SWT.READ_ONLY | SWT.BORDER );
+        sortingCombo.setLayoutData( new GridData( SWT.FILL, SWT.NONE, true, false ) );
+        sortingCombo.setItems( new String[]
+            { SORTING_FISTNAME, SORTING_OID } );
+        sortingCombo.setEnabled( true );
+
+        // Ascending Button
+        ascendingButton = new Button( sortingGroupComposite, SWT.RADIO );
+        ascendingButton.setText( "Ascending" );
+        ascendingButton.setEnabled( true );
+
+        // Descending Button
+        descendingButton = new Button( sortingGroupComposite, SWT.RADIO );
+        descendingButton.setText( "Descending" );
+        descendingButton.setEnabled( true );
+
+        initFieldsFromPreferences();
+
+        applyDialogFont( composite );
+        return composite;
+    }
+
+
+    /**
+     * Initializes the fields for the stored preferences.
+     */
+    private void initFieldsFromPreferences()
+    {
+        IPreferenceStore store = Activator.getDefault().getPreferenceStore();
+
+        int grouping = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING );
+        if ( grouping == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS )
+        {
+            inFoldersButton.setSelection( true );
+        }
+        else if ( grouping == PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED )
+        {
+            mixedButton.setSelection( true );
+        }
+
+        int sortingBy = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY );
+        if ( sortingBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME )
+        {
+            sortingCombo.select( 0 );
+        }
+        else if ( sortingBy == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID )
+        {
+            sortingCombo.select( 1 );
+        }
+
+        int sortingOrder = store.getInt( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER );
+        if ( sortingOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_ASCENDING )
+        {
+            ascendingButton.setSelection( true );
+        }
+        else if ( sortingOrder == PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING )
+        {
+            descendingButton.setSelection( true );
+        }
+
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.eclipse.jface.dialogs.Dialog#buttonPressed(int)
+     */
+    protected void buttonPressed( int buttonId )
+    {
+        if ( buttonId == IDialogConstants.OK_ID )
+        {
+            IPreferenceStore store = Activator.getDefault().getPreferenceStore();
+            if ( ( inFoldersButton.getSelection() ) && ( !mixedButton.getSelection() ) )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING,
+                    PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_FOLDERS );
+            }
+            else if ( ( !inFoldersButton.getSelection() ) && ( mixedButton.getSelection() ) )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_GROUPING,
+                    PluginConstants.PREFS_SCHEMA_VIEW_GROUPING_MIXED );
+            }
+
+            if ( sortingCombo.getItem( sortingCombo.getSelectionIndex() ).equals( SORTING_FISTNAME ) )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY,
+                    PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_FIRSTNAME );
+            }
+            else if ( sortingCombo.getItem( sortingCombo.getSelectionIndex() ).equals( SORTING_OID ) )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY,
+                    PluginConstants.PREFS_SCHEMA_VIEW_SORTING_BY_OID );
+            }
+
+            if ( ascendingButton.getSelection() && !descendingButton.getSelection() )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER,
+                    PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_ASCENDING );
+            }
+            else if ( !ascendingButton.getSelection() && descendingButton.getSelection() )
+            {
+                store.setValue( PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER,
+                    PluginConstants.PREFS_SCHEMA_VIEW_SORTING_ORDER_DESCENDING );
+            }
+        }
+
+        super.buttonPressed( buttonId );
+    }
+}

Propchange: directory/sandbox/felixk/studio-schemaeditor/src/main/java/org/apache/directory/studio/schemaeditor/view/views/SchemaViewSortingDialog.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message