/*******************************************************************************
 * Copyright (c) 2001, 2006 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
 *******************************************************************************/
// Based on version 1.12 of original xsdeditor
package org.eclipse.wst.xsd.ui.internal.wizards;

import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
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.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorCSHelpIds;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.util.ViewUtility;
import org.eclipse.xsd.XSDPatternFacet;


/*
-other regex features (eg case sensitivity, ^ or $, |, etc etc)
-smarter model
-better keyboard navigation
-update list of tokens 
*/

public class RegexCompositionPage extends WizardPage
{
  private static final boolean debug = false;

  /* The text representation of our pattern. */
  private StyledText value; 

  /* The StyleRange used to color code the current parse error. */
  private StyleRange currentError;

  /* The regex terms we can form tokens from. */
  private Combo terms;

  /* The checkbox for activating auto-escape mode. */  
  private Button escapeCheckbox;
  
  /* On/off status of auto-escape mode. */ 
  private boolean autoEscapeStatus;

  /* The Add Token button. */
  private Button add;


  // The following controls are used in the occurrence selection group

  private Text repeatValue;

  private Text rangeMinValue;
  private Text rangeMaxValue;
  private Label rangeToLabel;  

  private Button singleRadio;
  private Button starRadio;
  private Button plusRadio;
  private Button optionalRadio; 
  private Button repeatRadio;
  private Button rangeRadio;

  
  // The following variables used as part of the model. 

  /* Our pattern. */
  private XSDPatternFacet pattern;

  /* Model used to store the current token. */
  private RegexNode node;    

  /* The flags passed to the new RegularExpression object.  Default value includes:
      X = XMLSchema mode    */
  private String regexFlags = "X";
      

  /* Is the current regex token valid? */
  private boolean isValidToken;

  /* The label used to indicate the value's caret position when it looses focus. */
  private Label caretLabel;

  /* The pixel offsets needed to align the label icon with the caret location.
     These are dependent on the icon used. */
  private static final int CARET_LABEL_X_OFFSET = -3;
  private static final int CARET_LABEL_Y_OFFSET = 19;

  
  /* Enumerated constants for specifying the type of an error message. */
  private static final int TOKEN = 0;
  private static final int SELECTION = 1;
  private static final int PARSE = 2;
  
  private static final int NUM_ERROR_MESSAGE_TYPES = 3;
  
  /* The current error message for each type of error.  A value of null indicates no message. 
     The array is indexed according to the above constants.
  */
  private String[] currentErrorMessages;


