Expanded tabs into spaces

1 files changed, 374 insertions, 374 deletions

diff --git a/java/src/IceGridGUI/Application/ServerInstance.java b/java/src/IceGridGUI/Application/ServerInstance.java
index 8e2d7388fc3..5d8fd9a23d9 100755
--- a/java/src/IceGridGUI/Application/ServerInstance.java
+++ b/java/src/IceGridGUI/Application/ServerInstance.java
@@ -26,8 +26,8 @@ class ServerInstance extends ListTreeNode implements Server, PropertySetParent
     copyDescriptor(ServerInstanceDescriptor sid)
     {
         ServerInstanceDescriptor copy = (ServerInstanceDescriptor)sid.clone();
-	copy.propertySet = PropertySet.copyDescriptor(copy.propertySet);
-	return copy;
+        copy.propertySet = PropertySet.copyDescriptor(copy.propertySet);
+        return copy;
     }
     
     //
@@ -35,7 +35,7 @@ class ServerInstance extends ListTreeNode implements Server, PropertySetParent
     //
     public boolean getAllowsChildren()
     {
-	return _isIceBox;
+        return _isIceBox;
     }
 
     //
@@ -43,519 +43,519 @@ class ServerInstance extends ListTreeNode implements Server, PropertySetParent
     //
     public boolean[] getAvailableActions()
     {
-	boolean[] actions = new boolean[ACTION_COUNT];
-	actions[COPY] = !_ephemeral;
-	
-	Object clipboard = getCoordinator().getClipboard();
-	if(clipboard != null && 
-	   (clipboard instanceof ServerDescriptor
-	    || clipboard instanceof ServerInstanceDescriptor
-	    || (_isIceBox && clipboard instanceof PropertySetDescriptor)))
-	{
-	    actions[PASTE] = true;
-	}
-
-	actions[DELETE] = true;
-	if(!_ephemeral)
-	{
-	    actions[SHOW_VARS] = true;
-	    actions[SUBSTITUTE_VARS] = true;
-	    
-	    if(_isIceBox)
-	    {
-		actions[NEW_PROPERTY_SET] = true;
-	    }
-	}
-	
-	return actions;
+        boolean[] actions = new boolean[ACTION_COUNT];
+        actions[COPY] = !_ephemeral;
+        
+        Object clipboard = getCoordinator().getClipboard();
+        if(clipboard != null && 
+           (clipboard instanceof ServerDescriptor
+            || clipboard instanceof ServerInstanceDescriptor
+            || (_isIceBox && clipboard instanceof PropertySetDescriptor)))
+        {
+            actions[PASTE] = true;
+        }
+
+        actions[DELETE] = true;
+        if(!_ephemeral)
+        {
+            actions[SHOW_VARS] = true;
+            actions[SUBSTITUTE_VARS] = true;
+            
+            if(_isIceBox)
+            {
+                actions[NEW_PROPERTY_SET] = true;
+            }
+        }
+        
+        return actions;
     }
     
     public void copy()
     {
-	getCoordinator().setClipboard(copyDescriptor(_descriptor));
-	getCoordinator().getActionsForMenu().get(PASTE).setEnabled(true);
+        getCoordinator().setClipboard(copyDescriptor(_descriptor));
+        getCoordinator().getActionsForMenu().get(PASTE).setEnabled(true);
     }
 
     public void paste()
     {
-	if(_isIceBox)
-	{
-	    Object descriptor =  getCoordinator().getClipboard();
-	    if(descriptor instanceof PropertySetDescriptor)
-	    {
-		newPropertySet(PropertySet.copyDescriptor((PropertySetDescriptor)descriptor));
-		return;
-	    }
-	}
+        if(_isIceBox)
+        {
+            Object descriptor =  getCoordinator().getClipboard();
+            if(descriptor instanceof PropertySetDescriptor)
+            {
+                newPropertySet(PropertySet.copyDescriptor((PropertySetDescriptor)descriptor));
+                return;
+            }
+        }
 
-	((TreeNode)_parent).paste();
+        ((TreeNode)_parent).paste();
     }
     
     public void newPropertySet()
     {
-	newPropertySet(new PropertySetDescriptor(
-			   new String[0], new java.util.LinkedList()));
+        newPropertySet(new PropertySetDescriptor(
+                           new String[0], new java.util.LinkedList()));
     }
 
 
     public JPopupMenu getPopupMenu()
     {
-	if(_isIceBox)
-	{
-	    ApplicationActions actions = getCoordinator().getActionsForPopup();
-	    if(_popup == null)
-	    {
-		_popup = new JPopupMenu();
-		_popup.add(actions.get(NEW_PROPERTY_SET));
-	    }
-	    actions.setTarget(this);
-	    return _popup;
-	}
-	else
-	{
-	    return null;
-	}
+        if(_isIceBox)
+        {
+            ApplicationActions actions = getCoordinator().getActionsForPopup();
+            if(_popup == null)
+            {
+                _popup = new JPopupMenu();
+                _popup.add(actions.get(NEW_PROPERTY_SET));
+            }
+            actions.setTarget(this);
+            return _popup;
+        }
+        else
+        {
+            return null;
+        }
     }
 
     public Editor getEditor()
     {
-	if(_editor == null)
-	{
-	    _editor = (ServerInstanceEditor)
-		getRoot().getEditor(ServerInstanceEditor.class, this);
-	}
-	_editor.show(this);
-	return _editor;
+        if(_editor == null)
+        {
+            _editor = (ServerInstanceEditor)
+                getRoot().getEditor(ServerInstanceEditor.class, this);
+        }
+        _editor.show(this);
+        return _editor;
     }
 
     protected Editor createEditor()
     {
-	return new ServerInstanceEditor();
+        return new ServerInstanceEditor();
     }
