/**
 * Used by PropertyAction to mimic property sheet behavior - trying to invoke
 * PropertyEnv listener of the current property editor (we can't create our
 * own PropertyEnv instance).
 * 
 * @return current value
 * @throws java.beans.PropertyVetoException if someone vetoes this change.
 */
public Object commitChanges() throws PropertyVetoException {
    int currentIndex = editorsCombo.getSelectedindex();
    propertyeditor currentEditor = currentIndex > -1 ? allEditors[currentIndex] : null;
    if (currentEditor instanceof Expropertyeditor) {
        // we can only guess - according to the typical pattern the propetry
        // editor itself or the custom editor usually implement the listener
        // registered in PropertyEnv
        PropertyChangeEvent evt = new PropertyChangeEvent(
                this,PropertyEnv.PROP_STATE,null,PropertyEnv.STATE_VALID);
        if (currentEditor instanceof Vetoablechangelistener) {
            ((Vetoablechangelistener)currentEditor).vetoableChange(evt);
        }
        Component currentCustEd = currentIndex > -1 ? allCustomEditors[currentIndex] : null;
        if (currentCustEd instanceof Vetoablechangelistener) {
            ((Vetoablechangelistener)currentCustEd).vetoableChange(evt);
        }
        if (currentEditor instanceof Propertychangelistener) {
            ((Propertychangelistener)currentEditor).propertyChange(evt);
        }
        if (currentCustEd instanceof Propertychangelistener) {
            ((Propertychangelistener)currentCustEd).propertyChange(evt);
        }
    }
    return commitChanges0();
}

@SuppressWarnings("unchecked")
private void createEditors(Properties configuration) {

    boolean trace = log.isTraceEnabled();
    // load properties using this class class loader
    ClassLoader classLoader = getClass().getClassLoader();

    for (Map.Entry<Object,Object> entry : configuration.entrySet()) {
        // key represents type
        Class<?> key;
        // value represents property editor
        Class<?> editorClass;
        try {
            key = classLoader.loadClass((String) entry.getKey());
            editorClass = classLoader.loadClass((String) entry.getValue());
        } catch (ClassNotFoundException ex) {
            throw (RuntimeException) new IllegalArgumentException("Cannot load class").initCause(ex);
        }

        Assert.isAssignable(propertyeditor.class,editorClass);

        if (trace)
            log.trace("Adding property editor[" + editorClass + "] for type[" + key + "]");
        editors.put(key,(Class<? extends propertyeditor>) editorClass);
    }
}

public static Font show(Font initialFont) {
    propertyeditor pe = propertyeditorManager.findEditor(Font.class);
    if (pe == null) {
        throw new RuntimeException("Could not find font editor component.");
    }
    pe.setValue(initialFont);
    DialogDescriptor dd = new DialogDescriptor(
            pe.getCustomEditor(),"Choose Font");
    Dialogdisplayer.getDefault().createDialog(dd).setVisible(true);
    if (dd.getValue() == DialogDescriptor.OK_OPTION) {
        Font f = (Font)pe.getValue();
        return f;
    }
    return initialFont;
}

private static propertyeditor findThepropertyeditor(Class clazz) {
    propertyeditor pe;
    if (Object.class.equals(clazz)) {
        pe = null;
    } else {
        pe = propertyeditorManager.findEditor(clazz);
        if (pe == null) {
            Class sclazz = clazz.getSuperclass();
            if (sclazz != null) {
                pe = findpropertyeditor(sclazz);
            }
        }
    }
    classesWithPE.put(clazz,pe != null);
    return pe;
}

boolean setValueWithMirror(Object value,Object valueMirror) {
    this.currentValue = value;
    Class clazz = valueMirror.getClass();
    propertyeditor propertyeditor = findpropertyeditor(clazz);
    propertyeditor = testpropertyeditorOnValue(propertyeditor,valueMirror);
    if (propertyeditor == null) {
        return false;
    }
    boolean doAttach = false;
    mirrorClass = clazz;
    delegatepropertyeditor = propertyeditor;
    if (env != null && propertyeditor instanceof Expropertyeditor) {
        doAttach = true;
    }
    delegateValue = valueMirror;
    delegatepropertyeditor.setValue(valueMirror);
    if (doAttach) {
        ((Expropertyeditor) delegatepropertyeditor).attachEnv(env);
    }
    return doAttach;
}

@Override
public propertyeditor getpropertyeditor() {
    return new propertyeditorSupport() {
        @Override
        public void setAsText(String text) throws IllegalArgumentException {
            if (text instanceof String) {
                try {
                    entry.setMessage(!text.equals("") ? text : null);
                } catch (IOException ex) {
                    History.LOG.log(Level.WARNING,ex);
                }
                return;
            }
            throw new java.lang.IllegalArgumentException(text);
        }
        @Override
        public String getAsText() {
            return te.getdisplayValue();
        }
    };
}

public void seTradioButtonMax(int i) {
    if (i != radioButtonMax) {
        Dimension oldPreferredSize = null;

        if (isShowing()) {
            oldPreferredSize = getPreferredSize();
        }

        int old = radioButtonMax;
        radioButtonMax = i;

        if (oldPreferredSize != null) {
            //see if the change will affect anything
            propertyeditor ed = PropUtils.getpropertyeditor(prop);
            String[] tags = ed.getTags();

            if (tags != null) {
                if ((tags.length >= i) != (tags.length >= old)) {
                    firePropertyChange("preferredSize",oldPreferredSize,getPreferredSize()); //NOI18N
                }
            }
        }
    }
}

