/*

 * IntEditor.java

 *

 * Created on February 28, 2003, 2:15 PM

 */

package org.netbeans.beaninfo.editors;

import java.beans.*;

import org.openide.explorer.propertysheet.ExPropertyEditor;

import org.openide.util.NbBundle;

import java.util.Arrays;

/** An editor for primitive integer types which allows hinting of tag

 *  values and handles whitespace in setAsText better than the default

 *  one.  Hints may be supplied by the standard method of returning them

 *  from getValue() on the feature descriptor supplied by the PropertyEnv.

 *  To use hinting, return a String[] from getValue ("stringKeys")

 *  and an int[] from getValue ("intValues").  These two

 *  arrays must have the same number of entries and the number of entries

 *  must be at least 1.  Key matching in setAsText is case sensitive.

 *  <P>To provide specific initialization strings (support for generating

 *  code that uses constants instead of their literal value), also supply

 *  from <code>getValue(&quot;codeValues&quot;) an array of initialization

 *  strings.  This array must be the same size as the keys array.

 *

 * @author  Tim Boudreau

 */

public class IntEditor extends PropertyEditorSupport implements 

    ExPropertyEditor {

    String[] keys=null;

    String[] code=null;

    int[] values=null;

    /** Creates a new instance of IntEditor */

    public IntEditor() {

    }

    public void attachEnv(org.openide.explorer.propertysheet.PropertyEnv env) {

        keys = (String[]) env.getFeatureDescriptor().getValue(

            "stringKeys"); //NOI18N

        values = (int[]) env.getFeatureDescriptor().getValue(

            "intValues"); //NOI18N

        code = (String[]) env.getFeatureDescriptor().getValue(

            "codeValues"); //NOI18N

        System.out.println("Env attached.  keys= " + arrToStr(keys) 

            + " values=" + arrToStr(values) + " codes=" + arrToStr(code));

        validateEnv();

    }

    /** Validate that the values supplied by the PropertyEnv are proper,

     *  so there's not an obscure ArrayIndexOutOfBoundsException some time

     *  later because bad information was supplied.  */

    private void validateEnv() {

        //fail fast validation of illegal values

        boolean valid = keys == null && values == null && code == null;

        System.out.println("checked all null - " + valid);

        if (!valid) {

            valid = keys != null && values != null;

            System.out.println("checked both non-null - " + valid);

            if (!valid) {

                throw new EnvException (

                    "You must specify both an array of keys and an array of values if you specify one. Keys=" +   //NOI18N

                    arrToStr(keys) + " Values=" + arrToStr(values));  //NOI18N

            } else {

                valid = keys.length == values.length;

                System.out.println("checked matching lengths - " + valid);

                if (valid) {

                    valid = keys.length > 0 && values.length > 0;

                }

                System.out.println("checked > 0 lengths - " + valid);

                if (!valid) {

                throw new EnvException (

                    "The arrays of keys and values must have the same length and the length must be > 0. keys.length =" +   //NOI18N

                    keys.length + " values.length=" + values.length + " Keys=" + //NOI18N

                    arrToStr(keys) + " Values=" + arrToStr(values));  //NOI18N

                } else {

                    if (code != null) {

                        valid = code.length == keys.length;

                        System.out.println("checked code length - " + valid);

                        if (valid) {

                            valid = code.length > 0;

                        }

                        System.out.println("checked code length > 0 - " + valid);

                        if (!valid) {

                            throw new EnvException (

                                "The arrays of keys and values and codes must all have the same length, > 0. keys.length =" +   //NOI18N

                                keys.length + " values.length=" + values.length + //NOI18N

                                " Code.length=" + code.length + " Keys=" + //NOI18N

                                arrToStr(keys) + " Values=" + arrToStr(values));  //NOI18N

                        }

                    }

                }

            }

        }

    }

    private static final String arrToStr (String[] s) {

        if (s == null) return "null"; //NOI18N

        StringBuffer out = new StringBuffer (s.length * 10);

        for (int i=0; i < s.length; i++) {

            out.append (s[i]);

            if (i != s.length-1) {

                out.append (","); //NOI18N

            }

        }

        return out.toString();

    }

    private static final String arrToStr (int[] s) {

        if (s == null) return "null"; //NOI18N

        StringBuffer out = new StringBuffer (s.length * 3);

        for (int i=0; i < s.length; i++) {

            out.append (s[i]);

            if (i != s.length-1) {

                out.append (","); //NOI18N

            }

        }

        return out.toString();

    }

    private String getStringRep (int i) {

        if (keys != null) {

            try {

                return keys[i];

            } catch (ArrayIndexOutOfBoundsException ae) {

                throw new IllegalArgumentException (

                    "This property editor uses a set of keyed values, " +  //NOI18N

                    "and the value " //NOI18N

                    + i + " is out of range."); //NOI18N

            }

        } else {

            return Integer.toString(i);

        }

    }

    public String getAsText() {

        return getStringRep (((Integer) getValue()).intValue());

    }

    public void setAsText(String s) {

        s = s.trim();

        if (keys == null) {

            //standard int handling

            setValue (new Integer (Integer.parseInt (s)));

        } else {

            //use the keys

            int idx = Arrays.asList (keys).indexOf(s);

            if ((idx == -1) || (idx > values.length-1)) {

                StringBuffer sb = new StringBuffer (40);

                //if something goes wrong, give a clue what it was

                sb.append ("Illegal value: \"" + s + "\" - valid values are: "); //NOI18N

                for (int i=0; i < keys.length; i ++) {

                    sb.append (keys[i]);

                    if (i != keys.length - 1) {

                        sb.append (','); //NOI18N

                    }

                }

                throw new IllegalArgumentException 

                    (sb.toString()); //NOI18N

            } else {

                setValue (new Integer (values[idx]));

            }

        }

    }

    public String[] getTags () {

        return keys;

    }

    public String getJavaInitializationString() {

        String result;

        if (code == null) {

            result = getValue().toString();

        } else {

            result = code[((Integer) getValue()).intValue()];

        }

        return result;

    }

    /** This class exists to enable unit tests to differentiate

     *  between code bugs in the editors and invalid values from

     *  the propertyEnv.  */

    public static class EnvException extends IllegalArgumentException {  

        public EnvException (String s) { super (s); }

    }

}

