/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.properties;

import java.util.List;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.DialogCellEditor;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.ui.views.properties.PropertyDescriptor;
import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.util.TypesHelper;
import org.eclipse.wst.xsd.ui.internal.util.XSDDOMHelper;
import org.eclipse.wst.xsd.ui.internal.widgets.TypeSection;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


public class TypesPropertyDescriptor extends PropertyDescriptor
{
  Element element;
  XSDSchema xsdSchema;
  String property;
  /**
   * @param id
   * @param displayName
   */
  public TypesPropertyDescriptor(Object id, String displayName, Element element, XSDSchema xsdSchema)
  {
    super(id, displayName);
    this.property = (String)id;
    this.element = element;
    this.xsdSchema = xsdSchema;
  }
  
  boolean showComplexTypes = true;

  public CellEditor createPropertyEditor(Composite parent)
  {
    if (XSDDOMHelper.inputEquals(element, XSDConstants.ELEMENT_ELEMENT_TAG, false))
    {
      showComplexTypes = true;
    }
    else if (XSDDOMHelper.inputEquals(element, XSDConstants.ATTRIBUTE_ELEMENT_TAG, false) ||
      XSDDOMHelper.inputEquals(element, XSDConstants.LIST_ELEMENT_TAG, false) ||
      XSDDOMHelper.inputEquals(element, XSDConstants.UNION_ELEMENT_TAG, false))
    {
      showComplexTypes = false;
    }
    // CellEditor editor = new TypesOptionsTextCellEditor(parent);
    CellEditor editor = new TypesDialogCellEditor(parent);
    if (getValidator() != null)
      editor.setValidator(getValidator());
    return editor;
  }

  
  public class TypesDialogCellEditor extends DialogCellEditor
  {

    /**
     * Creates a new Font dialog cell editor parented under the given control.
     * The cell editor value is <code>null</code> initially, and has no 
     * validator.
     *
     * @param parent the parent control
     */
    protected TypesDialogCellEditor(Composite parent)
    {
      super(parent);
    }

    protected Object openDialogBox(Control cellEditorWindow)
    {
	    Shell shell = Display.getCurrent().getActiveShell();
	    
	    TypesDialog dialog = new TypesDialog(shell);

	    dialog.setBlockOnOpen(true);
	    dialog.create();
	    
	    String value = (String)getValue();
	
	    int result = dialog.open();
	    
	    if (result == Window.OK)
	    {
	      value = dialog.getType();
        doSetValue(value);
        fireApplyEditorValue();
	    }
	    deactivate();
	    return null;
	  }
  }

  public class TypesDialog extends org.eclipse.jface.dialogs.Dialog implements SelectionListener
  {
    String type;
    Object typeObject;
    Table table;

    TypeSection typeSection;
    boolean showAnonymous = true;
    String previousStringType = "";
    boolean isAnonymous;
    int previousType;

    
    public TypesDialog(Shell shell)
    {
      super(shell);
    }

    protected void configureShell(Shell shell)
    {
      super.configureShell(shell);
    }

    protected void buttonPressed(int buttonId)
    {
      if (buttonId == Dialog.OK)
      {
        type = table.getItem(table.getSelectionIndex()).getText();
        ok();
      }
      super.buttonPressed(buttonId);
    }

    public Object getTypeObject() { return typeObject; }
    public String getType() { return type; }