@Override
public void actionPerformed(ActionEvent ae) {
    int i = getSelectedRow();

    if (i != -1) {
        FeatureDescriptor fd = getPropertySetModel().getFeatureDescriptor(i);

        if (fd instanceof Property) {
            java.beans.propertyeditor ped = PropUtils.getpropertyeditor((Property) fd);
            System.err.println(ped.getClass().getName());
        } else {
            System.err.println("PropertySets - no editor"); //NOI18N
        }
    } else {
        System.err.println("No selection"); //NOI18N
    }
}

public static Object getValueFromBeanInfopropertyeditor(
               Class attrClass,String attrName,String attrValue,Class propertyeditorClass) 
throws JasperException 
   {
try {
    propertyeditor pe = (propertyeditor)propertyeditorClass.newInstance();
    pe.setAsText(attrValue);
    return pe.getValue();
} catch (Exception ex) {
    throw new JasperException(
               Localizer.getMessage("jsp.error.beans.property.conversion",attrValue,attrClass.getName(),attrName,ex.getMessage()));
}
   }

propertyeditor getpropertyeditor() { //package private for unit tests

        propertyeditor result;

        if (editor != null) {
            return editor;
        }

        if (getInplaceEditor() != null) {
            result = getInplaceEditor().getpropertyeditor();
        } else {
            result = PropUtils.getpropertyeditor(getproperty());
        }

        editor = result;

        return result;
    }

private propertyeditor getpropertyeditor(Class<?> requiredType) {
    // Special case: If no required type specified,which usually only happens for
    // Collection elements,or required type is not assignable to registered type,// which usually only happens for generic properties of type Object -
    // then return propertyeditor if not registered for Collection or array type.
    // (If not registered for Collection or array,it is assumed to be intended
    // for elements.)
    if (this.registeredType == null ||
            (requiredType != null &&
            (ClassUtils.isAssignable(this.registeredType,requiredType) ||
            ClassUtils.isAssignable(requiredType,this.registeredType))) ||
            (requiredType == null &&
            (!Collection.class.isAssignableFrom(this.registeredType) && !this.registeredType.isArray()))) {
        return this.propertyeditor;
    }
    else {
        return null;
    }
}

public propertyeditor getpropertyeditor() {
    if (mdl.getpropertyeditorClass() != null) {
        try {
            //System.err.println("ModelProperty creating a " 
            //+ mdl.getpropertyeditorClass());
            Constructor c = mdl.getpropertyeditorClass().getConstructor();
            c.setAccessible(true);

            return (propertyeditor) c.newInstance(new Object[0]);
        } catch (Exception e) {
            Exceptions.printstacktrace(e);

            return new PropUtils.NopropertyeditorEditor();
        }
    }

    return super.getpropertyeditor();
}

/**
 * @param requiredType
 * @param propertyPath
 * @return
 */
public propertyeditor findCustomEditor ( final Class<?> requiredType,final String propertyPath )
{
    // first try to find exact match
    String key = requiredType.getCanonicalName () + ":" + propertyPath;
    propertyeditor pe = this.propertyeditors.get ( key );
    // 2nd: try to find for class only
    if ( pe == null )
    {
        key = requiredType.getCanonicalName () + ":";
        pe = this.propertyeditors.get ( key );
    }
    // 3rd: try to get internal
    if ( pe == null )
    {
        pe = propertyeditorManager.findEditor ( requiredType );
    }
    return pe;
}

public static Object getValueFrompropertyeditorManager(Class<?> attrClass,String attrValue)
        throws JasperException {
    try {
        propertyeditor propEditor = propertyeditorManager.findEditor(attrClass);
        if (propEditor != null) {
            propEditor.setAsText(attrValue);
            return propEditor.getValue();
        } else {
            throw new IllegalArgumentException(
                    Localizer.getMessage("jsp.error.beans.propertyeditor.notregistered"));
        }
    } catch (IllegalArgumentException ex) {
        throw new JasperException(Localizer.getMessage("jsp.error.beans.property.conversion",ex.getMessage()));
    }
}

@Override
public propertyeditor getpropertyeditor() {
    if (editor == null) {
        editor = super.getpropertyeditor();
    }
    return editor;
}

@Override
public propertyeditor getpropertyeditor() {
    return new propertyeditorSupport() {
        @Override
        public java.awt.Component getCustomEditor() {
            return new CustomCodeEditor(CodePropertySupportRW.this);
        }

        @Override
        public boolean supportsCustomEditor() {
            return true;
        }
    };            
}

private static Object getValueFrompropertyeditorManager(Class attrClass,String attrValue) {
    propertyeditor propEditor = propertyeditorManager.findEditor(attrClass);
    if (propEditor != null) {
        propEditor.setAsText(attrValue);
        return propEditor.getValue();
    } else {
        throw new IllegalArgumentException("beans property editor not registered");
    }
}

public PropertyText(propertyeditor pe) {
        super(pe.getAsText());
        editor = pe;
        addKeyListener(this);
        addFocusListener(this);
        editor.addPropertychangelistener(this);
//      setBorder(propertysheet.EMPTY_BORDER);
    }

private static void test(Class<?> type,Class<? extends propertyeditor> expected) {
    propertyeditor actual = propertyeditorManager.findEditor(type);
    if ((actual == null) && (expected != null)) {
        throw new Error("expected editor is not found");
    }
    if ((actual != null) && !actual.getClass().equals(expected)) {
        throw new Error("found unexpected editor");
    }
}

