Logo Search packages:      
Sourcecode: zeroc-ice-java version File versions  Download package

TreeNode.java

// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
package IceGridGUI.Application;

import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;

import java.util.Enumeration;

import IceGrid.*;
import IceGridGUI.*;

public abstract class TreeNode extends TreeNodeBase
{
    abstract public Editor getEditor();
    abstract protected Editor createEditor(); 
    abstract Object getDescriptor();
    
    abstract void write(XMLWriter writer) throws java.io.IOException;
 
    //
    // Ephemeral objects are destroyed when you switch selection
    // without "apply"ing the changes.
    //
    public boolean isEphemeral()
    {
      return false;
    }

    //
    // Destroys this node
    //
    public void destroy()
    {
      assert false;
    }
   
    TreeNode(TreeNode parent, String id)
    {
      super(parent, id);
    }

    Root getRoot()
    {
      assert _parent != null;
      return ((TreeNode)_parent).getRoot();
    }

    TreeNode findChildLike(TreeNode other)
    {
      //
      // Default implementation just use id; not always appropriate
      //
      return (TreeNode)findChild(other.getId());
    }

    //
    // Get variable-resolver
    //
    Utils.Resolver getResolver()
    {
      if(isEphemeral())
      {
          return null;
      }
      else
      {
          return ((TreeNode)_parent).getResolver();
      }
    }

    //
    // Find child whose descriptor == the given descriptor
    //
    TreeNode findChildWithDescriptor(Object descriptor)
    {
      Enumeration p = children();
      while(p.hasMoreElements())
      {
          TreeNode node = (TreeNode)p.nextElement();
          if(node.getDescriptor() == descriptor)
          {
            return node;
          }
      }
      return null;
    }

    static String[] createAttribute(String name, String value)
    {
      return new String[]{name, value};
    }

    static void writeVariables(XMLWriter writer, 
                         java.util.Map variables)
      throws java.io.IOException
    {
      java.util.Iterator p = variables.entrySet().iterator();
      while(p.hasNext())
      {
          java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
          
          java.util.List attributes = new java.util.LinkedList();
          attributes.add(createAttribute("name", entry.getKey().toString()));
          attributes.add(createAttribute("value", entry.getValue().toString()));

          writer.writeElement("variable", attributes);
      }
    }

    static void writePropertySet(XMLWriter writer, String id, 
                         PropertySetDescriptor psd, java.util.List adapters)
      throws java.io.IOException
    {
      if(id.length() == 0 && psd.references.length == 0 && psd.properties.size() == 0)
      {
          return;
      }

      //
      // We don't show the .Endpoint and .PublishedEndpoints of adapters,
      // since they already appear in the Adapter descriptors
      //
      java.util.Set hiddenPropertyNames = new java.util.HashSet();

      if(adapters != null)
      {
          java.util.Iterator p = adapters.iterator();
          while(p.hasNext())
          {
            AdapterDescriptor ad = (AdapterDescriptor)p.next();
            hiddenPropertyNames.add(ad.name + ".Endpoints");
          }
      }

      java.util.List attributes = new java.util.LinkedList();
      if(id.length() > 0)
      {
          attributes.add(createAttribute("id", id));
      }
      if(psd.references.length == 0 && psd.properties.size() == 0)
      {
          writer.writeElement("properties", attributes);
      }
      else
      {
          writer.writeStartTag("properties", attributes);
          
          for(int i = 0; i < psd.references.length; ++i)
          {
            attributes.clear();
            attributes.add(createAttribute("refid", psd.references[i])); 
            writer.writeElement("properties", attributes);
          }
          
          java.util.Iterator p = psd.properties.iterator();
          while(p.hasNext())
          {
            PropertyDescriptor pd = (PropertyDescriptor)p.next();
            if(hiddenPropertyNames.contains(pd.name))
            {
                //
                // We hide only the first occurence
                //
                hiddenPropertyNames.remove(pd.name);
            }
            else
            {
                attributes.clear();
                attributes.add(createAttribute("name", pd.name));
                attributes.add(createAttribute("value", pd.value));
                writer.writeElement("property", attributes);
            }
          }
          writer.writeEndTag("properties");
      }
    }

    static void writeDistribution(XMLWriter writer, 
                          DistributionDescriptor descriptor)
      throws java.io.IOException
    {
      if(descriptor.icepatch.length() > 0)
      {
          java.util.List attributes = new java.util.LinkedList();
          attributes.add(createAttribute("icepatch", descriptor.icepatch));
      
          if(descriptor.directories.isEmpty())
          {
            writer.writeElement("distrib", attributes);
          }
          else
          {
            writer.writeStartTag("distrib", attributes);
            java.util.Iterator p = descriptor.directories.iterator();
            while(p.hasNext())
            {
                writer.writeElement("directory", p.next().toString());
            }
            writer.writeEndTag("distrib");
          }
      }
    }
    