-	
+        
     public Component getTreeCellRendererComponent(
-	    JTree tree,
-	    Object value,
-	    boolean sel,
-	    boolean expanded,
-	    boolean leaf,
-	    int row,
-	    boolean hasFocus) 
-    {
-	if(_cellRenderer == null)
-	{
-	    //
-	    // Initialization
-	    //
-	    _cellRenderer = new DefaultTreeCellRenderer();
-
-	    _serverIcon = Utils.getIcon("/icons/16x16/server_inactive.png");
-	    _iceboxServerIcon = Utils.getIcon("/icons/16x16/icebox_server_inactive.png");
-	    
-	    _cellRenderer.setLeafIcon(_serverIcon);
-	    _cellRenderer.setOpenIcon(_iceboxServerIcon);
-	    _cellRenderer.setClosedIcon(_iceboxServerIcon);
-	}
-
-	return _cellRenderer.getTreeCellRendererComponent(
-	    tree, value, sel, expanded, leaf, row, hasFocus);
+            JTree tree,
+            Object value,
+            boolean sel,
+            boolean expanded,
+            boolean leaf,
+            int row,
+            boolean hasFocus) 
+    {
+        if(_cellRenderer == null)
+        {
+            //
+            // Initialization
+            //
+            _cellRenderer = new DefaultTreeCellRenderer();
+
+            _serverIcon = Utils.getIcon("/icons/16x16/server_inactive.png");
+            _iceboxServerIcon = Utils.getIcon("/icons/16x16/icebox_server_inactive.png");
+            
+            _cellRenderer.setLeafIcon(_serverIcon);
+            _cellRenderer.setOpenIcon(_iceboxServerIcon);
+            _cellRenderer.setClosedIcon(_iceboxServerIcon);
+        }
+
+        return _cellRenderer.getTreeCellRendererComponent(
+            tree, value, sel, expanded, leaf, row, hasFocus);
     }
 
     public void destroy()
     {
-	Node node = (Node)_parent;
-	
-	if(_ephemeral)
-	{
-	    node.removeServer(this);
-	}
-	else
-	{
-	    node.removeDescriptor(_descriptor);
-	    node.removeServer(this);
-	    node.getEditable().removeElement(_id, _editable, Server.class);
-	    getRoot().updated();
-	}
+        Node node = (Node)_parent;
+        
+        if(_ephemeral)
+        {
+            node.removeServer(this);
+        }
+        else
+        {
+            node.removeDescriptor(_descriptor);
+            node.removeServer(this);
+            node.getEditable().removeElement(_id, _editable, Server.class);
+            getRoot().updated();
+        }
     }
 
 
     public Object getDescriptor()
     {
-	return _descriptor;
+        return _descriptor;
     }
 
     public Object saveDescriptor()
     {
-	return _descriptor.clone();
+        return _descriptor.clone();
     }
 
     public void restoreDescriptor(Object savedDescriptor)
     {
-	ServerInstanceDescriptor copy = (ServerInstanceDescriptor)savedDescriptor;
+        ServerInstanceDescriptor copy = (ServerInstanceDescriptor)savedDescriptor;
 
-	_descriptor.template = copy.template;
-	_descriptor.parameterValues = copy.parameterValues;
-	_descriptor.propertySet = copy.propertySet;
+        _descriptor.template = copy.template;
+        _descriptor.parameterValues = copy.parameterValues;
+        _descriptor.propertySet = copy.propertySet;
     }
 
     //
     // Builds the server and all its sub-tree
     //
     ServerInstance(boolean brandNew, TreeNode parent, String serverId, 
-		   Utils.Resolver resolver, 
-		   ServerInstanceDescriptor instanceDescriptor,
-		   boolean isIceBox) 
-	throws UpdateFailedException
+                   Utils.Resolver resolver, 
+                   ServerInstanceDescriptor instanceDescriptor,
+                   boolean isIceBox) 
+        throws UpdateFailedException
     {
-	super(brandNew, parent, serverId);
-	_ephemeral = false;
-	rebuild(resolver, instanceDescriptor, isIceBox);
+        super(brandNew, parent, serverId);
+        _ephemeral = false;
+        rebuild(resolver, instanceDescriptor, isIceBox);
     }
 
     ServerInstance(TreeNode parent, String serverId, 
-		   ServerInstanceDescriptor instanceDescriptor)
+                   ServerInstanceDescriptor instanceDescriptor)
     {
-	super(false, parent, serverId);
-	_ephemeral = true;
-	try
-	{
-	    rebuild(null, instanceDescriptor, false);
-	}
-	catch(UpdateFailedException e)
-	{
-	    assert false;
-	}
+        super(false, parent, serverId);
+        _ephemeral = true;
+        try
+        {
+            rebuild(null, instanceDescriptor, false);
+        }
+        catch(UpdateFailedException e)
+        {
+            assert false;
+        }
     }
 
     void write(XMLWriter writer) throws java.io.IOException
     {
-	if(!_ephemeral)
-	{
-	    TemplateDescriptor templateDescriptor 
-		= getRoot().findServerTemplateDescriptor(_descriptor.template);
-	    
-	    java.util.LinkedList attributes = parameterValuesToAttributes(
-		_descriptor.parameterValues, templateDescriptor.parameters);
-	    attributes.addFirst(createAttribute("template", _descriptor.template));
-		
-	    if(_descriptor.propertySet.references.length == 0 &&
-	       _descriptor.propertySet.properties.size() == 0 &&
-	       _children.size() == 0)
-	    {
-		writer.writeElement("server-instance", attributes);
-	    }
-	    else
-	    {
-		writer.writeStartTag("server-instance", attributes);
-		writePropertySet(writer, _descriptor.propertySet, null, null);
-		
-		java.util.Iterator p = _children.iterator();
-		while(p.hasNext())
-		{
-		    PropertySet ps = (PropertySet)p.next();
-		    ps.write(writer);
-		}
-
-		writer.writeEndTag("server-instance");
-	    }
-	}
+        if(!_ephemeral)
+        {
+            TemplateDescriptor templateDescriptor 
+                = getRoot().findServerTemplateDescriptor(_descriptor.template);
+            
+            java.util.LinkedList attributes = parameterValuesToAttributes(
+                _descriptor.parameterValues, templateDescriptor.parameters);
+            attributes.addFirst(createAttribute("template", _descriptor.template));
+                
+            if(_descriptor.propertySet.references.length == 0 &&
+               _descriptor.propertySet.properties.size() == 0 &&
+               _children.size() == 0)
+            {
+                writer.writeElement("server-instance", attributes);
+            }
+            else
+            {
+                writer.writeStartTag("server-instance", attributes);
+                writePropertySet(writer, _descriptor.propertySet, null, null);
+                
+                java.util.Iterator p = _children.iterator();
+                while(p.hasNext())
+                {
+                    PropertySet ps = (PropertySet)p.next();
+                    ps.write(writer);
+                }
+
+                writer.writeEndTag("server-instance");
+            }
+        }
     }
 
 
     boolean isIceBox()
     {
-	return _isIceBox;
+        return _isIceBox;
     }
 
     void isIceBox(boolean newValue)
     {
-	if(newValue != _isIceBox)
-	{
-	    _isIceBox = newValue;
-	    _children.clear();
-	    getRoot().getTreeModel().nodeStructureChanged(this);
-	}
+        if(newValue != _isIceBox)
+        {
+            _isIceBox = newValue;
+            _children.clear();
+            getRoot().getTreeModel().nodeStructureChanged(this);
+        }
     }
     
     static private class Backup
     {
-	Backup(Editable ne)
-	{
-	    nodeEditable = ne;
-	}
+        Backup(Editable ne)
+        {
+            nodeEditable = ne;
+        }
 
-	Editable nodeEditable;
-	java.util.Map parameterValues;
+        Editable nodeEditable;
+        java.util.Map parameterValues;
     }
 
     public Object rebuild(java.util.List editables) throws UpdateFailedException
     {
-	Node node = (Node)_parent;
-	Backup backup = new Backup(node.getEditable().save());
-
-	TemplateDescriptor templateDescriptor 
-	    = getRoot().findServerTemplateDescriptor(_descriptor.template);
-
-	java.util.Set parameters = new java.util.HashSet(templateDescriptor.parameters);
-	if(!parameters.equals(_descriptor.parameterValues.keySet()))
-	{
-	    backup.parameterValues = _descriptor.parameterValues;
-	    _descriptor.parameterValues = Editor.makeParameterValues(
-		_descriptor.parameterValues, templateDescriptor.parameters);
-	}
-	ServerInstance newServer = node.createServer(false, _descriptor);
-	
-
-	if(_id.equals(newServer.getId()))
-	{
-	    //
-	    // A simple update. We can't simply rebuild server because 
-	    // we need to keep a backup
-	    //
-	    if(_editable.isModified())
-	    {
-		newServer.getEditable().markModified();
-	    }
-
-	    node.removeServer(this);	    
-	    try
-	    {
-		node.insertServer(newServer, true);
-	    }
-	    catch(UpdateFailedException e)
-	    {
-		assert false; // impossible, we just removed a child with
-		              // this id
-	    }
-
-	    if(backup.parameterValues != null)
-	    {
-		editables.add(newServer.getEditable());
-	    }
-	}
-	else
-	{
-	    newServer.getEditable().markNew();
-	    node.removeServer(this);
-	    node.getEditable().removeElement(_id, _editable, Server.class);
-	    try
-	    {
-		node.insertServer(newServer, true);
-	    }
-	    catch(UpdateFailedException e)
-	    {
-		restore(backup);
-		throw e;
-	    }
-	}
-	
-	return backup;
+        Node node = (Node)_parent;
+        Backup backup = new Backup(node.getEditable().save());
+
+        TemplateDescriptor templateDescriptor 
+            = getRoot().findServerTemplateDescriptor(_descriptor.template);
+
+        java.util.Set parameters = new java.util.HashSet(templateDescriptor.parameters);
+        if(!parameters.equals(_descriptor.parameterValues.keySet()))
+        {
+            backup.parameterValues = _descriptor.parameterValues;
+            _descriptor.parameterValues = Editor.makeParameterValues(
+                _descriptor.parameterValues, templateDescriptor.parameters);
+        }
+        ServerInstance newServer = node.createServer(false, _descriptor);
+        
+
+        if(_id.equals(newServer.getId()))
+        {
+            //
+            // A simple update. We can't simply rebuild server because 
+            // we need to keep a backup
+            //
+            if(_editable.isModified())
+            {
+                newServer.getEditable().markModified();
+            }
+
+            node.removeServer(this);        
+            try
+            {
+                node.insertServer(newServer, true);
+            }
+            catch(UpdateFailedException e)
+            {
+                assert false; // impossible, we just removed a child with
+                              // this id
+            }
+
+            if(backup.parameterValues != null)
+            {
+                editables.add(newServer.getEditable());
+            }
+        }
+        else
+        {
+            newServer.getEditable().markNew();
+            node.removeServer(this);
+            node.getEditable().removeElement(_id, _editable, Server.class);
+            try
+            {
+                node.insertServer(newServer, true);
+            }
+            catch(UpdateFailedException e)
+            {
+                restore(backup);
+                throw e;
+            }
+        }
+        
+        return backup;
     }
 
     public void restore(Object backupObj)
     {
-	Backup backup = (Backup)backupObj;
-	Node node = (Node)_parent;
-	
-	node.getEditable().restore(backup.nodeEditable);
+        Backup backup = (Backup)backupObj;
+        Node node = (Node)_parent;
+        
+        node.getEditable().restore(backup.nodeEditable);
 
-	if(backup.parameterValues != null)
-	{
-	    _descriptor.parameterValues = backup.parameterValues;
-	}
+        if(backup.parameterValues != null)
+        {
+            _descriptor.parameterValues = backup.parameterValues;
+        }
 
-	TreeNode badServer = node.findChildWithDescriptor(_descriptor);
+        TreeNode badServer = node.findChildWithDescriptor(_descriptor);
 
-	if(badServer != null)
-	{
-	    node.removeServer(badServer);
-	}
+        if(badServer != null)
+        {
+            node.removeServer(badServer);
+        }
 
-	try
-	{
-	    node.insertServer(this, true);
-	}
-	catch(UpdateFailedException e)
-	{
-	    assert false; // impossible
-	}
+        try
+        {
+            node.insertServer(this, true);
+        }
+        catch(UpdateFailedException e)
+        {
+            assert false; // impossible
+        }
     }
 
 
     public void tryAdd(String unsubstitutedId, PropertySetDescriptor descriptor)