public void testPERegistered() {
    NodeOp.registerpropertyeditors();
    propertyeditor pEditor = propertyeditorManager.findEditor(Double[].class);
    assertEquals("org.netbeans.modules.openide.nodes.Testpropertyeditor",pEditor.getClass().getName());
    pEditor = propertyeditorManager.findEditor(Integer.class);
    assertEquals("org.netbeans.modules.openide.nodes.Testpropertyeditor",pEditor.getClass().getName());
    pEditor = propertyeditorManager.findEditor(char[][].class);
    assertEquals("org.netbeans.modules.openide.nodes.Testpropertyeditor",pEditor.getClass().getName());
    pEditor = propertyeditorManager.findEditor(short.class);
    assertEquals("org.netbeans.modules.openide.nodes.Testpropertyeditor",pEditor.getClass().getName());
}

private static String getStringValue(FormProperty prop,Object value) {
    if (value instanceof String)
        return (String) value;

    propertyeditor prEd = prop.getCurrentEditor();
    prEd.setValue(value);
    return prEd.getAsText(); // [this does not work correctly with IconEditor...]
}

/**
 * Find a default editor for the given type.
 * @param requiredType the type to find an editor for
 * @return the corresponding editor,or {@code null} if none
 */
private propertyeditor findDefaultEditor(Class<?> requiredType) {
    propertyeditor editor = null;
    if (requiredType != null) {
        // No custom editor -> check BeanWrapperImpl's default editors.
        editor = this.propertyeditorRegistry.getDefaultEditor(requiredType);
        if (editor == null && !String.class.equals(requiredType)) {
            // No BeanWrapper default editor -> check standard JavaBean editor.
            editor = BeanUtils.findEditorByConvention(requiredType);
        }
    }
    return editor;
}

/**
 * Test if the property editor can act on the provided value. We can never be sure. :-(
 * @param propertyeditor
 * @param valueMirror
 * @return the property editor,or <code>null</code>
 */
private static propertyeditor testpropertyeditorOnValue(propertyeditor propertyeditor,Object valueMirror) {
    propertyeditor.setValue(valueMirror);
    Object value = propertyeditor.getValue();
    if (value != valueMirror && (value == null || !value.equals(valueMirror))) {
        // Returns something that we did not set. Give up.
        return null;
    }
    return propertyeditor;
}

public static Object getValueFromBeanInfopropertyeditor(Class<?> attrClass,Class<?> propertyeditorClass) throws JasperException {
    try {
        propertyeditor pe = (propertyeditor) propertyeditorClass.newInstance();
        pe.setAsText(attrValue);
        return pe.getValue();
    } catch (Exception ex) {
        throw new JasperException(Localizer.getMessage("jsp.error.beans.property.conversion",ex.getMessage()));
    }
}

/**
 * Get custom editor for the given type. If no direct match found,* try custom editor for superclass (which will in any case be able
 * to render a value as String via {@code getAsText}).
 * @param requiredType the type to look for
 * @return the custom editor,or {@code null} if none found for this type
 * @see java.beans.propertyeditor#getAsText()
 */
private propertyeditor getCustomEditor(Class<?> requiredType) {
    if (requiredType == null || this.customEditors == null) {
        return null;
    }
    // Check directly registered editor for type.
    propertyeditor editor = this.customEditors.get(requiredType);
    if (editor == null) {
        // Check cached editor for type,registered for superclass or interface.
        if (this.customEditorCache != null) {
            editor = this.customEditorCache.get(requiredType);
        }
        if (editor == null) {
            // Find editor for superclass or interface.
            for (Iterator<Class<?>> it = this.customEditors.keySet().iterator(); it.hasNext() && editor == null;) {
                Class<?> key = it.next();
                if (key.isAssignableFrom(requiredType)) {
                    editor = this.customEditors.get(key);
                    // Cache editor for search type,to avoid the overhead
                    // of repeated assignable-from checks.
                    if (this.customEditorCache == null) {
                        this.customEditorCache = new HashMap<Class<?>,propertyeditor>();
                    }
                    this.customEditorCache.put(requiredType,editor);
                }
            }
        }
    }
    return editor;
}

public void registerCustomEditors(propertyeditorRegistry registry) {
    for (Map.Entry<Class<?>,Class<? extends propertyeditor>> entry : editors.entrySet()) {
        Class<?> type = entry.getKey();
        propertyeditor editorInstance;
        editorInstance = BeanUtils.instantiate(entry.getValue());
        registry.registerCustomEditor(type,editorInstance);
    }

    // register non-externalized types
    registry.registerCustomEditor(Dictionary.class,new CustomMapEditor(Hashtable.class));
    registry.registerCustomEditor(Properties.class,new PropertiesEditor());
    registry.registerCustomEditor(Class.class,new ClassEditor(userClassLoader));
    registry.registerCustomEditor(Class[].class,new ClassArrayEditor(userClassLoader));
}

@Override
public Object parseImp(String input,ParserHelper helper) {
    propertyeditor editor = findEditor(helper.getRawTargetClass());
    if (editor == null) {
        return TRY_NEXT;
    }
    editor.setAsText(input);
    return editor.getValue();
}

private boolean openCustomEditor(ActionEvent e) {
    if (getSelectedRowCount() != 1 || getSelectedColumnCount() != 1) {
        return false;
    }
    int row = getSelectedRow();
    if (row < 0) return false;
    int column = getSelectedColumn();
    if (column < 0) return false;
    Object o = getValueAt(row,column);
    if (!(o instanceof Node.Property)) {
        return false;
    }
    Node.Property p = (Node.Property) o;
    if (!Boolean.TRUE.equals(p.getValue("suppressCustomEditor"))) { //NOI18N
        PropertyPanel panel = new PropertyPanel(p);
        @SuppressWarnings("deprecation")
        propertyeditor ed = panel.getpropertyeditor();

        if ((ed != null) && ed.supportsCustomEditor()) {
            Action act = panel.getActionMap().get("invokeCustomEditor"); //NOI18N

            if (act != null) {
                act.actionPerformed(null);

                return true;
            }
        }
    }
    return false;
}