  public RegexCompositionPage(XSDPatternFacet pattern)
  {
    super(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_COMPOSITION_PAGE_TITLE"));
    this.pattern = pattern;

    setTitle(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_COMPOSITION_PAGE_TITLE"));
    setDescription(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_COMPOSITION_PAGE_DESCRIPTION"));
  }

  public void createControl(Composite parent)
  {
    // Set up our model and validator
    node = new RegexNode();
        
    isValidToken = true;

    currentErrorMessages = new String[NUM_ERROR_MESSAGE_TYPES];

    // The main composite
    Composite composite= new Composite(parent, SWT.NONE);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, XSDEditorCSHelpIds.REGEX_WIZARD_PAGE);
    composite.setLayout(new GridLayout());


    // The composite for the token combo box, label, and auto-escape checkbox
    Composite tokenComposite = new Composite (composite, SWT.NONE);
    GridLayout tokenCompositeLayout = new GridLayout();
    tokenCompositeLayout.numColumns = 3;
    tokenCompositeLayout.marginWidth = 0;
    tokenComposite.setLayout(tokenCompositeLayout);


    new Label(tokenComposite, SWT.LEFT).setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_TOKEN_LABEL"));
    
    terms = new Combo(tokenComposite, SWT.DROP_DOWN);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(terms, XSDEditorCSHelpIds.REGEX_TOKEN_CONTENTS);
    for (int i = 0; i < RegexNode.getNumRegexTerms(); i++)
    {
      terms.add(RegexNode.getRegexTermText(i));
    }
    terms.addListener(SWT.Modify, new ComboListener());
    terms.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_TERMS"));

    escapeCheckbox = new Button(tokenComposite, SWT.CHECK);
    escapeCheckbox.setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_AUTO_ESCAPE_CHECKBOX_LABEL"));
    escapeCheckbox.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_AUTO_ESCAPE_CHECKBOX")); 
    escapeCheckbox.addSelectionListener(new CheckboxListener());
    autoEscapeStatus = false;


    // Set up the composites pertaining to the selection of occurrence quantifiers

    Group occurrenceSelectionArea = new Group(composite, SWT.NONE);
    occurrenceSelectionArea.setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_OCCURENCE_LABEL"));
    PlatformUI.getWorkbench().getHelpSystem().setHelp(occurrenceSelectionArea, XSDEditorCSHelpIds.REGEX_WIZARD_PAGE);
    GridLayout selectionAreaLayout = new GridLayout();
    selectionAreaLayout.numColumns = 2;
    occurrenceSelectionArea.setLayout(selectionAreaLayout);

    occurrenceSelectionArea.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

    // Listener used for all of the text fields
    TextListener textListener = new TextListener();
    

    // Add the radio buttons
    RadioSelectListener radioSelectListener = new RadioSelectListener();

    singleRadio = addOccurenceRadioButton(RegexNode.SINGLE, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(singleRadio, XSDEditorCSHelpIds.REGEX_JUST_ONCE);
    ViewUtility.createHorizontalFiller(occurrenceSelectionArea, 1);

    starRadio = addOccurenceRadioButton(RegexNode.STAR, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(starRadio, XSDEditorCSHelpIds.REGEX_ZERO_OR_MORE);
    ViewUtility.createHorizontalFiller(occurrenceSelectionArea, 1);

    plusRadio = addOccurenceRadioButton(RegexNode.PLUS, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(plusRadio, XSDEditorCSHelpIds.REGEX_ONE_OR_MORE);
    ViewUtility.createHorizontalFiller(occurrenceSelectionArea, 1);

    optionalRadio = addOccurenceRadioButton(RegexNode.OPTIONAL, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(optionalRadio, XSDEditorCSHelpIds.REGEX_OPTIONAL);
    ViewUtility.createHorizontalFiller(occurrenceSelectionArea, 1);

    repeatRadio = addOccurenceRadioButton(RegexNode.REPEAT, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(repeatRadio, XSDEditorCSHelpIds.REGEX_REPEAT_RADIO);
    
    repeatValue = new Text(occurrenceSelectionArea, SWT.SINGLE | SWT.BORDER);
    repeatValue.addListener(SWT.Modify, textListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(repeatValue, XSDEditorCSHelpIds.REGEX_REPEAT_FIELD);
    repeatValue.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_REPEAT"));
    repeatValue.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    setEnabledStatus(RegexNode.REPEAT, false);
    
    rangeRadio = addOccurenceRadioButton(RegexNode.RANGE, occurrenceSelectionArea, radioSelectListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(rangeRadio, XSDEditorCSHelpIds.REGEX_RANGE_RADIO);

    // Add text fields and labels for specifying the range    
    Composite rangeWidgets = new Composite(occurrenceSelectionArea, SWT.NONE);
    GridLayout gridLayout = new GridLayout(3, false);
    gridLayout.marginHeight = 0;
    gridLayout.marginWidth = 0;
    rangeWidgets.setLayout(gridLayout);
    rangeWidgets.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    
    rangeMinValue = new Text(rangeWidgets, SWT.SINGLE | SWT.BORDER);
    rangeMinValue.addListener(SWT.Modify, textListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(rangeMinValue, XSDEditorCSHelpIds.REGEX_RANGE_MINIMUM_FIELD);
    rangeMinValue.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_MIN"));
    rangeMinValue.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
    
    rangeToLabel = new Label(rangeWidgets, SWT.NONE);
    rangeToLabel.setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_TO_LABEL"));
    
    rangeMaxValue = new Text(rangeWidgets, SWT.SINGLE | SWT.BORDER);
    rangeMaxValue.addListener(SWT.Modify, textListener);
    rangeMaxValue.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_MAX"));
    PlatformUI.getWorkbench().getHelpSystem().setHelp(rangeMaxValue, XSDEditorCSHelpIds.REGEX_RANGE_MAXIMUM_FIELD);
    rangeMaxValue.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

    setEnabledStatus(RegexNode.RANGE, false);
    
    singleRadio.setSelection(true);
    
    // The add button
    add = new Button(composite, SWT.PUSH);
    add.addSelectionListener(new ButtonSelectListener());
    add.setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_ADD_BUTTON_LABEL"));
    PlatformUI.getWorkbench().getHelpSystem().setHelp(add, XSDEditorCSHelpIds.REGEX_ADD_BUTTON);
    add.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_ADD_BUTTON"));

    
    Label separator = new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
    separator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

    
    // Our main text box

    Label valueLabel= new Label(composite, SWT.LEFT);
    valueLabel.setText(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_CURRENT_REGEX_LABEL"));
    
    value = new StyledText(composite, SWT.SINGLE | SWT.BORDER);
    value.addListener(SWT.Modify, textListener);
    value.addListener(SWT.Selection, textListener);
    PlatformUI.getWorkbench().getHelpSystem().setHelp(value, XSDEditorCSHelpIds.REGEX_CURRENT_VALUE);
    value.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_CURRENT_REGEX"));
    value.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

    value.setFocus();

    // StyleRange used for highlighting parse errors
    currentError = new StyleRange();
    currentError.length = 1;
    currentError.foreground = parent.getDisplay().getSystemColor(SWT.COLOR_RED);

    // The caret label
    caretLabel = new Label(composite, SWT.LEFT);
    caretLabel.setImage(XSDEditorPlugin.getXSDImage("icons/RegexWizardArrow.gif"));
    caretLabel.setToolTipText(XSDEditorPlugin.getXSDString("_UI_TOOLTIP_REGEX_WIZARD_CARET_LABEL"));
    setShowCaretLabel(true);

    value.addFocusListener(new TextFocusListener());

    terms.select(0);


    setControl(composite);
  }


  public void setVisible(boolean visible)
  {
    super.setVisible(visible);

    value.setText(pattern.getLexicalValue());
    value.setCaretOffset(value.getCharCount());
  }

  public void dispose()
  {
    super.dispose();
  }


  /**
   * Sets the visible status of caretLabel to status.  If status is true, then we also update the position
   * of caretLabel in one of two ways.  If there is no active selection in value, we set caretLabel's
   * position to correspond with the position of the actual caret.  Alternatively, if there is an active selection
   * in value, we set caretLabel's position to the beginning of the selection.
   *
   * @param The new visibility status of caretLabel.
   */
  private void setShowCaretLabel(boolean status)
  {
    if (status)
    {
  
      int offset;
      
      if (value.getSelectionText().equals(""))
      {
        offset = value.getCaretOffset();
      }
      else
      {
        offset = value.getSelection().x;
      }
  
      Point p = value.getLocationAtOffset(offset);
      
      p.x += value.getLocation().x;
      p.y = value.getLocation().y;
      
      // Place the label under value, and make sure it is aligned with the caret.
      // The offsets are dependent on the icon used.
      p.x += CARET_LABEL_X_OFFSET;
      p.y += CARET_LABEL_Y_OFFSET;
  
      if (debug)
      {
        System.out.println("POINT: " + p); //$NON-NLS-1$
      }
      
      caretLabel.setLocation(p);
      caretLabel.setVisible(true);
    }
    else
    {
      caretLabel.setVisible(false);
    }
  }


  /**
   * Adds a new radio button to Composite c with SelectionListener l.  The text of the button is the String associated with
   * quantifier.
   *
   * @param quantifier The desired quantifier, as enumerated in RegexNode.
   * @param c The Composite to add the buttons to (normally occurrenceRadioButtons).
   * @param l The SelectionListener (normally radioSelectionListener).
   * @return The newly created button.
   */
  private Button addOccurenceRadioButton(int quantifier, Composite c, SelectionListener l)
  {
    Button result = new Button(c, SWT.RADIO);
    result.setText(RegexNode.getQuantifierText(quantifier));
    result.addSelectionListener(l);
    return result;
  }


  /**
   * Validates the regex in value.  If the regex is valid, clears the Wizard's error message.  If it's not valid,
   *  sets the Wizard's error message accordingly.
   *
   * @return Whether the regex is valid.
   */
  private boolean validateRegex()
  {

    boolean isValid;
    try
    {
      // We validate the regex by checking whether we get a ParseException.
      // By default, we assume that it's valid unless we determine otherwise.
      isValid = true;
      displayRegexErrorMessage(null);
      value.setStyleRange(null);

      Pattern.compile(value.getText());
    }
    catch (PatternSyntaxException pe)
    {
      isValid = false;
      displayRegexErrorMessage(pe.getMessage());

      // An off-by-one bug in the xerces regex parser will sometimes return a location for the parseError that
      //  is off the end of the string.  If this is the case, then we want to highlight the last character.
      if (pe.getIndex() >= value.getText().length())
      {
        currentError.start = value.getText().length() - 1;
      }
      else
      {
        currentError.start = pe.getIndex();
      }

      if (debug)
      {
        System.out.println("Parse Error location: " + pe.getIndex());  //$NON-NLS-1$
        System.out.println("currentError.start: " + currentError.start); //$NON-NLS-1$
      }

      value.setStyleRange(currentError);

    }

    // Another bug in the xerces parser will sometimes throw a RuntimeException instead of a ParseException.
    //  When we get a RuntimeException, we aren't provided with the additional information we need to highlight
    //  the parse error.  So, we merely report that there is an error.
    catch (RuntimeException re)
    {
      displayRegexErrorMessage("");
      value.setStyleRange(null);
      isValid = false;
    }
    
    setPageComplete(isValid);    
    return isValid;
  }

  
  /**
   * Manages the display of error messages.
   * Sets the error message for type to errorMessage.  If errorMessage != null, then we set the Wizard's error message
   * to errorMessage.  If errorMessage == null, then we check whether we have a pending message of another type.
   * If we do, then it is displayed as the Wizard's error message.  If we don't, then the Wizard's error message field
   * is cleared.
   *
   * @param errorMessage The text of the new error message.  A value of null indicates that the error message should
   *  be cleared.
   * @param type The error type, one of PARSE, TOKEN, or SELECTION.
   */ 
  private void displayErrorMessage(String errorMessage, int type)
  {
    String messageToDisplay = null;


    currentErrorMessages[type] = errorMessage;

    messageToDisplay = errorMessage;

    for (int i = 0; i < NUM_ERROR_MESSAGE_TYPES; i++)
    {
      if (messageToDisplay != null)
      {
        break;
      }
      messageToDisplay = currentErrorMessages[i];
    }

    setErrorMessage(messageToDisplay);
  }


  /**
   * Sets the Wizard's error message to message, preceded by a standard prefix.
   *
   * @param message The new error message (or null to clear it).
   */
  private void displayRegexErrorMessage (String errorMessage)
  {
    if (errorMessage == null)
    {
      displayErrorMessage(null, PARSE);
    }
    else
    {
    	if (errorMessage.trim().equals("")) // when there is no error message available.
    	{
        displayErrorMessage(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_REGEX_ERROR"),
                           PARSE);
      }
      else
      {
        displayErrorMessage(errorMessage, PARSE);
      }
    }
  }


  /**
   * Updates the token status.  Sets isValidToken to status && the status of the other error type.
   * If status is true, we clear the wizard's error message for this type; if it is false, we set it to errorMessage.
   *
   * @param status The new isValidToken value.
   * @param errorMessage The new error message.
   * @param type The type of the error (either TOKEN or SELECTION).
   */
  private void setTokenStatus (boolean status, String errorMessage, int type)
  {
    boolean otherTypeStatus =     (type == TOKEN) ? 
                                  currentErrorMessages[SELECTION] == null :
                                  currentErrorMessages[TOKEN] == null;
    
    isValidToken = status && otherTypeStatus;
    add.setEnabled(isValidToken);

    if (status)
    {
      displayErrorMessage(null, type);
    }
    else
    {
    	if (errorMessage != null && errorMessage.trim().equals("")) // when there is no error message available.
    	{
        displayErrorMessage(XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_TOKEN_ERROR"),
                           type);
      }
      else
      {
        displayErrorMessage(errorMessage, type);
      }
    }
  }

  
  /**
   * Updates the token status.  Sets isValidToken to status && the status of the other error type.
   * Also clears the wizard's error message for this type.
   * Usually used to set isValidToken to true.
   *
   * @param status The new isValidToken value.
   * @param type The type of the error (either TOKEN or SELECTION).
   */
  private void setTokenStatus(boolean status, int type)
  {
    setTokenStatus(status, null, type);
  }


  /**
   * Sets the enabled status of the text fields and labels associated with the specified quantifier.
   * If status is true, then fields and labels associated with other quantifiers are disabled.
   * @param quantifier The quantifier whose elements' enabled status we wish to change
   *   (as enumerated in RegexNode).
   * @param status The new status of the elements.  If true, then all elements associated with other buttons
   *               are disabled.
   */    
  private void setEnabledStatus(int quantifier, boolean status)
  {
    switch (quantifier)
    {
    
    case RegexNode.REPEAT:
      repeatValue.setEnabled(status);
      if (status)
      {
        rangeMinValue.setEnabled(false);
        rangeMaxValue.setEnabled(false);
        rangeToLabel.setEnabled(false);
      }
      break;

    case RegexNode.RANGE:
      rangeMinValue.setEnabled(status);
      rangeMaxValue.setEnabled(status);
      rangeToLabel.setEnabled(status);
      if (status)
      {
        repeatValue.setEnabled(false);
      }
      break;

    }
  }

  /**
   * Checks to see if there is a selection in value.  If there is not, we set the Wizard's error message accordingly.
   * If there is, we update the contents of node.  If "Current Selection" is not the current token, then
   * we clear the Selection error message.
   */
  private void updateCurrentSelectionStatus()
  {
    if (terms.getSelectionIndex() == RegexNode.SELECTION)
    {
      String selection = value.getSelectionText();
      if (selection.equals(""))
      {
        setTokenStatus(false, XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_SELECTION_ERROR"), SELECTION);
      }
      else
      {
        setTokenStatus(true, SELECTION);
        node.setContents(selection);
        node.setHasParens(true);
      }
    }
    else
    {
      setTokenStatus(true, SELECTION);
    }
  }

  /**
   * Updates the enabled status of the auto-escape checkbox.  If status is true, we enable the checkbox, and
   * set its selection status and node's auto-escape status to the value of autoEscapeStatus.  If status is
   * false, then we disable and deselect the checkbox, and set node's status to false.
   *
   * @param status The new enabled status.
   */
  private void setEscapeCheckboxEnabledStatus(boolean status)
  {
    if (status)
    {
      escapeCheckbox.setEnabled(true);
      escapeCheckbox.setSelection(autoEscapeStatus);
      node.setAutoEscapeStatus(autoEscapeStatus);
    }
    else
    {
      escapeCheckbox.setEnabled(false);
      escapeCheckbox.setSelection(false);
      node.setAutoEscapeStatus(false);
    }
  }


  /**
   * Returns the current regex flags.
   */
  String getFlags()
  {
    return regexFlags;
  }

  /**
   * Returns the current XSDPattern model.
   */
  XSDPatternFacet getPattern()
  {
    return pattern;
  }


  /**
   * Returns a string consisting of the values of min, max, and repeat stored in node.
   * Used for debugging purposes only.
   */  
  private String getAllFieldValues()
  {
      String result = "";
      result += "Min: " + node.getMin() + "\n";
      result += "Max: " + node.getMax() + "\n";
      result += "Repeat: " + node.getRepeat() + "\n";
      result += "\n";
      return result;
  }
  

  /* Listener for the add button. */
  class ButtonSelectListener implements SelectionListener
  {
    public void widgetDefaultSelected(SelectionEvent e)
    {
    }

    // Precondition: isValidToken == true  
    public void widgetSelected(SelectionEvent e)
    {
      if (!isValidToken) // should never happen
      {
        return;
      }

      // Whether there is anything selected in value.
      boolean isActiveSelection = value.getSelectionCount() != 0;
      
      value.insert(node.toString());

      if (terms.getSelectionIndex() == RegexNode.SELECTION)
      {
        updateCurrentSelectionStatus();
      }

      // If nothing is selected, then we need to advance the caret location.
      if (!isActiveSelection)
      {
        value.setCaretOffset(value.getCaretOffset() + node.toString().length());
      }

      value.setFocus();

    }

  }
 

  /* Listener for the terms combo box. */
  class ComboListener implements Listener
  {
    public void handleEvent(Event e)
    {
      
      updateCurrentSelectionStatus();

      // If the user has typed in a token
      if (terms.getSelectionIndex() == -1)
      {
        setEscapeCheckboxEnabledStatus(true);
        node.setContents(terms.getText());
        node.setHasParens(true);
        

        if (debug)
        {
          System.out.println(terms.getText());
        }

      }
      else if (terms.getSelectionIndex() == RegexNode.SELECTION)
      {
        setEscapeCheckboxEnabledStatus(false);
      }
      else
      {
        node.setContents(RegexNode.getRegexTermValue(terms.getSelectionIndex()));
        node.setHasParens(false);
        setEscapeCheckboxEnabledStatus(false);
      }
    }
  }


  /* Listener for enabling/disabling caretLabel. */
  class TextFocusListener implements FocusListener
  {
    public void focusGained(FocusEvent e)
    {
      setShowCaretLabel(false);
    }
    public void focusLost(FocusEvent e)
    {
      setShowCaretLabel(true);
    }
  }


  /* Listener for the text fields. */
  class TextListener implements Listener
  {
    public void handleEvent (Event e)
    {

      if (debug)
      {
        System.out.println("Inside TextListener handler");  //$NON-NLS-1$
        System.out.println(e);
        System.out.println(getAllFieldValues());
      }


      if ( (e.widget == value) && (e.type == SWT.Modify) )
      {
        pattern.setLexicalValue(value.getText());
        validateRegex();
      }

      else if (e.widget == value && e.type == SWT.Selection)
      {
        if (terms.getSelectionIndex() == RegexNode.SELECTION)
        {
          updateCurrentSelectionStatus();
        }
      }

      else if (e.widget == rangeMinValue)
      {
        boolean isValid = node.setMin(rangeMinValue.getText());

        if (isValid)
        {
          setTokenStatus(true, null, TOKEN);
        }
        else
        {
          setTokenStatus(false,  XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_MIN_ERROR_SUFFIX"), TOKEN);
        }
      }

      else if (e.widget == rangeMaxValue)
      {
        boolean isValid = node.setMax(rangeMaxValue.getText());

        if (node.getMin() == RegexNode.EMPTY)
        {
          setTokenStatus(false, XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_MISSING_MIN_ERROR_SUFFIX"), TOKEN);
        }
        else if (isValid)
        {
          setTokenStatus(true, null, TOKEN);
        }
        else
        {
          setTokenStatus(false, XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_MAX_ERROR_SUFFIX"), TOKEN);
        }
      }

      else  // (e.widget == repeatValue)
      {
        boolean isValid = node.setRepeat(repeatValue.getText());
        if (isValid)
        {
          setTokenStatus(true, null, TOKEN);
        }
        else
        {
          setTokenStatus(false, XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_REPEAT_ERROR_SUFFIX"), TOKEN);
        }
      }
    }
  }

  /* Listener for the auto-escape checkbox. */
  class CheckboxListener implements SelectionListener
  {
    public void widgetDefaultSelected(SelectionEvent e)
    {
    }

    public void widgetSelected(SelectionEvent e)
    {
      boolean newStatus = !autoEscapeStatus;
      node.setAutoEscapeStatus(newStatus);
      autoEscapeStatus = newStatus;
      
      if (debug)
      {
        System.out.println("AutoEscape Status: " + node.getAutoEscapeStatus());  //$NON-NLS-1$ 
      }
    }

  }


  /* Listener for the radio buttons. */
  class RadioSelectListener implements SelectionListener
  {
    public void widgetDefaultSelected(SelectionEvent e)
    {
    }

    public void widgetSelected(SelectionEvent e)
    {
      if (debug)
      {
        System.out.println(getAllFieldValues());
      }


      int currentQuantifier = getQuantifier(e);

      node.setQuantifier(currentQuantifier);

      switch (currentQuantifier)
      {
      case RegexNode.SINGLE:                     
      case RegexNode.STAR:
      case RegexNode.PLUS:
      case RegexNode.OPTIONAL:
        setEnabledStatus(RegexNode.REPEAT, false);
        setEnabledStatus(RegexNode.RANGE, false);
        setTokenStatus(true, TOKEN);
        break; 

      case RegexNode.REPEAT:
        setEnabledStatus(RegexNode.REPEAT, true);
        setTokenStatus(node.hasValidRepeat(), XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_REPEAT_ERROR_SUFFIX"), TOKEN);
        repeatValue.setFocus();
        break;

      case RegexNode.RANGE:
        setEnabledStatus(RegexNode.RANGE, true);
        String error = (node.hasValidMin()) ? 
                            XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_MAX_ERROR_SUFFIX") : 
                            XSDEditorPlugin.getXSDString("_UI_REGEX_WIZARD_INVALID_MIN_ERROR_SUFFIX");

        setTokenStatus( node.hasValidMin() && node.hasValidMax(), error, TOKEN);
        rangeMinValue.setFocus();
        break;
      }
    }

    private int getQuantifier(SelectionEvent e)
    {

      if (e.widget == singleRadio)
      {
        return RegexNode.SINGLE;
      }
      
      else if (e.widget == starRadio)
      {
        return RegexNode.STAR;
      }
      
      else if (e.widget == plusRadio)
      {
        return RegexNode.PLUS;
      }
      
      else if (e.widget == optionalRadio)
      {
        return RegexNode.OPTIONAL;
      }
      
      else if (e.widget == repeatRadio)
      {
        return RegexNode.REPEAT;
      }
      
      else if (e.widget == rangeRadio)
      {
        return RegexNode.RANGE;
      }
      
      else // can't get here
      { 
        return RegexNode.EMPTY;
      }
    } 
  }
  
  public String getValue()
  {
    return value.getText();
  }
}