/*

 * BoolEditor.java

 *

 * Created on February 28, 2003, 1:13 PM

 */

package org.netbeans.beaninfo.editors;

import java.beans.*;

import org.openide.explorer.propertysheet.ExPropertyEditor;

import org.openide.util.NbBundle;

/** Replacement editor for boolean primitive values which supports 

 *  internationalization and alternate string values that

 *  can be supplied to the property editor via adding an array

 *  returning an array of two Strings (false then true) from

 *  <code>env.getFeatureDescriptor().getValue()</code>.  These

 *  string values will then be used for getAsText, setAsText, and getTags.

 *  These strings should be correctly internationalized if supplied

 *  by a module.  String value matching in setAsText is non-case-sensitive

 *  ("TRUE" and "tRue" are equivalent).

 *

 * @author  Tim Boudreau

 */

public class BoolEditor extends PropertyEditorSupport implements ExPropertyEditor {

    String[] stringValues = null;

    /** Creates a new instance of BoolEditor */

    public BoolEditor() {

    }

    public void attachEnv(org.openide.explorer.propertysheet.PropertyEnv env) {

        stringValues = (String[]) env.getFeatureDescriptor().getValue(

            "stringValues"); //NOI18N

    }

    private String getStringRep (boolean val) {

        if (stringValues != null) {

            return stringValues [val ? 0 : 1];

        }

        String result;

        if (val) {

            result = NbBundle.getMessage(BoolEditor.class, "TRUE"); //NOI18N

        } else {

            result = NbBundle.getMessage(BoolEditor.class, "FALSE"); //NOI18N

        }

        return result;

    }

    /** Returns Boolean.TRUE, Boolean.FALSE or null in the case of an

     *  unrecognized string. */

    private Boolean stringVal (String val) {

        String valToTest = val.trim().toUpperCase();

        String test = getStringRep (true).toUpperCase();

        if (test.equals(valToTest)) return Boolean.TRUE;

        test = getStringRep (false).toUpperCase();

        if (test.equals(valToTest)) return Boolean.FALSE;

        return null;

    }

    public String getJavaInitializationString() {

        Boolean val = (Boolean) getValue();

        if (val == null) return "null"; //NOI18N

        return Boolean.TRUE.equals (getValue()) ? "true" : "false"; //NOI18N

    }

    public String[] getTags () {

        return new String[] {

            getStringRep (true), getStringRep (false)

        };

    }

    public String getAsText() {

        Boolean val = (Boolean) getValue();

        if (val == null) return NbBundle.getMessage (BoolEditor.class, "NULL");

        return getStringRep (Boolean.TRUE.equals (getValue()));

    }

    public void setAsText(String txt) {

        Boolean val = stringVal (txt);

        boolean newVal = val == null ? false : val.booleanValue();

        setValue (newVal ? Boolean.TRUE : Boolean.FALSE);

    }

    static BoolEditor ed = new BoolEditor();