/**
 * Initializes folder from the properties object.
 * @param props
 */
protected void loadFromProperties(Properties props,String prefix) throws IntrospectionException {
    Enumeration<String> keys = (Enumeration<String>) props.propertyNames();
    prefix = prefix + getName() + ".";
    // load properties in this folder
    while (keys.hasMoreElements()) {
        String key = keys.nextElement();
        if (key.startsWith(prefix)) {
            String posfix = key.replaceFirst(prefix,"");
            if (!posfix.contains(".")) {
                // the posfix represents a name of a property
                Property prop = getProperty(posfix);
                if (prop == null) {
                    continue;
                }
                // exploit the JavaBeans property editors to convert the values from text
                propertyeditor editor = propertyeditorManager.findEditor(prop.getType());
                if (editor == null) {
                    continue;
                }
                editor.setAsText(props.getProperty(key));
                prop.setValue(editor.getValue());

            }
        }
        ;
    }

    // load all subfolders
    for (Folder folder : getFolders()) {
        folder.loadFromProperties(props,prefix);
    }

}

@Override
public propertyeditor getpropertyeditor() {
    try {
        return new DiffNode.Diffpropertyeditor(getValue());
    } catch (Exception e) {
        return super.getpropertyeditor();
    }
}

public void testNullValueSupport() throws Exception {
    NP np = new NP();
    String defaultValue = "<null value>";
    String customValue = "Hello World!";
    np.setValue(ObjectEditor.PROP_NULL,defaultValue);

    propertyeditor p = np.getpropertyeditor();
    assertNotNull("There is some editor",p);
    assertEquals("It is StringEditor",StringEditor.class,p.getClass());
    ((StringEditor) p).readEnv(np);

    p.setValue(null);
    String value = (String)p.getValue ();
    assertNull(value);
    assertEquals(defaultValue,p.getAsText());

    p.setValue(customValue);
    value = (String)p.getValue ();
    assertEquals(customValue,value);
    assertEquals(customValue,p.getAsText());

    np.setValue(ObjectEditor.PROP_NULL,Boolean.TRUE);
    ((StringEditor) p).readEnv(np);
    p.setValue(null);
    value = (String)p.getValue ();
    assertNull(value);
    assertFalse("we've better than default 'null' string","null".equals(defaultValue));
}

propertyeditor getpropertyeditor() { //Package private for unit tests

        if (editor == null) {
            setpropertyeditor(PropUtils.getpropertyeditor(getproperty()));
        }

        return editor;
    }

private static void test(Class<?> type,Class<? extends propertyeditor> expected) {
    propertyeditor actual = propertyeditorManager.findEditor(type);
    if ((actual == null) && (expected != null)) {
        throw new Error("expected editor is not found");
    }
    if ((actual != null) && !actual.getClass().equals(expected)) {
        throw new Error("found unexpected editor");
    }
}

public boolean isValueModified() {
    boolean result = false;
    propertyeditor peditor = getpropertyeditor();

    Object enteredValue = getEnteredValue();
    Object realValue = null;

    //Get the value from the editor to make sure getAsText() does not lie
    Object editorValue = null;

    try {
        editorValue = peditor.getValue();
    } catch (ProxyNode.DifferentValuesException dve) {
        return false;
    }

    //some editors provide a single from getTags()
    //but the value is null by default
    if ((enteredValue == null) != (editorValue == null)) {
        return true;
    }

    if (realValue == null) {
        //try to check the editor value if the editor does not support
        //getAsText
        realValue = editorValue;
    }

    if ((realValue == null) != (enteredValue == null)) {
        result = true;
    } else if (realValue == enteredValue) {
        result = false;
    } else if (realValue != null) {
        result = !realValue.equals(enteredValue);
    } else {
        result = false;
    }

    return result;
}

public void valueChanged(propertyeditor editor) {
    Failed = false;

    try {
        //                System.err.println("ValueChanged - new value " + editor.getValue());
        if (getInplaceEditor() != null) {
            setEnteredValue(getproperty().getValue());
        } else {
            //Handle case where our parent PropertyPanel is no longer showing,but
            //the custom editor we invoked still is.  Issue 38004
            PropertyModel mdl = (modelRef != null) ? modelRef.get() : null;

            if (mdl != null) {
                FeatureDescriptor fd = null;

                if (mdl instanceof ExPropertyModel) {
                    fd = ((ExPropertyModel) mdl).getFeatureDescriptor();
                }

                String title = null;

                if (fd != null) {
                    title = fd.getdisplayName();
                }

                Failed = PropUtils.updateProp(mdl,editor,title); //XXX
            }
        }
    } catch (Exception e) {
        throw (IllegalStateException) new IllegalStateException("Problem setting entered value from custom editor").initCause(e);
    }
}

private IconPanel prepareIconPanel(propertyeditor ed,PropertyEnv env,InplaceEditor inner) {
    IconPanel icp = iconPanel();
    icp.setInplaceEditor(inner);
    icp.connect(ed,env);

    return icp;
}

/**
 * Provides a component usable as property customizer (so typically a modal
 * dialog) that allows to choose (or create) a properties bundle file within
 * the project of given form data object. The selected file should be
 * written to the given property editor (via setValue) as a resource name
 * string.
 */