    static void writeObjects(String elt, XMLWriter writer, java.util.List objects)
      throws java.io.IOException
    {
      java.util.Iterator p = objects.iterator();
      while(p.hasNext())
      {
          ObjectDescriptor od = (ObjectDescriptor)p.next();
          java.util.List attributes = new java.util.LinkedList();
          attributes.add(createAttribute("identity", Ice.Util.identityToString(od.id)));
          if(od.type.length() > 0)
          {
            attributes.add(createAttribute("type", od.type));
          }
          writer.writeElement(elt, attributes);
      }
    }   

    static void writeParameters(XMLWriter writer, java.util.List parameters,
                        java.util.Map defaultValues)
      throws java.io.IOException
    {
      java.util.Iterator p = new java.util.LinkedHashSet(parameters).iterator();
      while(p.hasNext())
      {
          String parameter = (String)p.next();
          String val = (String)defaultValues.get(parameter);
          java.util.List attributes = new java.util.LinkedList();
          attributes.add(createAttribute("name", parameter));
          if(val != null)
          {
            attributes.add(createAttribute("default", val));
          }
          writer.writeElement("parameter", attributes);
      }
    }

    static java.util.LinkedList 
    parameterValuesToAttributes(java.util.Map parameterValues,
                        java.util.List parameters)
    {
      java.util.LinkedList result = new java.util.LinkedList();

      //
      // We use a LinkedHashSet to maintain order while eliminating duplicates
      //
      java.util.Iterator p = new java.util.LinkedHashSet(parameters).iterator();
      while(p.hasNext())
      {
          String param = (String)p.next();
          String val = (String)parameterValues.get(param);
          if(val != null)
          {
            result.add(createAttribute(param, val));
          }
      }
      return result;
    }

    //
    // Actions
    //
    public static final int NEW_ADAPTER = 0;
    public static final int NEW_DBENV = 1;
    public static final int NEW_NODE = 2;
    public static final int NEW_PROPERTY_SET = 3;
    public static final int NEW_REPLICA_GROUP = 4;
    public static final int NEW_SERVER = 5;
    public static final int NEW_SERVER_ICEBOX = 6;
    public static final int NEW_SERVER_FROM_TEMPLATE = 7;
    public static final int NEW_SERVICE = 8;
    public static final int NEW_SERVICE_FROM_TEMPLATE = 9;
    public static final int NEW_TEMPLATE_SERVER = 10;
    public static final int NEW_TEMPLATE_SERVER_ICEBOX = 11;
    public static final int NEW_TEMPLATE_SERVICE = 12;
  
    public static final int COPY = 13;
    public static final int PASTE = 14;
    public static final int DELETE = 15;

    public static final int SHOW_VARS = 16;
    public static final int SUBSTITUTE_VARS = 17;

    public static final int MOVE_UP = 18;
    public static final int MOVE_DOWN = 19;

    static public final int ACTION_COUNT = 20;

    public boolean[] getAvailableActions()
    {
      return new boolean[ACTION_COUNT];
    }
    public void newAdapter()
    {
      assert false;
    }
    public void newDbEnv()
    {
      assert false;
    }
    public void newNode()
    {
      assert false;
    }
    public void newPropertySet()
    {
      assert false;
    }
    public void newReplicaGroup()
    {
      assert false;
    }
    public void newServer()
    {
      assert false;
    }
    public void newServerIceBox()
    {
      assert false;
    }
    public void newServerFromTemplate()
    {
      assert false;
    }
    public void newService()
    {
      assert false;
    }
    public void newServiceFromTemplate()
    {
      assert false;
    }
    public void newTemplateServer()
    {
      assert false;
    }
    public void newTemplateServerIceBox()
    {
      assert false;
    }
    public void newTemplateService()
    {
      assert false;
    }
    public void copy()
    {
      assert false;
    }
    public void paste()
    {
      assert false;
    }
    public void delete()
    {
      destroy();
      if(_parent != null)
      {
          getRoot().setSelectedNode((TreeNode)_parent);
      }
    }
    public void moveUp()
    {
      assert false;
    }
    public void moveDown()
    {
      assert false;
    }
}

Generated by  Doxygen 1.6.0   Back to index