    //
    // Create the controls
    //
    public Control createDialogArea(Composite parent)
    {
      int tabIndex = 0;
      Composite client = (Composite)super.createDialogArea(parent);
      getShell().setText("Available Types");

      typeObject = null;
      
      GridLayout gl = new GridLayout(1, true);
//      gl.marginHeight = 0;
//      gl.marginWidth = 0;
//      gl.horizontalSpacing = 0;
//      gl.verticalSpacing = 0;
      client.setLayout(gl);

      GridData gd = new GridData();
      gd.grabExcessHorizontalSpace = true;
      gd.grabExcessVerticalSpace = true;
      gd.horizontalAlignment = GridData.FILL;
      gd.verticalAlignment = GridData.FILL;
      gd.horizontalIndent = 0;
      client.setLayoutData(gd);
      
      typeSection = new TypeSection(client);
      typeSection.setShowUserComplexType(showComplexTypes);

      typeSection.createClient(client);
      typeSection.getSimpleType().setSelection(false);
      typeSection.getSimpleType().addSelectionListener(this);
      typeSection.getUserSimpleType().addSelectionListener(this);
      if (showComplexTypes)
      {
        typeSection.getUserComplexType().addSelectionListener(this);
      }

      table = new Table(client,
                        SWT.SINGLE | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL); 
      table.setHeaderVisible(false);
      table.setLinesVisible(true);
      
      GridData gd2 = new GridData();
      gd2.grabExcessHorizontalSpace = true;
      gd2.grabExcessVerticalSpace = true;
      gd2.horizontalAlignment = GridData.FILL;
      gd2.heightHint = 200;
      table.setLayoutData(gd2);

      TableColumn tableColumn = new TableColumn(table, SWT.LEFT);
//      tableColumn.setImage(XSDEditorPlugin.getXSDImage("icons/XSDElement.gif"));
      tableColumn.setResizable(true);
      tableColumn.setWidth(200);
      

      // Fill table and select input type
      handleSetInput();

      return client;
    }
    
    public void widgetSelected(SelectionEvent e)
    {
      if (e.widget == typeSection.getSimpleType() && typeSection.getSimpleType().getSelection())
      {
        populateBuiltInType();
      }
      else if (e.widget == typeSection.getUserComplexType() && typeSection.getUserComplexType().getSelection())
      {
        populateUserComplexType();
      }
      else if (e.widget == typeSection.getUserSimpleType() && typeSection.getUserSimpleType().getSelection())
      {
        populateUserSimpleType();
      }

    }
    
  	public void widgetDefaultSelected(SelectionEvent e)
    {
    }