@Override
public Component getBundleSelectionComponent(final propertyeditor prEd,FileObject srcFile) {
    try {
        final FileSelector fs = new FileSelector(srcFile,JavaResourceHolder.getTemplate());
        return fs.getDialog(NbBundle.getMessage(I18nServiceImpl.class,"CTL_SELECT_BUNDLE_TITLE"),// NOI18N
                            new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent ev) {
                DataObject bundleDO = fs.getSelectedDataObject();
                if (bundleDO != null) {
                    Classpath cp = Classpath.getClasspath(bundleDO.getPrimaryFile(),Classpath.soURCE);
                    if (cp != null) {
                        String bundleName = cp.getResourceName(bundleDO.getPrimaryFile(),'/',false);
                        prEd.setValue(bundleName);
                    }
                }
            }
        });
    }
    catch (IOException ex) {
        // means that template for properties file was not found - unlikely
        ErrorManager.getDefault().notify(ErrorManager.informatIONAL,ex);
    }
    return null;
}

private JComponent prepareCheckBox(propertyeditor editor,PropertyEnv env) {
    CheckBoxRenderer ren = checkBoxRenderer();
    ren.setUseTitle(useLabels);
    ren.clear();
    ren.setEnabled(true);
    ren.connect(editor,env);

    return ren.getComponent();
}

/** Create a StringCustomEditor.
  * @param value the initial value for the string
  * @param editable whether to show the editor in read only or read-write mode
  * @param oneline whether the text component should be a single-line or multi-line component
  * @param instructions any instructions that should be displayed
  */
 StringCustomEditor (String value,boolean editable,boolean oneline,String instructions,propertyeditor editor,PropertyEnv env) {
     this.oneline = oneline;
     this.instructions = instructions;
     this.env = env;
     this.editor = editor;

     this.env.setState(PropertyEnv.STATE_NEEDS_VALIDATION);
     this.env.addPropertychangelistener(this);

     init (value,editable);
}

public propertyeditorFinder() {
    super(propertyeditor.class,false,"Editor",DEFAULT);

    this.registry = new WeakCache<Class<?>,Class<?>>();
    this.registry.put(Byte.TYPE,ByteEditor.class);
    this.registry.put(Short.TYPE,ShortEditor.class);
    this.registry.put(Integer.TYPE,IntegerEditor.class);
    this.registry.put(Long.TYPE,LongEditor.class);
    this.registry.put(Boolean.TYPE,BooleanEditor.class);
    this.registry.put(Float.TYPE,FloatEditor.class);
    this.registry.put(Double.TYPE,DoubleEditor.class);
}

public final propertyeditor<Insets> getEditor() {
  if (myEditor == null) {
    myEditor = new IntRegexEditor<Insets>(Insets.class,myRenderer,new int[] { 0,0 }) {
      public Insets getValue() throws Exception {
        // if a single number has been entered,interpret it as same value for all parts (IDEADEV-7330)
        try {
          int value = Integer.parseInt(myTf.getText());
          final Insets insets = new Insets(value,value,value);
          myTf.setText(myRenderer.formatText(insets));
          return insets;
        }
        catch(NumberFormatException ex) {
          return super.getValue();
        }
      }
    };
  }
  return myEditor;
}

public final propertyeditor<Insets> getEditor() {
  if (myEditor == null) {
    myEditor = new IntRegexEditor<Insets>(Insets.class,value);
          myTf.setText(myRenderer.formatText(insets));
          return insets;
        }
        catch(NumberFormatException ex) {
          return super.getValue();
        }
      }
    };
  }
  return myEditor;
}

public final propertyeditor<Insets> getEditor() {
  if (myEditor == null) {
    myEditor = new IntRegexEditor<Insets>(Insets.class,value);
          myTf.setText(myRenderer.formatText(insets));
          return insets;
        }
        catch(NumberFormatException ex) {
          return super.getValue();
        }
      }
    };
  }
  return myEditor;
}

private void updateUI(final Property property) {
  final PropertyRenderer renderer = property.getRenderer();
  renderer.updateUI();
  final propertyeditor editor = property.getEditor();
  if (editor != null) {
    editor.updateUI();
  }
  final Property[] children = property.getChildren(null);
  for (int i = children.length - 1; i >= 0; i--) {
    updateUI(children[i]);
  }
}

public IntroIntProperty(final String name,final Method readMethod,final Method writeMethod,final PropertyRenderer<Integer> renderer,final propertyeditor<Integer> editor,final boolean storeAsClient){
  super(name,readMethod,writeMethod,storeAsClient);
  myRenderer = renderer;
  myEditor = editor;
}

private void updateUI(final Property property){
  final PropertyRenderer renderer = property.getRenderer();
  renderer.updateUI();
  final propertyeditor editor = property.getEditor();
  if(editor != null){
    editor.updateUI();
  }
  final Property[] children = property.getChildren(null);
  for (int i = children.length - 1; i >= 0; i--) {
    updateUI(children[i]);
  }
}

public IntroIntProperty(final String name,storeAsClient);
  myRenderer = renderer;
  myEditor = editor;
}

private void updateUI(final Property property){
  final PropertyRenderer renderer = property.getRenderer();
  renderer.updateUI();
  final propertyeditor editor = property.getEditor();
  if(editor != null){
    editor.updateUI();
  }
  final Property[] children = property.getChildren(null);
  for (int i = children.length - 1; i >= 0; i--) {
    updateUI(children[i]);
  }
}