-	throws UpdateFailedException
+        throws UpdateFailedException
     {
-	insertPropertySet(new PropertySet(this,
-					  Utils.substitute(unsubstitutedId, _resolver),
-					  unsubstitutedId,
-					  descriptor), 
-			  true);
-	_descriptor.servicePropertySets.put(unsubstitutedId, descriptor);
-	_editable.markModified();
+        insertPropertySet(new PropertySet(this,
+                                          Utils.substitute(unsubstitutedId, _resolver),
+                                          unsubstitutedId,
+                                          descriptor), 
+                          true);
+        _descriptor.servicePropertySets.put(unsubstitutedId, descriptor);
+        _editable.markModified();
     }
 
     public void tryRename(String oldId, String oldUnresolvedId, 
-			  String newUnsubstitutedId)
-	throws UpdateFailedException
-    {
-	PropertySet oldChild = (PropertySet)findChild(oldId);
-	assert oldChild != null;
-	removePropertySet(oldChild);
-	PropertySetDescriptor descriptor = (PropertySetDescriptor)oldChild.getDescriptor();
-
-	try
-	{
-	    insertPropertySet(
-		new PropertySet(this, 
-				Utils.substitute(newUnsubstitutedId, _resolver), 
-				newUnsubstitutedId, descriptor),
-		true);
-	}
-	catch(UpdateFailedException ex)
-	{
-	    try
-	    {
-		insertPropertySet(oldChild, true);
-	    }
-	    catch(UpdateFailedException ufe)
-	    {
-		assert false;
-	    }
-	    throw ex;
-	}
-	
-	_editable.markModified();
-	_descriptor.servicePropertySets.remove(oldUnresolvedId);
-	_descriptor.servicePropertySets.put(newUnsubstitutedId, descriptor);
+                          String newUnsubstitutedId)
+        throws UpdateFailedException
+    {
+        PropertySet oldChild = (PropertySet)findChild(oldId);
+        assert oldChild != null;
+        removePropertySet(oldChild);
+        PropertySetDescriptor descriptor = (PropertySetDescriptor)oldChild.getDescriptor();
+
+        try
+        {
+            insertPropertySet(
+                new PropertySet(this, 
+                                Utils.substitute(newUnsubstitutedId, _resolver), 
+                                newUnsubstitutedId, descriptor),
+                true);
+        }
+        catch(UpdateFailedException ex)
+        {
+            try
+            {
+                insertPropertySet(oldChild, true);
+            }
+            catch(UpdateFailedException ufe)
+            {
+                assert false;
+            }
+            throw ex;
+        }
+        
+        _editable.markModified();
+        _descriptor.servicePropertySets.remove(oldUnresolvedId);
+        _descriptor.servicePropertySets.put(newUnsubstitutedId, descriptor);
     }
     
 
     public void insertPropertySet(PropertySet nps, boolean fireEvent)