    public static void main (String[] args) {

        Boolean val = Boolean.TRUE;

        ed.setValue (val);

        checkValue (val.booleanValue());

        val = Boolean.FALSE;

        ed.setValue (val);

        checkValue (val.booleanValue());

    }

    public static boolean checkValue (boolean val) {

        return val == ((Boolean) ed.getValue()).booleanValue();

    }

}

/*

 * EnvProvider.java

 *

 * Created on March 10, 2003, 4:14 PM

 */

package org.openide.explorer.propertysheet;

import org.openide.nodes.Node.Property;

/** Trivial class to manufacture PropertyEnv instances without having

 *to create visual components.

 *

 * @author  Tim Boudreau

 */

public class EnvProvider {

    /** Creates a new instance of EnvProvider */

    public EnvProvider() {

    }

    public static final PropertyEnv getEnv (Property p) {

        PropertyEnv result = new PropertyEnv();

        result.setFeatureDescriptor (p);

        return result;

    }

}

/*

 * IntEditorTest.java

 * JUnit based test

 *

 * Created on March 10, 2003, 1:10 PM

 */

package org.netbeans.beaninfo.editors;

import java.beans.*;

import junit.framework.*;

import org.openide.explorer.propertysheet.*;

import org.openide.nodes.*;

import org.openide.util.NbBundle;

import java.util.Arrays;

/** Unit test for priimitive int property editor

 *

 * @author Tim Boudreau

 */

public class IntEditorTest extends TestCase {

    String[] goodKeys = new String[] {"zero","one","two","three"};

    int[] goodValues = new int[] {0,1,2,3};

    String [] goodCode = new String[] {"0", "0+1", "1+1", "1+2"};

    IntProp goodProp = new IntProp (0, goodKeys, goodValues, goodCode);

    String[] badKeys = new String[] {"blah"};

    int[] badValues = new int[] {1,15};

    String[] emptyKeys = new String[0];

    IntProp badMismatchProp = new IntProp (1, emptyKeys, goodValues, null);

    IntProp badMismatchProp2 = new IntProp (1, goodKeys, goodValues, emptyKeys);

    public IntEditorTest(java.lang.String testName) {

        super(testName);

    }

    public static Test suite() {

        TestSuite suite = new TestSuite(IntEditorTest.class);

        return suite;

    }

    /** Test of attachEnv method, of class org.netbeans.beaninfo.editors.IntEditor. */

    public void testAttachEnv() {

        System.out.println("testAttachEnv");

        PropertyEditor ped = goodProp.getPropertyEditor();

        if (!(ped instanceof ExPropertyEditor)) {

            fail ("Not an instance of ExPropertyEditor: " + ped.getClass().getName());

        } else {

            ExPropertyEditor ex = (ExPropertyEditor) ped;

            prepareEnv (goodProp, ex, false);

        }

        ped = badMismatchProp.getPropertyEditor();

        if (!(ped instanceof ExPropertyEditor)) {

            fail ("Not an instance of ExPropertyEditor: " + ped.getClass().getName());

        } else {

            ExPropertyEditor ex = (ExPropertyEditor) ped;

            prepareEnv (badMismatchProp, ex, true);

        }

        ped = badMismatchProp2.getPropertyEditor();

        if (!(ped instanceof ExPropertyEditor)) {

            fail ("Not an instance of ExPropertyEditor: " + ped.getClass().getName());

        } else {

            ExPropertyEditor ex = (ExPropertyEditor) ped;

            prepareEnv (badMismatchProp2, ex, true);

        }

    }

    /** Test of getAsText method, of class org.netbeans.beaninfo.editors.IntEditor. */

    public void testGetAsText() {

        System.out.println("testGetAsText");

        // Add your test code below by replacing the default call to fail.

        ExPropertyEditor ped = getConfiguredEditor (goodProp);

        ped.setValue (new Integer(0));

        String s = ped.getAsText();

        if ("zero".equals(s)) return;

    }

    /** Test of setAsText method, of class org.netbeans.beaninfo.editors.IntEditor. */

    public void testSetAsText() {

        System.out.println("testSetAsText");

        ExPropertyEditor ped = getConfiguredEditor (goodProp);

        ped.setAsText ("two");

        int i = ((Integer) ped.getValue()).intValue();

        if (i != 2) {

            fail ("Set text value of propertyeditor to \"two\" but getValue() returns " + i);

        }

    }

    /** Test of getTags method, of class org.netbeans.beaninfo.editors.IntEditor. */