    protected void ok()
    {
      TableItem[] items = table.getItems();
      int selection = table.getSelectionIndex();
      if (items != null && items.length > 0 && selection >= 0)
      {
        typeObject = items[selection].getData();
      }
//      System.out.println("typeObject is " + typeObject);

//      beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_TYPE_CHANGE"), element);
//      beginRecording(XSDEditorPlugin.getXSDString("_UI_TYPE_CHANGE"), element);
//      doSetValue(typeObject);
//      applyEditorValueAndDeactivate();
//      dialog.close();

      if (!XSDDOMHelper.inputEquals(element, XSDConstants.UNION_ELEMENT_TAG, false))
      {
      if (typeObject.equals("**anonymous**"))
      {
        if (typeSection.getUserSimpleType().getSelection())
        {
          if (!previousStringType.equals("**anonymous**"))
          {
            updateElementToAnonymous(
              element,
              XSDConstants.SIMPLETYPE_ELEMENT_TAG);
          }
        }
        else
        {
          if (!previousStringType.equals("**anonymous**"))
          {
            updateElementToAnonymous(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
          }
        }
        // element.removeAttribute(XSDConstants.TYPE_ATTRIBUTE);
        element.removeAttribute(property);
      }
      else
      {
        updateElementToNotAnonymous(element);
        //element.setAttribute(XSDConstants.TYPE_ATTRIBUTE, typeObject.toString());
        element.setAttribute(property, typeObject.toString());
      }
      }
//      endRecording(element);

      //implement dispose();
//      table.removeAll();
//      table.dispose();
    }

  	
    public void handleSetInput()
    {
      table.removeAll();
      isAnonymous = checkForAnonymousType(element);
      // Attr attr = element.getAttributeNode(XSDConstants.TYPE_ATTRIBUTE);
      Attr attr = element.getAttributeNode(property);
      if (attr != null)
      {
        String value = attr.getValue();
        if (typeSection.getBuiltInTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getSimpleType().setSelection(true);
          populateBuiltInType();
          int i = typeSection.getBuiltInTypeNamesList(xsdSchema).indexOf(value);
          table.setSelection(i);
          previousType = 1;
        }
        else if (typeSection.getUserSimpleTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getUserSimpleType().setSelection(true);
          populateUserSimpleType();
          int i = typeSection.getUserSimpleTypeNamesList(xsdSchema).indexOf(value);
          if (showAnonymous)
          {
            table.setSelection(i + 1);
          }
          else
          {
            table.setSelection(i);
          }
          previousType = 2;
        }
        else if (typeSection.getUserComplexTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getUserComplexType().setSelection(true);
          populateUserComplexType();
          int i = typeSection.getUserComplexTypeNamesList(xsdSchema).indexOf(value);
          if (showAnonymous)
           {
            table.setSelection(i + 1);
          }
          else
           {
            table.setSelection(i);
          }
          previousType = 3;
        }
        else // if it is type="" for an empty list of simple types
          {
          typeSection.getUserSimpleType().setSelection(true);
          populateUserSimpleType();
          previousType = 2;
        }
      }
      else
      {
        if (isAnonymous)
        {
          if (isSTAnonymous(element))
          {
            typeSection.getUserSimpleType().setSelection(true);
            populateUserSimpleType();
            previousType = 2;
          }
          else
          {
            typeSection.getUserComplexType().setSelection(true);
            populateUserComplexType();
            previousType = 3;
          }
          table.setSelection(0); // anonymous
          //        typeSection.getTypeList().setText("**anonymous**");
        }
        else
        {
          typeSection.getSimpleType().setSelection(true);
          populateBuiltInType();
          table.setSelection(0);
          
          //        typeSection.getTypeList().setEnabled(true);
          //        typeSection.getSimpleType().setSelection(true);
          //        typeSection.populateBuiltInType(xsdSchema);
          //        typeSection.getTypeList().setText(XSDEditorPlugin.getXSDString("_UI_NO_TYPE"));
          previousType = 1;
        }
      }
      if (table.getSelection() != null && table.getSelection().length > 0)
      {
        previousStringType = (table.getSelection()[0]).getText();
      }
    }
    
    public void populateBuiltInType()
    {
      table.removeAll();
      List items = getBuiltInTypeNamesList();
      for (int i = 0; i < items.size(); i++)
      {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDSimpleType.gif"));
        item.setData(items.get(i));
      }
    }

    public void populateUserComplexType()
    {
      table.removeAll();
      if (showAnonymous)
      {
        TableItem anonymousItem = new TableItem(table, SWT.NONE);
        anonymousItem.setText("**anonymous**");
        anonymousItem.setData("**anonymous**");
      }
      List items = getUserComplexTypeNamesList();
      for (int i = 0; i < items.size(); i++)
      {
        TableItem item = new TableItem(table, SWT.NONE);
//        System.out.println("item " + i + " is " + item);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDComplexType.gif"));
        item.setData(items.get(i));
      }
    }

    public void populateUserSimpleType()
    {
      table.removeAll();
      if (showAnonymous)
       {
        TableItem anonymousItem = new TableItem(table, SWT.NONE);
        anonymousItem.setText("**anonymous**");
        anonymousItem.setData("**anonymous**");
      }
      List items = getUserSimpleTypeNamesList();
      for (int i = 0; i < items.size(); i++)
       {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDSimpleType.gif"));
        item.setData(items.get(i));
      }
    }

    boolean checkForAnonymousType(Element element)
    {
      /*
       * Using Ed's model to check boolean isAnonymous = false;
       * 
       * XSDConcreteComponent component =
       * getXSDSchema().getCorrespondingComponent(element); if (component
       * instanceof XSDElementDeclaration) { XSDElementDeclaration xsdElem =
       * (XSDElementDeclaration)component; isAnonymous =
       * xsdElem.isSetAnonymousTypeDefinition(); } return isAnonymous;
       */
      XSDDOMHelper helper = new XSDDOMHelper();
      boolean isAnonymous = false;
      Node aNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        return true;
      }
      aNode = helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        isAnonymous = true;
      }
      return isAnonymous;
    }

    void updateElementToAnonymous(Element element, String xsdType)
    {
      String prefix = element.getPrefix();
      prefix = (prefix == null) ? "" : (prefix + ":");
      updateElementToNotAnonymous(element);
      boolean hasChildrenElements = hasElementChildren(element);
      Element childNode = null;
      if (xsdType.equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
       {
        childNode = element.getOwnerDocument().createElementNS(
            XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001,
            prefix + XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      }
      else if (xsdType.equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG))
       {
        childNode =
        element.getOwnerDocument().createElementNS(
            XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001,
            prefix + XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      }
      element.appendChild(childNode);
      //formatChild(childNode, hasChildrenElements);
    }

    boolean isSTAnonymous(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node aNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        if (XSDDOMHelper
            .inputEquals(aNode, XSDConstants.SIMPLETYPE_ELEMENT_TAG, false))
         {
          return true;
        }
      }
      return false;
    }

    boolean isCTAnonymous(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node aNode = helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        if (XSDDOMHelper.inputEquals(aNode, XSDConstants.COMPLEXTYPE_ELEMENT_TAG, false))
         {
          return true;
        }
      }
      return false;
    }