-	throws UpdateFailedException
+        throws UpdateFailedException
     {
-	insertChild(nps, fireEvent);
+        insertChild(nps, fireEvent);
     }
 
     public void removePropertySet(PropertySet nps)
     {
-	removeChild(nps);
+        removeChild(nps);
     }
 
     public void removeDescriptor(String unsubstitutedId)
     {
-	_descriptor.servicePropertySets.remove(unsubstitutedId);
+        _descriptor.servicePropertySets.remove(unsubstitutedId);
     }
 
     public Editable getEditable()
     {
-	return _editable;
+        return _editable;
     }
     
     Object[] getServiceNames()
     {
-	assert _isIceBox;
-
-	//
-	// Retrieve the list of service instances
-	//
-	
-	Communicator.ChildList services = getRoot().
-	    findServerTemplate(_descriptor.template).getServices();
-	
-	Object[] result = new Object[services.size()];
-	int i = 0;
-	
-	java.util.Iterator p = services.iterator();
-	while(p.hasNext())
-	{
-	    TreeNode n = (TreeNode)p.next();
-	    ServiceInstanceDescriptor d = (ServiceInstanceDescriptor)n.getDescriptor();
-
-	    if(d.template.length() > 0)
-	    {
-		TemplateDescriptor templateDescriptor 
-		    = (TemplateDescriptor)getRoot().findServiceTemplateDescriptor(d.template);
-		assert templateDescriptor != null;
-		Utils.Resolver serviceResolver = new Utils.Resolver(_resolver, 
-								    d.parameterValues,
-								    templateDescriptor.parameterDefaults);
-		
-		ServiceDescriptor serviceDescriptor = (ServiceDescriptor)templateDescriptor.descriptor;
-
-		result[i++] = serviceResolver.substitute(serviceDescriptor.name);
-	    }
-	    else
-	    {
-		result[i++] = _resolver.substitute(d.descriptor.name);
-	    }
-	}
-	return result;
+        assert _isIceBox;
+
+        //
+        // Retrieve the list of service instances
+        //
+        
+        Communicator.ChildList services = getRoot().
+            findServerTemplate(_descriptor.template).getServices();
+        
+        Object[] result = new Object[services.size()];
+        int i = 0;
+        
+        java.util.Iterator p = services.iterator();
+        while(p.hasNext())
+        {
+            TreeNode n = (TreeNode)p.next();
+            ServiceInstanceDescriptor d = (ServiceInstanceDescriptor)n.getDescriptor();
+
+            if(d.template.length() > 0)
+            {
+                TemplateDescriptor templateDescriptor 
+                    = (TemplateDescriptor)getRoot().findServiceTemplateDescriptor(d.template);
+                assert templateDescriptor != null;
+                Utils.Resolver serviceResolver = new Utils.Resolver(_resolver, 
+                                                                    d.parameterValues,
+                                                                    templateDescriptor.parameterDefaults);
+                
+                ServiceDescriptor serviceDescriptor = (ServiceDescriptor)templateDescriptor.descriptor;
+
+                result[i++] = serviceResolver.substitute(serviceDescriptor.name);
+            }
+            else
+            {
+                result[i++] = _resolver.substitute(d.descriptor.name);
+            }
+        }
+        return result;
     }
 
     //
     // Update the server and its children
     //
     void rebuild(Utils.Resolver resolver,  
-		 ServerInstanceDescriptor instanceDescriptor,
-		 boolean isIceBox) throws UpdateFailedException
+                 ServerInstanceDescriptor instanceDescriptor,
+                 boolean isIceBox) throws UpdateFailedException
     {
-	_resolver = resolver;
-	_isIceBox = isIceBox;
-	_descriptor = instanceDescriptor;
-	
-	_children.clear();
+        _resolver = resolver;
+        _isIceBox = isIceBox;
+        _descriptor = instanceDescriptor;
+        
+        _children.clear();
 
-	java.util.Iterator p = _descriptor.servicePropertySets.entrySet().iterator();
-	while(p.hasNext())
-	{
-	    java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
-	    String unsubstitutedId = (String)entry.getKey();
+        java.util.Iterator p = _descriptor.servicePropertySets.entrySet().iterator();
+        while(p.hasNext())
+        {
+            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
+            String unsubstitutedId = (String)entry.getKey();
 
-	    insertPropertySet(new PropertySet(this, 
-					      Utils.substitute(unsubstitutedId, _resolver),
-					      unsubstitutedId,
-					      (PropertySetDescriptor)entry.getValue()),
-			      false);
-	}
+            insertPropertySet(new PropertySet(this, 
+                                              Utils.substitute(unsubstitutedId, _resolver),
+                                              unsubstitutedId,
+                                              (PropertySetDescriptor)entry.getValue()),
+                              false);
+        }
     }
 
     private void newPropertySet(PropertySetDescriptor descriptor)
     {
-	String id = makeNewChildId("Service");
-	
-	PropertySet ps = new PropertySet(this, id, descriptor);
-	try
-	{
-	    insertChild(ps, true);
-	}
-	catch(UpdateFailedException e)
-	{
-	    assert false;
-	}
-	getRoot().setSelectedNode(ps);
+        String id = makeNewChildId("Service");
+        
+        PropertySet ps = new PropertySet(this, id, descriptor);
+        try
+        {
+            insertChild(ps, true);
+        }
+        catch(UpdateFailedException e)
+        {
+            assert false;
+        }
+        getRoot().setSelectedNode(ps);
     }
 
 
     Utils.Resolver getResolver()
     {
-	return _resolver;
+        return _resolver;
     }
 
     public boolean isEphemeral()
     {
-	return _ephemeral;
+        return _ephemeral;
     }
 
     public String toString()
     {
-	if(_ephemeral)
-	{
-	    return super.toString();
-	}
-	else
-	{
-	    return _id + ": " + _descriptor.template + "<>";
-	}
+        if(_ephemeral)
+        {
+            return super.toString();
+        }
+        else
+        {
+            return _id + ": " + _descriptor.template + "<>";
+        }
     }
 
     private ServerInstanceDescriptor _descriptor;