    public void testGetTags() {

        System.out.println("testGetTags");

        ExPropertyEditor ped = getConfiguredEditor (goodProp);

        String[] s = ped.getTags();

        if (s.length != 4) fail ("Keys length should be 4 but is " + s.length);

        if ("zero".equals(s[0])) return;

        fail ("First key should be \"zero\" but is " + s[0]);

    }

    /** Test of getJavaInitializationString method, of class org.netbeans.beaninfo.editors.IntEditor. */

    public void testGetJavaInitializationString() {

        System.out.println("testGetJavaInitializationString");

        ExPropertyEditor ped = getConfiguredEditor (goodProp);

        ped.setValue (new Integer(3));

        String s = ped.getJavaInitializationString();

        if (!("1+2".equals (s))) {

            fail ("GetJavaInitializationString returns " + s + " but should return \"1+1\"");

        }

    }

    private ExPropertyEditor getConfiguredEditor (IntProp p) {

        ExPropertyEditor result = (ExPropertyEditor) p.getPropertyEditor();

        try {

            result.setValue ((Integer) p.getValue());

            prepareEnv (p, result, false);

        } catch (Exception e) {

            //Other tests will fail if an exception is thrown, ignore

        }

        return result;

    }

    private void prepareEnv (IntProp prop, ExPropertyEditor pe, boolean shouldFail) {

        PropertyEnv env = org.openide.explorer.propertysheet.EnvProvider.getEnv(prop);

        org.netbeans.beaninfo.editors.IntEditor.EnvException e=null;

        try {

            pe.attachEnv (env);

        } catch (org.netbeans.beaninfo.editors.IntEditor.EnvException ie) {

            e = ie;

        } finally {

            if (shouldFail && e == null) {

                fail ("EnvException should have been thrown but wasn't.");

            }

        }

    }

    private class IntProp extends Node.Property {

        String[] k;

        int[] v;

        String[] c;

        int val;

        public IntProp (int val, String[] keys, int[] vals, String[] codeVals) {

            super (Integer.TYPE);

            this.val = val;

            v = vals;

            k = keys;

            c = codeVals;

        }

        public Object getValue (String key) {

            if ("stringKeys".equals(key)) return k;

            if ("intValues".equals(key)) return v;

            if ("codeValues".equals(key)) return c;

            Object result = super.getValue(key);

            return result;

        }

        public boolean canRead() {

            return true;

        }

        public boolean canWrite() {

            return true;

        }

        public Object getValue() throws IllegalAccessException, java.lang.reflect.InvocationTargetException {

            return new Integer(val);

        }

        public void setValue(Object val) throws IllegalAccessException, IllegalArgumentException, java.lang.reflect.InvocationTargetException {

            this.val = ((Integer) val).intValue();

        }

        public PropertyEditor getPropertyEditor () {

            return new org.netbeans.beaninfo.editors.IntEditor ();

        }

    }

}

	<TR> 

	    <TD rowspan='3'>java.lang.String </TD>

	    <TD>instructions</TD>

	    <TD>String</TD>

	    <TD>Should contain localized instructions to the user, to be displayed in the

                String custom editor</TD>

        </TR>

        <TR>

            <TD>oneline</TD>

            <TD>Boolean</TD>

            <TD>Instructs the property editor that the custom editor should present

                a one-line text control (JTextField or equivalent) rather than

                a multi-line text control (JTextArea or equivalent).

            </TD>

        </TR>

        <TR>

	    <TD>suppressCustomEditor</TD>

            <TD>Boolean</TD>

            <TD>Instructs the property editor to suppress the custom editor 

                button on the property sheet.</TD>

        </TR>

	<TR>

	    <TD rowspan='3'> java.lang.Integer and primitive integer </TD>

            <TD>stringKeys</TD>

            <TD>String[]</TD>

            <TD> Should contain internationalized strings that should be used as tags in

                 a combo box.  Number of elements must be >= 1.  If this hint is 

                 supplied, the hint <code>intKeyValues</code> must also be supplied

            </TD>

        </TR>

        <TR>

            <TD>intValues</TD>

            <TD> int[] </TD>

            <TD> The values the string keys correspond to. Must have the same number

                 of elements as the string array </TD>

        </TR>

        <TR>

            <TD>codeValues</TD>

            <TD> String[] </TD>

            <TD> Values to use in <code>getJavaInitializationString()</code> in place

                 of hardcoding numbers (useful for constants)</TD>

        </TR>

        <TR>

           <TD> java.lang.Boolean </TD>

           <TD> stringValues </TD>

           <TD> String[] </TD>

           <TD> Should contain an array of two strings to be used for user

                displayable text for the boolean values, in the order

                false, true - for example, <code>new String[] {"off","on"}</code>.</TD

        </TR>