gt:     protected void doLoad() {
context: /**
   * Copyright (c) 2005-2011 by Appcelerator, Inc. All Rights Reserved.
   * Licensed under the terms of the Eclipse Public License (EPL).
   * Please see the license.txt included with this distribution for details.
   * Any modifications to this file must keep this entire header intact.
   */
  /*
   * Created on Oct 28, 2004
   *
   * @author Fabio Zadrozny
   */
  package org.python.pydev.utils;
  
  import org.eclipse.jface.preference.FieldEditor;
  import org.eclipse.jface.resource.JFaceResources;
  import org.eclipse.core.runtime.Assert;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.DisposeEvent;
  import org.eclipse.swt.events.DisposeListener;
  import org.eclipse.swt.events.FocusAdapter;
  import org.eclipse.swt.events.FocusEvent;
  import org.eclipse.swt.events.KeyAdapter;
  import org.eclipse.swt.events.KeyEvent;
  import org.eclipse.swt.graphics.GC;
  import org.eclipse.swt.graphics.Point;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Text;
  
  /**
   * @author Fabio Zadrozny
   */
  public class CustomizableFieldEditor extends FieldEditor {
  
      /**
       * Validation strategy constant (value <code>0</code>) indicating that the editor should perform validation after every key stroke.
       * 
       * @see #setValidateStrategy
       */
      public static final int VALIDATE_ON_KEY_STROKE = 0;
  
      /**
       * Validation strategy constant (value <code>1</code>) indicating that the editor should perform validation only when the text widget
       * loses focus.
       * 
       * @see #setValidateStrategy
       */
      public static final int VALIDATE_ON_FOCUS_LOST = 1;
  
      /**
       * Text limit constant (value <code>-1</code>) indicating unlimited text limit and width.
       */
      public static int UNLIMITED = -1;
  
      /**
       * Cached valid state.
       */
      private boolean isValid;
  
      /**
       * Old text value.
       */
      private String oldValue;
  
      /**
       * The text field, or <code>null</code> if none.
       */
      Text textField;
  
      /**
       * Width of text field in characters; initially unlimited.
       */
      private int widthInChars = UNLIMITED;
  
      /**
       * Text limit of text field in characters; initially unlimited.
       */
      private int textLimit = UNLIMITED;
  
      /**
       * The error message, or <code>null</code> if none.
       */
      private String errorMessage;
  
      /**
       * Indicates whether the empty string is legal; <code>true</code> by default.
       */
      private boolean emptyStringAllowed = true;
  
      /**
       * The validation strategy; <code>VALIDATE_ON_KEY_STROKE</code> by default.
       */
      private int validateStrategy = VALIDATE_ON_KEY_STROKE;
  
      /**
       * Creates a new string field editor
       */
      protected CustomizableFieldEditor() {
      }
  
      /**
       * Creates a string field editor. Use the method <code>setTextLimit</code> to limit the text.
       * 
       * @param name the name of the preference this field editor works on
       * @param labelText the label text of the field editor
       * @param width the width of the text input field in characters, or <code>UNLIMITED</code> for no limit
       * @param strategy either <code>VALIDATE_ON_KEY_STROKE</code> to perform on the fly checking (the default), or
       *            <code>VALIDATE_ON_FOCUS_LOST</code> to perform validation only after the text has been typed in
       * @param parent the parent of the field editor's control
       * @since 2.0
       */
      public CustomizableFieldEditor(String name, String labelText, int width, int strategy, Composite parent) {
          init(name, labelText);
          widthInChars = width;
          setValidateStrategy(strategy);
          isValid = false;
          errorMessage = JFaceResources.getString("StringFieldEditor.errorMessage");//$NON-NLS-1$
          createControl(parent);
      }
  
      /**
       * Creates a string field editor. Use the method <code>setTextLimit</code> to limit the text.
       * 
       * @param name the name of the preference this field editor works on
       * @param labelText the label text of the field editor
       * @param width the width of the text input field in characters, or <code>UNLIMITED</code> for no limit
       * @param parent the parent of the field editor's control
       */
      public CustomizableFieldEditor(String name, String labelText, int width, Composite parent) {
          this(name, labelText, width, VALIDATE_ON_KEY_STROKE, parent);
      }
  
      /**
       * Creates a string field editor of unlimited width. Use the method <code>setTextLimit</code> to limit the text.
       * 
       * @param name the name of the preference this field editor works on
       * @param labelText the label text of the field editor
       * @param parent the parent of the field editor's control
       */
      public CustomizableFieldEditor(String name, String labelText, Composite parent) {
          this(name, labelText, UNLIMITED, parent);
      }
  
      /*
       * (non-Javadoc) Method declared on FieldEditor.
       */
      protected void adjustForNumColumns(int numColumns) {
          //        GridData gd = (GridData) textField.getLayoutData();
          //        gd.horizontalSpan = 30;//numColumns - 1;
  
          GridData gd = (GridData) textField.getLayoutData();
          gd.horizontalSpan = numColumns - 1;
          // We only grab excess space if we have to
          // If another field editor has more columns then
          // we assume it is setting the width.
          gd.grabExcessHorizontalSpace = gd.horizontalSpan == 1;
      }
  
      /**
       * Checks whether the text input field contains a valid value or not.
       * 
       * @return <code>true</code> if the field value is valid, and <code>false</code> if invalid
       */
      protected boolean checkState() {
          boolean result = false;
          if (emptyStringAllowed)
              result = true;
  
          if (textField == null)
              result = false;
  
          String txt = textField.getText();
  
          if (txt == null) {
              result = false;
          } else {
              result = (txt.trim().length() > 0) || emptyStringAllowed;
          }
  
          // call hook for subclasses
          result = result && doCheckState();
  
          if (result)
              clearErrorMessage();
          else
              showErrorMessage(errorMessage);
  
          return result;
      }
  
      /**
       * Hook for subclasses to do specific state checks.
       * <p>
       * The default implementation of this framework method does nothing and returns <code>true</code>. Subclasses should override this
       * method to specific state checks.
       * </p>
       * 
       * @return <code>true</code> if the field value is valid, and <code>false</code> if invalid
       */
      protected boolean doCheckState() {
          return true;
      }
  
      /**
       * Fills this field editor's basic controls into the given parent.
       * <p>
       * The string field implementation of this <code>FieldEditor</code> framework method contributes the text field. Subclasses may
       * override but must call <code>super.doFillIntoGrid</code>.
       * </p>
       */
      protected void doFillIntoGrid(Composite parent, int numColumns) {
          getLabelControl(parent);
  
          textField = getTextControl(parent);
          GridData gd = new GridData();
          gd.horizontalSpan = numColumns - 1;
          if (widthInChars != UNLIMITED) {
              GC gc = new GC(textField);
              try {
                  Point extent = gc.textExtent("X");//$NON-NLS-1$
                  gd.widthHint = widthInChars * extent.x;
              } finally {
                  gc.dispose();
              }
          } else {
              //            System.out.println("fill");
              gd.horizontalAlignment = GridData.FILL_BOTH;
              gd.verticalSpan = 4;
              gd.horizontalSpan = 1;
              gd.grabExcessVerticalSpace = true;
              gd.widthHint = 400;
              gd.heightHint = 60;
              //            gd.grabExcessHorizontalSpace = true;
          }
          textField.setLayoutData(gd);
      }
  
      /*
       * (non-Javadoc) Method declared on FieldEditor.
       */
  