public IntroIntProperty(final String name,storeAsClient);
  myRenderer = renderer;
  myEditor = editor;
}

public propertyeditor<String> getEditor(){
  return myEditor;
}

public propertyeditor<Integer> getEditor() {
  return myEditor;
}

@Nullable public propertyeditor<Integer> getEditor() {
  return myEditor;
}

public propertyeditor<Boolean> getEditor() {
  return myEditor;
}

public propertyeditor<BorderType> getEditor() {
  return null;
}

public propertyeditor<RadButtonGroup> getEditor() {
  return myEditor;
}

public final propertyeditor<Dimension> getEditor() {
  return myEditor;
}

public propertyeditor<Boolean> getEditor(){
  return myEditor;
}

public propertyeditor<String> getEditor() {
  return myEditor;
}

public propertyeditor<T> getEditor(){
  if (myEditor == null) {
    myEditor = createEditor();
  }
  return myEditor;
}

protected propertyeditor<T> createEditor() {
  return new PrimitiveTypeEditor<T>(myClass);
}

public propertyeditor<Rectangle> getEditor() {
  return myEditor;
}

public propertyeditor<Dimension> getEditor() {
  return myEditor;
}

public propertyeditor<Insets> getEditor() {
  return myEditor;
}

public propertyeditor<String> getEditor(){
  return myEditor;
}

protected propertyeditor<Character> createEditor() {
  return new CharEditor();
}

public final propertyeditor<Integer> getEditor(){
  return null;
}

public final propertyeditor<Boolean> getEditor(){
  return myEditor;
}

public propertyeditor getEditor() {
  return myEditor;
}

public void valueCommitted(final propertyeditor source,final boolean continueEditing,final boolean closeEditorOnError) {
  finishInplaceEditing();
}

public void editingCanceled(final propertyeditor source) {
  cancelInplaceEditing();
}

public void preferredSizeChanged(final propertyeditor source) {
  adjustEditorComponentSize();
}

public propertyeditor<Double> getEditor() {
  if (myEditor == null) {
    myEditor = new PrimitiveTypeEditor<Double>(Double.class);
  }
  return myEditor;
}

public propertyeditor<String> getEditor() {
  return myEditor;
}

public propertyeditor<String> getEditor() {
  if (myEditor == null) {
    myEditor = new BorderSideEditor();
  }
  return myEditor;
}

public propertyeditor<StringDescriptor> getEditor() {
  return myEditor;
}

public propertyeditor<String> getEditor(){
  return myEditor;
}

public propertyeditor<Integer> getEditor() {
  return myEditor;
}

@Nullable public propertyeditor<Integer> getEditor() {
  return myEditor;
}

public propertyeditor<Boolean> getEditor() {
  return myEditor;
}

public propertyeditor<BorderType> getEditor() {
  return null;
}

public static void main(String[] args)throws Exception {


        BeanInfo bi = Introspector.getBeanInfo( BadBeanHidden.class );
        PropertyDescriptor[] ps = bi.getPropertyDescriptors();

        for ( int i = 0; i < ps.length; i++ ) {
            System.out.println( i + " : " + ps[i]);
            System.out.println("  Read : " + ps[i].getReadMethod() );
            System.out.println("  Write : " + ps[i].getWriteMethod() );
            System.out.println(" TYPE " + ps[i].getPropertyType() );
            if ( ps[i] instanceof IndexedPropertyDescriptor ) {
                System.out.println("  I Read : " + ((IndexedPropertyDescriptor)ps[i]).getIndexedReadMethod() );
                System.out.println("  I Write : " +((IndexedPropertyDescriptor)ps[i]).getIndexedWriteMethod() );
                System.out.println(" TYPE " + ((IndexedPropertyDescriptor)ps[i]).getIndexedPropertyType() );
            }


        }
    }

private static IndexedPropertyDescriptor _cloneIndexedPropertyDescriptor(
  IndexedPropertyDescriptor oldDescriptor
  )
{
  try
  {
    IndexedPropertyDescriptor newDescriptor = new IndexedPropertyDescriptor(
                                    oldDescriptor.getName(),oldDescriptor.getReadMethod(),oldDescriptor.getWriteMethod(),oldDescriptor.getIndexedReadMethod(),oldDescriptor.getIndexedWriteMethod());

    // copy the rest of the attributes
    _copyPropertyDescriptor(oldDescriptor,newDescriptor);

    return newDescriptor;
  }
  catch (Exception e)
  {
    _LOG.severe(e);
    return null;
  }
}

private PropertyDescriptor findExistingPropertyDescriptor(String propertyName,Class<?> propertyType) {
    for (PropertyDescriptor pd : this.propertyDescriptors) {
        final Class<?> candidateType;
        final String candidateName = pd.getName();
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            candidateType = ipd.getIndexedPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || candidateType.equals(propertyType.getComponentType()))) {
                return pd;
            }
        }
        else {
            candidateType = pd.getPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || propertyType.equals(candidateType.getComponentType()))) {
                return pd;
            }
        }
    }
    return null;
}

@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj != null && obj instanceof IndexedPropertyDescriptor) {
        IndexedPropertyDescriptor other = (IndexedPropertyDescriptor) obj;
        if (!compareMethods(getIndexedReadMethod(),other.getIndexedReadMethod())) {
            return false;
        }
        if (!compareMethods(getIndexedWriteMethod(),other.getIndexedWriteMethod())) {
            return false;
        }
        if (getIndexedPropertyType() != other.getIndexedPropertyType()) {
            return false;
        }
        return PropertyDescriptorUtils.equals(this,obj);
    }
    return false;
}