    XSDTypeDefinition getAnonymousTypeDefinition(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node typeDefinitionNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (typeDefinitionNode == null)
       {
        typeDefinitionNode =
        helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      }
      if (typeDefinitionNode != null)
       {
        XSDConcreteComponent component =
        xsdSchema.getCorrespondingComponent(typeDefinitionNode);
        if (component instanceof XSDTypeDefinition)
         {
          return (XSDTypeDefinition) component;
        }
      }
      return null;
    }

    void updateElementToNotAnonymous(Element element)
    {
      if (element != null)
      {
	      NodeList children = element.getChildNodes();
	      if (children != null)
	       {
	        for (int i = 0; i < children.getLength(); i++)
	         {
	          Node node = (Node) children.item(i);
	          if (node instanceof Element)
	           {
	            if (node.getLocalName().equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG)
	                || node.getLocalName().equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
	             {
	              XSDDOMHelper.removeNodeAndWhitespace(node);
	              i = 0;
	            }
	          }
	        }
	      }
      }
    }

    public java.util.List getBuiltInTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getBuiltInTypeNamesList();
    }

    public java.util.List getUserSimpleTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getUserSimpleTypeNamesList();
    }
    
    public java.util.List getUserComplexTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getUserComplexTypeNamesList();
    }
    
	  protected boolean hasElementChildren(Node parentNode)
	  {
	    boolean hasChildrenElements = false;
	    if (parentNode != null && parentNode.hasChildNodes())
	    {
	      NodeList nodes = parentNode.getChildNodes();
	      for (int i = 0; i < nodes.getLength(); i++)
	      {
	        if (nodes.item(i) instanceof Element)
	        {
	          hasChildrenElements = true;
	          break;
	        }
	      }
	    }
	    return hasChildrenElements;
	  }

  }

  
  class TypesOptionsTextCellEditor extends OptionsTextCellEditor
  {
    boolean showAnonymous = true;
    
    public TypesOptionsTextCellEditor(Composite parent)
    {
      super(parent);
    }

    protected Control createControl(Composite parent)
    {
      isTextReadOnly = true;
      return super.createControl(parent);
    }

    Table table;
    TypeSection typeSection;

    protected void openDialog()
    {
      typeObject = null;
      dialog = new Shell(XSDEditorPlugin.getPlugin().getWorkbench().getActiveWorkbenchWindow().getShell(), SWT.MODELESS);
      Display display = dialog.getDisplay();
      GridLayout gl = new GridLayout(1, true);
      gl.marginHeight = 0;
      gl.marginWidth = 0;
      gl.horizontalSpacing = 0;
      gl.verticalSpacing = 0;
      dialog.setLayout(gl);
      GridData gd = new GridData();
      gd.grabExcessHorizontalSpace = true;
      gd.grabExcessVerticalSpace = true;
      gd.horizontalAlignment = GridData.FILL;
      gd.verticalAlignment = GridData.FILL;
      gd.horizontalIndent = 0;
      dialog.setLayoutData(gd);

      
      typeSection = new TypeSection(dialog);
      typeSection.setShowUserComplexType(showComplexTypes);

      typeSection.createClient(dialog);
      typeSection.getSimpleType().setSelection(false);
      typeSection.getSimpleType().addSelectionListener(this);
      typeSection.getUserSimpleType().addSelectionListener(this);
      if (showComplexTypes)
      {
        typeSection.getUserComplexType().addSelectionListener(this);
      }

      table = new Table(dialog,
                        SWT.SINGLE | SWT.FULL_SELECTION | SWT.H_SCROLL | SWT.V_SCROLL); 
      table.setHeaderVisible(false);
      table.setLinesVisible(true);
      GridData gd2 = new GridData();
      gd2.grabExcessHorizontalSpace = true;
      gd2.grabExcessVerticalSpace = true;
      gd2.horizontalAlignment = GridData.FILL;
      gd2.verticalAlignment = GridData.FILL;
      table.setLayoutData(gd2);

      // Fill table and select input type
      handleSetInput();
      int tableItemCount = table.getItemCount();

      TableColumn tc = new TableColumn(table, SWT.LEFT);
      tc.setImage(XSDEditorPlugin.getXSDImage("icons/XSDElement.gif"));
      //tc.setText("Available types:");
      tc.setResizable(false);

      int MAX_ITEMS = 23;
//      tc.pack();
//      table.pack();
      Rectangle tableBounds = table.getBounds();
      tableBounds.height = Math.min(tableBounds.height, table.getItemHeight()*MAX_ITEMS);
      table.setBounds(tableBounds);
      dialog.pack();
      
      dialog.addShellListener(new ShellAdapter()
      {
        public void shellDeactivated(ShellEvent e)
        {
          cancel();
        }
      });

      Rectangle dialogBounds = dialog.getBounds();
      Point buttonLocation = getButtonAbsoluteLocation();
      dialogBounds.x = buttonLocation.x;
      dialogBounds.y = buttonLocation.y;

      if (dialogBounds.height > 200)
      {        
        dialogBounds.height = 200;
      }
      if (dialogBounds.height < 100)
      {
        dialogBounds.height = 200;
      }
      if (dialogBounds.width > 200)
      {
        dialogBounds.width = typeSection.getUserComplexType().getBounds().width + 30;
      }
      dialog.setBounds(dialogBounds);
      tc.setWidth(dialogBounds.width);

      table.addKeyListener(new KeyAdapter()
      {
        public void keyPressed(KeyEvent e)
        {
          int keyCode = e.keyCode;
          int stateMask = e.stateMask;
          char character = e.character;
          if (character == SWT.CR || character == SWT.LF)
            ok();
          else if (character == SWT.ESC)
            cancel();
        }
      });

      table.addMouseListener(new MouseAdapter()
      {
        public void mouseDoubleClick(MouseEvent e)
        {
          ok();
        }
        public void mouseDown(MouseEvent e)
        {
          ok();
        }
      });

      try
      {
        dialog.open();
        table.setFocus();
        table.showSelection();
        
        while (!dialog.isDisposed())
        {
          if (!display.readAndDispatch())
          {
            display.sleep();
          }
        }
      }
      finally
      {
        if (!dialog.isDisposed())
          cancel();
      }
    }
    
    public void widgetSelected(SelectionEvent e)
    {
      if (e.widget == typeSection.getSimpleType() && typeSection.getSimpleType().getSelection())
      {
        populateBuiltInType();
      }
      else if (e.widget == typeSection.getUserComplexType() && typeSection.getUserComplexType().getSelection())
      {
        populateUserComplexType();
      }
      else if (e.widget == typeSection.getUserSimpleType() && typeSection.getUserSimpleType().getSelection())
      {
        populateUserSimpleType();
      }
    }
    
    protected void cancel()
    {
      super.cancel();
      table.dispose();
    }

    protected void ok()
    {
      TableItem[] items = table.getItems();
      selection = table.getSelectionIndex();
      if (items != null && items.length > 0 && selection >= 0)
      {
        typeObject = items[selection].getData();
      }
//      System.out.println("typeObject is " + typeObject);

//      beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_TYPE_CHANGE"), element);
//      beginRecording(XSDEditorPlugin.getXSDString("_UI_TYPE_CHANGE"), element);
      doSetValue(typeObject);
      applyEditorValueAndDeactivate();
      dialog.close();

      if (!XSDDOMHelper.inputEquals(element, XSDConstants.UNION_ELEMENT_TAG, false))
      {
      if (typeObject.equals("**anonymous**"))
      {
        if (typeSection.getUserSimpleType().getSelection())
        {
          if (!previousStringType.equals("**anonymous**"))
          {
            updateElementToAnonymous(
              element,
              XSDConstants.SIMPLETYPE_ELEMENT_TAG);
          }
        }
        else
        {
          if (!previousStringType.equals("**anonymous**"))
          {
            updateElementToAnonymous(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
          }
        }
        // element.removeAttribute(XSDConstants.TYPE_ATTRIBUTE);
        element.removeAttribute(property);
      }
      else
      {
        updateElementToNotAnonymous(element);
        //element.setAttribute(XSDConstants.TYPE_ATTRIBUTE, typeObject.toString());
        element.setAttribute(property, typeObject.toString());
      }
      }
//      endRecording(element);

      //implement dispose();
      table.removeAll();
      table.dispose();
    }

    String previousStringType = "";
    boolean isAnonymous;
    int previousType;

    public void handleSetInput()
    {
      table.removeAll();
      isAnonymous = checkForAnonymousType(element);
      // Attr attr = element.getAttributeNode(XSDConstants.TYPE_ATTRIBUTE);
      Attr attr = element.getAttributeNode(property);
      if (attr != null)
      {
        String value = attr.getValue();
        if (typeSection.getBuiltInTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getSimpleType().setSelection(true);
          populateBuiltInType();
          int i = typeSection.getBuiltInTypeNamesList(xsdSchema).indexOf(value);
          table.setSelection(i);
          previousType = 1;
        }
        else if (typeSection.getUserSimpleTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getUserSimpleType().setSelection(true);
          populateUserSimpleType();
          int i = typeSection.getUserSimpleTypeNamesList(xsdSchema).indexOf(value);
          if (showAnonymous)
          {
            table.setSelection(i + 1);
          }
          else
          {
            table.setSelection(i);
          }
          previousType = 2;
        }
        else if (typeSection.getUserComplexTypeNamesList(xsdSchema).contains(value))
        {
          typeSection.getUserComplexType().setSelection(true);
          populateUserComplexType();
          int i = typeSection.getUserComplexTypeNamesList(xsdSchema).indexOf(value);
          if (showAnonymous)
           {
            table.setSelection(i + 1);
          }
          else
           {
            table.setSelection(i);
          }
          previousType = 3;
        }
        else // if it is type="" for an empty list of simple types
          {
          typeSection.getUserSimpleType().setSelection(true);
          populateUserSimpleType();
          previousType = 2;
        }
      }
      else
      {
        if (isAnonymous)
        {
          if (isSTAnonymous(element))
          {
            typeSection.getUserSimpleType().setSelection(true);
            populateUserSimpleType();
            previousType = 2;
          }
          else
          {
            typeSection.getUserComplexType().setSelection(true);
            populateUserComplexType();
            previousType = 3;
          }
          table.setSelection(0); // anonymous
          //        typeSection.getTypeList().setText("**anonymous**");
        }
        else
        {
          typeSection.getSimpleType().setSelection(true);
          populateBuiltInType();
          table.setSelection(0);
          
          //        typeSection.getTypeList().setEnabled(true);
          //        typeSection.getSimpleType().setSelection(true);
          //        typeSection.populateBuiltInType(xsdSchema);
          //        typeSection.getTypeList().setText(XSDEditorPlugin.getXSDString("_UI_NO_TYPE"));
          previousType = 1;
        }
      }
      if (table.getSelection() != null && table.getSelection().length > 0)
      {
        previousStringType = (table.getSelection()[0]).getText();
      }
    }
    
    public void populateBuiltInType()
    {
      table.removeAll();
      List items = getBuiltInTypeNamesList();
      for (int i = 0; i < items.size(); i++)
      {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDSimpleType.gif"));
        item.setData(items.get(i));
      }
    }

    public void populateUserComplexType()
    {
      table.removeAll();
      if (showAnonymous)
      {
        TableItem anonymousItem = new TableItem(table, SWT.NONE);
        anonymousItem.setText("**anonymous**");
        anonymousItem.setData("**anonymous**");
      }
      List items = getUserComplexTypeNamesList();
      for (int i = 0; i < items.size(); i++)
      {
        TableItem item = new TableItem(table, SWT.NONE);
//        System.out.println("item " + i + " is " + item);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDComplexType.gif"));
        item.setData(items.get(i));
      }
    }

    public void populateUserSimpleType()
    {
      table.removeAll();
      if (showAnonymous)
       {
        TableItem anonymousItem = new TableItem(table, SWT.NONE);
        anonymousItem.setText("**anonymous**");
        anonymousItem.setData("**anonymous**");
      }
      List items = getUserSimpleTypeNamesList();
      for (int i = 0; i < items.size(); i++)
       {
        TableItem item = new TableItem(table, SWT.NONE);
        item.setText(items.get(i).toString());
        item.setImage(XSDEditorPlugin.getXSDImage("icons/XSDSimpleType.gif"));
        item.setData(items.get(i));
      }
    }

    boolean checkForAnonymousType(Element element)
    {
      /*
       * Using Ed's model to check boolean isAnonymous = false;
       * 
       * XSDConcreteComponent component =
       * getXSDSchema().getCorrespondingComponent(element); if (component
       * instanceof XSDElementDeclaration) { XSDElementDeclaration xsdElem =
       * (XSDElementDeclaration)component; isAnonymous =
       * xsdElem.isSetAnonymousTypeDefinition(); } return isAnonymous;
       */
      XSDDOMHelper helper = new XSDDOMHelper();
      boolean isAnonymous = false;
      Node aNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        return true;
      }
      aNode = helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        isAnonymous = true;
      }
      return isAnonymous;
    }

    void updateElementToAnonymous(Element element, String xsdType)
    {
      String prefix = element.getPrefix();
      prefix = (prefix == null) ? "" : (prefix + ":");
      updateElementToNotAnonymous(element);
      boolean hasChildrenElements = hasElementChildren(element);
      Element childNode = null;
      if (xsdType.equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
       {
        childNode = element.getOwnerDocument().createElementNS(
            XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001,
            prefix + XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      }
      else if (xsdType.equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG))
       {
        childNode =
        element.getOwnerDocument().createElementNS(
            XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001,
            prefix + XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      }
      element.appendChild(childNode);
      //formatChild(childNode, hasChildrenElements);
    }

    boolean isSTAnonymous(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node aNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        if (XSDDOMHelper
            .inputEquals(aNode, XSDConstants.SIMPLETYPE_ELEMENT_TAG, false))
         {
          return true;
        }
      }
      return false;
    }

    boolean isCTAnonymous(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node aNode = helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      if (aNode != null)
       {
        if (XSDDOMHelper.inputEquals(aNode, XSDConstants.COMPLEXTYPE_ELEMENT_TAG, false))
         {
          return true;
        }
      }
      return false;
    }

    XSDTypeDefinition getAnonymousTypeDefinition(Element element)
    {
      XSDDOMHelper helper = new XSDDOMHelper();
      Node typeDefinitionNode =
      helper.getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
      if (typeDefinitionNode == null)
       {
        typeDefinitionNode =
        helper.getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
      }
      if (typeDefinitionNode != null)
       {
        XSDConcreteComponent component =
        xsdSchema.getCorrespondingComponent(typeDefinitionNode);
        if (component instanceof XSDTypeDefinition)
         {
          return (XSDTypeDefinition) component;
        }
      }
      return null;
    }

    void updateElementToNotAnonymous(Element element)
    {
      NodeList children = element.getChildNodes();
      if (children != null)
       {
        for (int i = 0; i < children.getLength(); i++)
         {
          Node node = (Node) children.item(i);
          if (node instanceof Element)
           {
            if (node.getLocalName().equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG)
                || node.getLocalName().equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
             {
              XSDDOMHelper.removeNodeAndWhitespace(node);
              i = 0;
            }
          }
        }
      }
    }

    public java.util.List getBuiltInTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getBuiltInTypeNamesList();
    }

    public java.util.List getUserSimpleTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getUserSimpleTypeNamesList();
    }
    
    public java.util.List getUserComplexTypeNamesList()
    {
      TypesHelper helper = new TypesHelper(xsdSchema);
      return helper.getUserComplexTypeNamesList();
    }
    
	  protected boolean hasElementChildren(Node parentNode)
	  {
	    boolean hasChildrenElements = false;
	    if (parentNode != null && parentNode.hasChildNodes())
	    {
	      NodeList nodes = parentNode.getChildNodes();
	      for (int i = 0; i < nodes.getLength(); i++)
	      {
	        if (nodes.item(i) instanceof Element)
	        {
	          hasChildrenElements = true;
	          break;
	        }
	      }
	    }
	    return hasChildrenElements;
	  }

  }

}