private static Property makeProperty(Object o,PropertyDescriptor propertyDescriptor) {
    Class propertyType = propertyDescriptor.getPropertyType();
    if (propertyType != null && Vector.class.isAssignableFrom(propertyType)) {
        return new VectorProperty(o,propertyDescriptor);
    }
    if (propertyType != null && IAtomList.class.isAssignableFrom(propertyType)) {
        return new AtomListProperty(o,propertyDescriptor);
    }
    if (propertyType != null && IMoleculeList.class.isAssignableFrom(propertyType)) {
        return new MoleculeListProperty(o,propertyDescriptor);
    }
    if (!(propertyDescriptor instanceof IndexedPropertyDescriptor) && propertyType.isArray() &&
            !(propertyType.getComponentType().isPrimitive() || propertyType.getComponentType().equals(String.class))) {
        return new ArrayProperty(o,propertyDescriptor);
    }
    return new InstanceProperty(o,propertyDescriptor);
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),ipd.getReadMethod(),ipd.getWriteMethod(),ipd.getIndexedReadMethod(),ipd.getIndexedWriteMethod());
        } else {
            return new PropertyDescriptor(
                    pd.getName(),pd.getReadMethod(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,boolean read,boolean write,boolean readindexed,boolean writeIndexed) {
    PropertyDescriptor pd = BeanUtils.findPropertyDescriptor(type,"size");
    if (pd != null) {
        test(type,"read",read,null != pd.getReadMethod());
        test(type,"write",write,null != pd.getWriteMethod());
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            test(type,"indexed read",readindexed,null != ipd.getIndexedReadMethod());
            test(type,"indexed write",writeIndexed,null != ipd.getIndexedWriteMethod());
        } else if (readindexed || writeIndexed) {
            error(type,"indexed property does not exist");
        }
    } else if (read || write || readindexed || writeIndexed) {
        error(type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean",bt);
    test(pd.getReadMethod());
    test(pd.getWriteMethod());

    // test IndexedPropertyDescriptor
    IndexedPropertyDescriptor ipd = new IndexedPropertyDescriptor("indexed",bt);
    test(ipd.getReadMethod());
    test(ipd.getWriteMethod());
    test(ipd.getIndexedReadMethod());
    test(ipd.getIndexedWriteMethod());

    // test EventSetDescriptor
    EventSetDescriptor esd = new EventSetDescriptor(bt,"test",lt,"process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private PropertyDescriptor findExistingPropertyDescriptor(String propertyName,Class<?> propertyType) {
    for (PropertyDescriptor pd : this.propertyDescriptors) {
        final Class<?> candidateType;
        final String candidateName = pd.getName();
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            candidateType = ipd.getIndexedPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || candidateType.equals(propertyType.getComponentType()))) {
                return pd;
            }
        }
        else {
            candidateType = pd.getPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || propertyType.equals(candidateType.getComponentType()))) {
                return pd;
            }
        }
    }
    return null;
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private PropertyDescriptor findExistingPropertyDescriptor(String propertyName,Class<?> propertyType) {
    for (PropertyDescriptor pd : this.propertyDescriptors) {
        final Class<?> candidateType;
        final String candidateName = pd.getName();
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            candidateType = ipd.getIndexedPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || candidateType.equals(propertyType.getComponentType()))) {
                return pd;
            }
        }
        else {
            candidateType = pd.getPropertyType();
            if (candidateName.equals(propertyName) &&
                    (candidateType.equals(propertyType) || propertyType.equals(candidateType.getComponentType()))) {
                return pd;
            }
        }
    }
    return null;
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

private static void test(Class<?> type,"property does not exist");
    }
}

public static void main(String[] args) throws Exception {
    Class<?> bt = Accessor.getBeanType();
    Class<?> lt = Accessor.getListenerType();

    // test PropertyDescriptor
    PropertyDescriptor pd = new PropertyDescriptor("boolean","process");
    test(esd.getAddListenerMethod());
    test(esd.getRemoveListenerMethod());
    test(esd.getGetListenerMethod());
    test(esd.getListenerMethods());
}

/**
 * Return the Java Class representing the property type of the specified property,or
 * <code>null</code> if there is no such property for the specified bean.  This method
 * follows the same name resolution rules used by <code>getPropertyDescriptor()</code>,* so if the last element of a name reference is indexed,the type of the property itself
 * will be returned.  If the last (or only) element has no property with the specified
 * name,<code>null</code> is returned.
 *
 * @param bean Bean for which a property descriptor is requested
 * @param name Possibly indexed and/or nested name of the property for which a property
 *             descriptor is requested
 * @throws illegalaccessexception    if the caller does not have access to the property
 *                                   accessor method
 * @throws IllegalArgumentException  if <code>bean</code> or <code>name</code> are null
 *                                   or if a nested reference to a property returns null
 * @throws InvocationTargetException if the property accessor method throws an exception
 * @throws NoSuchMethodException     if an accessor method for this property cannot be
 *                                   found
 */
public static Class getPropertyType(Object bean,String name)
   throws illegalaccessexception,InvocationTargetException,NoSuchMethodException
{

   if(bean == null) throw new IllegalArgumentException("No bean specified");
   if(name == null) throw new IllegalArgumentException("No name specified");

   PropertyDescriptor descriptor = getPropertyDescriptor(bean,name);
   if(descriptor == null) {
      return null;
   } else if(descriptor instanceof IndexedPropertyDescriptor) {
      return (((IndexedPropertyDescriptor) descriptor).getIndexedPropertyType());
   } else if(descriptor instanceof MappedPropertyDescriptor) {
      return (((MappedPropertyDescriptor) descriptor).getMappedPropertyType());
   } else {
      return descriptor.getPropertyType();
   }

}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

private static PropertyDescriptor create(PropertyDescriptor pd) {
    try {
        if (pd instanceof IndexedPropertyDescriptor) {
            IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
            return new IndexedPropertyDescriptor(
                    ipd.getName(),pd.getWriteMethod());
        }
    }
    catch (IntrospectionException exception) {
        exception.printstacktrace();
        return null;
    }
}

public void test_MixedBooleanSimpleClass7() throws Exception {
    BeanInfo info = Introspector
            .getBeanInfo(MixedBooleanSimpleClass7.class);
    Method getter = MixedBooleanSimpleClass7.class
            .getDeclaredMethod("isList");
    Method setter = MixedBooleanSimpleClass7.class.getDeclaredMethod(
            "setList",boolean.class);

    for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
        if (propertyName.equals(pd.getName())) {
            assertFalse(pd instanceof IndexedPropertyDescriptor);
            assertEquals(getter,pd.getReadMethod());
            assertEquals(setter,pd.getWriteMethod());
        }
    }
}

public void testSetIndexedWriteMethod_return()
        throws IntrospectionException,NoSuchMethodException,NoSuchMethodException {
    String propertyName = "PropertyFour";
    Class<MockJavaBean> beanClass = MockJavaBean.class;

    Method readMethod = beanClass.getmethod("get" + propertyName,(Class[]) null);
    Method writeMethod = beanClass.getmethod("set" + propertyName,new Class[] { String[].class });
    Method indexedReadMethod = beanClass.getmethod("get" + propertyName,new Class[] { Integer.TYPE });

    IndexedPropertyDescriptor ipd = new IndexedPropertyDescriptor(
            propertyName,readMethod,writeMethod,indexedReadMethod,null);
    assertNull(ipd.getIndexedWriteMethod());
    Method badArgType = beanClass.getmethod("setPropertyFourInvalid",new Class[] { Integer.TYPE,String.class });
    ipd.setIndexedWriteMethod(badArgType);

    assertEquals(String.class,ipd.getIndexedPropertyType());
    assertEquals(String[].class,ipd.getPropertyType());
    assertEquals(Integer.TYPE,ipd.getIndexedWriteMethod().getReturnType());
}

/**
 * Extract a filtered set of PropertyDescriptors from the given BeanWrapper,* excluding ignored dependency types or properties defined on ignored dependency interfaces.
 * @param bw the BeanWrapper the bean was created with
 * @param cache whether to cache filtered PropertyDescriptors for the given bean Class
 * @return the filtered PropertyDescriptors
 * @see #isExcludedFromDependencyCheck
 * @see #filterPropertyDescriptorsForDependencyCheck(org.springframework.beans.BeanWrapper)
 */
protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw,boolean cache) {
    PropertyDescriptor[] filtered = this.filteredPropertyDescriptorsCache.get(bw.getWrappedClass());
    if (filtered == null) {
        if (cache) {
            synchronized (this.filteredPropertyDescriptorsCache) {
                filtered = this.filteredPropertyDescriptorsCache.get(bw.getWrappedClass());
                if (filtered == null) {
                    filtered = filterPropertyDescriptorsForDependencyCheck(bw);
                    this.filteredPropertyDescriptorsCache.put(bw.getWrappedClass(),filtered);
                }
            }
        }
        else {
            filtered = filterPropertyDescriptorsForDependencyCheck(bw);
        }
    }
    return filtered;
}

public static void writeDirectly(Object destination,PropertyDescriptor propertyDescriptor,Object value) {
    try {
        Field field = findField(destination,propertyDescriptor);
        boolean accessible = field.isAccessible();
        try {
            if (!accessible) {
                field.setAccessible(true);
            }
            field.set(destination,value);
        } finally {
            if (!accessible) {
                field.setAccessible(false);
            }
        }
    } catch (NoSuchFieldException | illegalaccessexception e) {
        throw new ReflectionRuntimeException("Failed to write " + getQualifiedPropertyName(destination,propertyDescriptor),e);
    }
}

public ClientInstructionSetCheckedBeanInfo() {
    try {
        beanClass = ClientInstructionSetChecked.class;
        additionalBeanClass = com.twinsoft.convertigo.beans.extractionrules.siteclipper.AbstractClientInstructionWithPath.class;

        iconNameC16 = "/com/twinsoft/convertigo/beans/extractionrules/siteclipper/images/rule_clientinstructionsetchecked_color_16x16.png";
        iconNameC32 = "/com/twinsoft/convertigo/beans/extractionrules/siteclipper/images/rule_clientinstructionsetchecked_color_32x32.png";

        resourceBundle = getResourceBundle("res/ClientInstructionSetChecked");

        displayName = getExternalizedString("display_name");
        shortDescription = getExternalizedString("short_description");

        properties = new PropertyDescriptor[1];

        properties[0] = new PropertyDescriptor("targetValue",beanClass,"getTargetValue","setTargetValue");
        properties[0].setdisplayName(getExternalizedString("property.targetvalue.display_name"));
        properties[0].setShortDescription(getExternalizedString("property.targetvalue.short_description"));
        properties[0].setValue("scriptable",Boolean.TRUE);
    }
    catch(Exception e) {
        com.twinsoft.convertigo.engine.Engine.logBeans.error("Exception with bean info; beanpanel-heading">
            项目：zooadmin   
            文件：BeanMapUtil.java