Changeset 14783


Ignore:
Timestamp:
2007-11-07T11:10:02+13:00 (15 years ago)
Author:
anna
Message:

If a plugin option has a display name, use the displayName instead of option name, such as process_expression instead of process_exp.

Location:
gli/trunk/src/org/greenstone/gatherer/cdm
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • gli/trunk/src/org/greenstone/gatherer/cdm/Argument.java

    r12824 r14783  
    5151 */
    5252public class Argument
    53     implements Comparable, Serializable {
    54     /** An element of the argument type enumeration specifying a combobox control. */
    55     static final public byte ENUM = 0;
    56     /** An element of the argument type enumeration specifying a checkbox control. */
    57     static final public byte FLAG = 1;
    58     /** An element of the argument type enumeration specifying a tree control. */
    59     static final public byte HIERARCHY = 2;
    60     /** An element of the argument type enumeration specifying a spinner control. */
    61     static final public byte INTEGER = 3;
    62     /** An element of the argument type enumeration specifying a language combobox control. */
    63     static final public byte LANGUAGE = 4;
    64     /** An element of the argument type enumeration specifying a list control. */
    65     static final public byte METADATA = 5;
    66     /** An element of the argument type enumeration specifying a metadata combobox control. */
    67     static final public byte METADATUM = 6;
    68     /** An element of the argument type enumeration specifying a text field. */
    69     static final public byte STRING = 7;
    70     /** An element of the argument type enumeration specifying a regular expression text field. */
    71     static final public byte REGEXP = 8;
    72     /** An element of the argument type enumeration specifying a metadata set combobox control. */
    73     static final public byte METADATA_SET_NAMESPACE = 9;
    74 
    75  ///////////kk added the number was 9, I changed it to 10//////////////
    76   /** An element of the argument type enumeration specifying a text field. */
    77     static final public byte URL = 10;
    78     /////////////////////////////////////////////////////////////////
    79 
    80     /** true if this argument should actually be hidden within the GLI. This is important for arguments such as import dir or other location critical arguments. */
    81     private boolean hidden_gli = false;
    82     /** <i>true</i> if this argument is required for the applicable script to work properly, <i>false</i> otherwise. */
    83     private boolean required = false;
    84     /** The type of this argument. Used to be an int, but bytes are cheaper. */
    85     private byte type = STRING;
    86     /** The maximum value an integer based control can have. */
    87     private int maximum = Integer.MAX_VALUE;
    88     /** The minimum value an integer based control can have. */
    89     private int minimum = Integer.MIN_VALUE;
    90     /** Every argument has a detail mode level at which it becomes available to the user to edit.
    91      * @see org.greenstone.gatherer.Configuration
    92      */
    93     private int mode_level = Configuration.LIBRARIAN_MODE;
    94     /** The DOM element this argument is built around, if any. */
    95     private Element element;
    96     /** If the argument is of type ENUM then this map holds all the various options. Each entry is an &lt;option value&gt; -&gt; &lt;description&gt; mapping. */
    97     private ArrayList option_list = null;
    98     /** A default value for parameter-type arguments. May be a Perl pattern. */
    99     private String default_value = null;
    100     /** The text description of this argument parsed from the pluginfo output. */
    101     private String description = null;
    102     /** The argument flag as it appears in the command. Also used as the unique identifier of an argument. */
    103     private String name = null;
    104     /** The plugin that owns this argument, for the purposes of visualising inheritance. */
    105     private String owner = null;
    106 
    107     private String display_name = null;
    108 
    109     /** Default Constructor. */
    110     public Argument() {
    111     }
    112 
    113     /** Another constructor but this one is a little more interesting as it takes a DOM element.
    114      * @param element the Element this argument is based around
    115      */
    116     public Argument(Element element) {
    117     this.element = element;
    118     }
    119 
    120     /** Method to add an element to the option_list.
    121      * @param name the name value of the option as a String
    122      * @param desc the description of this options as a String
    123      */
    124     public void addOption(String name, String desc) {
    125     if(type == ENUM && name != null) {
    126         if(desc == null) {
    127         desc = "";
    128         }
    129         if(option_list == null) {
    130         option_list = new ArrayList();
    131         }
    132         option_list.add(new ArgumentOption(name, desc));
    133     }
    134     }
    135 
    136     /** Method to compare two arguments for ordering.
    137      * @param object the argument we are comparing to, as an Object
    138      * @return an int specifying the argument order, using values as set out in String
    139      * @see org.greenstone.gatherer.cdm.Argument
    140      */
    141     public int compareTo(Object object) {
    142     if(object instanceof Argument) {
    143         return getName().compareTo(((Argument)object).getName());
    144     }
    145     else {
    146         return toString().compareTo(object.toString());
    147     }
    148     }
    149 
    150     /** Create a copy of this argument.
    151      * @return a newly created Argument with the same details as this one
    152      */
    153     public Argument copy() {
    154     Argument copy = new Argument();
    155     copy.setDefaultValue(default_value);
    156     copy.setDescription(description);
    157     copy.setOptions(option_list);
    158     copy.setOwner(owner);
    159     copy.setName(name);
    160     copy.setRequired(required);
    161     copy.setType(type);
    162     copy.setMinimum(minimum);
    163     copy.setMaximum(maximum);
    164     copy.setModeLevel(mode_level);
    165     copy.setHiddenGLI(hidden_gli);
    166     return copy;
    167     }
    168 
    169     /** Method to determine if two arguments are equal.
    170      * @param object the argument to test against, as an Object
    171      * @return true if the arguments names match, false otherwise
    172      */
    173     public boolean equals(Object object) {
    174     return (compareTo(object) == 0);
    175     }
    176 
    177     /** Method to retrieve the value of default_value.
    178      * @return a String containing the default value
    179      */
    180     public String getDefaultValue() {
    181     return default_value;
    182     }
    183 
    184     /** Method to retrieve this arguments description.
    185      * @return a String containing the description
    186      */
    187     public String getDescription() {
    188     return description;
    189     }
    190 
    191     public Element getElement() {
    192     return element;
    193     }
    194     /** Retrieve the upper bound of a range based argument.
    195      * @return the maximum as an int
    196      */
    197     public int getMaximum() {
    198     return maximum;
    199     }
    200 
    201     /** Retrieve the lower bound of a range based argument.
    202      * @return the minimum as an int
    203      */
    204     public int getMinimum() {
    205     return minimum;
    206     }
    207 
    208     /** Retrieves the mode level at which this argument should become available. Any higher levels should also see this argument.
    209      * @return the mode level as an int
    210      */
    211     public int getModeLevel() {
    212     return mode_level;
    213     }
    214 
    215     /** Method to retrieve the value of name.
    216      * @return a String containing the argument name
    217      * @see org.greenstone.gatherer.util.StaticStrings#NAME_ATTRIBUTE
    218      */
    219     public String getName() {
    220     if(name == null && element != null) {
    221         name = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    222     }
    223     return name;
    224     }
    225 
    226     public String getDisplayName() {
    227     return display_name;
    228     }
    229 
    230 
    231     /** Method to retrieve the option list for this argument.
    232      * @return a HashMap containing &lt;option value&gt; -&gt; &lt;description&gt; entries
    233      */
    234     public ArrayList getOptions() {
    235     return option_list;
    236     }
    237 
    238     /** Retrieve the name of the owner of this argument.
    239      * @return the owners name as a String
    240      */
    241     public String getOwner() {
    242     return owner;
    243     }
    244    
    245     /** Method to determine the type of this argument.
    246      * @return a byte specifying the type
    247      */
    248     public byte getType() {
    249     return type;
    250     }
    251 
    252     /** Method to retrieve the value of value.
    253      * @return the value of value as a String
    254      * @see org.greenstone.gatherer.Gatherer#c_man
    255      * @see org.greenstone.gatherer.collection.CollectionManager#getCollection
    256      */
    257     public String getValue()
    258     {
    259     // Only assigned arguments have values.
    260     if (element == null) {
    261         return null;
    262     }
    263 
    264     return XMLTools.getValue(element);
    265     }
    266 
    267 
    268     /** Method to determine if this argument has been assigned.
    269      * @return true if it has, false otherwise
    270      * @see org.greenstone.gatherer.util.StaticStrings#ASSIGNED_ATTRIBUTE
    271      * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
    272      */
    273     public boolean isAssigned() {
    274     return (element != null && element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR));
    275     }
    276 
    277     /** Determine if this is a custom argument ie one that has been parsed from the config file but doesn't have a matching entry in the argument library.
    278      * @return true if this argument is a custom, false otherwise
    279      * @see org.greenstone.gatherer.util.StaticStrings#CUSTOM_ATTRIBUTE
    280      * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
    281      */
    282     public boolean isCustomArgument() {
    283     return (element != null && element.getAttribute(StaticStrings.CUSTOM_ATTRIBUTE).equals(StaticStrings.TRUE_STR));
    284     }
    285 
    286     /** Determine if this argument is hidden in GLI
    287      * @return true if the argument is hidden, false otherwise
    288      */
    289     public boolean isHiddenGLI() {
    290     return hidden_gli;
    291     }
    292 
    293     /** Method to determine of this argument is required for the associated script to work.
    294      * @return true if this argument is required, false otherwise
    295      */
    296     public boolean isRequired() {
    297     return required;
    298     }
    299 
    300     /** Method to allow for the activation of arguments that might never have their setValue() method called.
    301      * @param assigned the desired state as a boolean
    302      * @see org.greenstone.gatherer.util.StaticStrings#ASSIGNED_ATTRIBUTE
    303      * @see org.greenstone.gatherer.util.StaticStrings#FALSE_STR
    304      * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
    305      */
    306     public void setAssigned(boolean assigned) {
    307     if(element != null) {
    308         element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (assigned ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
    309     }
    310     }
    311 
    312     /** Sets the value of default_value.
    313      * @param default_value The new value for default_value as a <strong>String</strong>.
    314      */
    315     public void setDefaultValue(String default_value) {
    316     this.default_value = default_value;
    317     }
    318 
    319     /** Set the value of desc.
    320      * @param description the new value of desc as a String
    321      */
    322     public void setDescription(String description) {
    323     this.description = description;
    324     }
    325 
    326     /** Set the element this argument should be based upon.
    327      * @param element the Element
    328      */
    329     public void setElement(Element element) {
    330     this.element = element;
    331     }
    332 
    333     /** Mark this argument as being hidden in GLI. */
    334     public void setHiddenGLI(boolean hidden) {
    335     this.hidden_gli = hidden;
    336     }
    337 
    338     /** Set the upper bound for a range type argument.
    339      * @param maximum the maximum as an int
    340      */
    341     public void setMaximum(int maximum) {
    342     this.maximum = maximum;
    343     }
    344 
    345     /** Set the lower bound for a range type argument.
    346      * @param minimum the minimum as an int
    347      */
    348     public void setMinimum(int minimum) {
    349     this.minimum = minimum;
    350     }
    351 
    352     /** Set the detail mode level where this argument will become available.
    353      * @param mode_level the mode level as an int
    354      */
    355     public void setModeLevel(int mode_level) {
    356     this.mode_level = mode_level;
    357     }
    358 
    359     /** Set the value of name.
    360      * @param name the new value of name as a String
    361      */
    362     public void setName(String name) {
    363     this.name = name;
    364     }
    365 
    366     /** Sets the value of the options list.
    367      * @param list the new options list as a HashMap
    368      */
    369     public void setOptions(ArrayList list) {
    370     this.option_list = list;
    371     }
    372 
    373     /** Set the owner of this argument.
    374      * @param owner the name of the owner of this argument as a String
    375      */
    376     public void setOwner(String owner) {
    377     this.owner = owner;
    378     }
    379 
    380     /** Set the value of required.
    381      * @param required the new value of required as a boolean
    382      */
    383     public void setRequired(boolean required) {
    384     this.required = required;
    385     }
    386 
    387     /** Set the value of type.
    388      * @param type the new value of type as an byte
    389      */
    390     public void setType(byte type) {
    391     this.type = type;
    392     }
    393 
    394     /** Set the value of type, by matching a type to the given string.
    395      * @param new_type a String which contains the name of a certain argument type
    396      * @see org.greenstone.gatherer.util.StaticStrings#ENUM_STR
    397      * @see org.greenstone.gatherer.util.StaticStrings#FLAG_STR
    398      * @see org.greenstone.gatherer.util.StaticStrings#HIERARCHY_STR
    399      * @see org.greenstone.gatherer.util.StaticStrings#INT_STR
    400      * @see org.greenstone.gatherer.util.StaticStrings#LANGUAGE_STR
    401      * @see org.greenstone.gatherer.util.StaticStrings#METADATA_TYPE_STR
    402      * @see org.greenstone.gatherer.util.StaticStrings#METADATUM_TYPE_STR
    403      * @see org.greenstone.gatherer.util.StaticStrings#REGEXP_STR
    404      */
    405     public void setType(String new_type) {
    406     if(new_type.equalsIgnoreCase(StaticStrings.ENUM_STR)) {
    407         this.type = ENUM;
    408         option_list = new ArrayList();
    409     }
    410     else if(new_type.equalsIgnoreCase(StaticStrings.FLAG_STR)) {
    411         this.type = FLAG;
    412     }
    413     else if(new_type.equalsIgnoreCase(StaticStrings.HIERARCHY_STR)) {
    414         this.type = HIERARCHY;
    415     }
    416     else if(new_type.equalsIgnoreCase(StaticStrings.INT_STR)) {
    417         this.type = INTEGER;
    418     }
    419     else if(new_type.equalsIgnoreCase(StaticStrings.LANGUAGE_STR)) {
    420         this.type = LANGUAGE;
    421     }
    422     else if(new_type.equalsIgnoreCase(StaticStrings.METADATA_TYPE_STR)) {
    423         this.type = METADATA;
    424     }
    425     else if(new_type.equalsIgnoreCase(StaticStrings.METADATUM_TYPE_STR)) {
    426         this.type = METADATUM;
    427     }
    428     else if(new_type.equalsIgnoreCase(StaticStrings.REGEXP_STR)) {
    429         this.type = REGEXP;
    430     }
    431     else {
    432         this.type = STRING;
    433     }
    434     }
    435 
    436     /** Method to set the value of this argument.
    437      * @param value the new value for the argument
    438      * @see org.greenstone.gatherer.Gatherer#println
    439      */
    440     public void setValue(String value) {
    441     if(element != null) {
    442         XMLTools.setValue(element, value);
    443     }
    444     else {
    445         DebugStream.println("Argument.setValue(" + value + ") called on a base Argument.");
    446     }
    447     }
    448 
    449     /** Set the values vector to the given values. Currently I just assign the new values, whereas I may later want to implement a deep clone.
    450      * @param values an ArrayList of values
    451      * @see org.greenstone.gatherer.Gatherer#println
    452      */
    453     public void setValues(ArrayList values) {
    454     if(element != null) {
    455         StringBuffer value = new StringBuffer();
    456         int value_length = values.size();
    457         for(int i = 0; i < value_length; i++) {
    458         value.append(values.get(i));
    459         value.append(StaticStrings.COMMA_CHARACTER);
    460         }
    461         value.deleteCharAt(value.length() - 1); // Remove last ','
    462         XMLTools.setValue(element, value.toString());
    463     }
    464     else {
    465         DebugStream.println("Argument.setValues([" + values.size() + " items]) called on a base Argument.");
    466     }
    467     }
    468 
    469     /** Method for translating the data of this class into a string.
    470      * @return a String containing a fragment of the total arguments string
    471      * @see org.greenstone.gatherer.Gatherer#c_man
    472      * @see org.greenstone.gatherer.collection.CollectionManager#getCollection
    473      * @see org.greenstone.gatherer.util.StaticStrings#COMMA_CHARACTER
    474      * @see org.greenstone.gatherer.util.StaticStrings#NAME_ATTRIBUTE
    475      * @see org.greenstone.gatherer.util.StaticStrings#SPACE_CHARACTER
    476      * @see org.greenstone.gatherer.util.StaticStrings#SPEECH_CHARACTER
    477      */
    478     public String toString()
    479     {
    480     StringBuffer text = new StringBuffer("-");
    481 
    482     if (element == null) {
    483         return text.toString();
    484     }
    485 
    486     if (name == null) {
    487         name = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
    488     }
    489     text.append(name);
    490 
    491     String value = XMLTools.getValue(element);
    492     if (value.length() == 0) {
    493         return text.toString();
    494     }
    495 
    496     text.append(StaticStrings.SPACE_CHARACTER);
    497 
    498 //  // Handle metadata elements specially
    499 //  if (type == METADATA || type == METADATUM) {
    500 //      // Tokenize the string
    501 //      StringTokenizer tokenizer = new StringTokenizer(value, ",");
    502 //      while (tokenizer.hasMoreTokens()) {
    503 //      String token = tokenizer.nextToken();
    504 
    505 //      MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName(token);
    506 //      if (metadata_element != null) {
    507 //          text.append(metadata_element.getFullName());
    508 //      }
    509 //      else {
    510 //          text.append(token);
    511 //      }
    512 
    513 //      if (tokenizer.hasMoreTokens()) {
    514 //          text.append(StaticStrings.COMMA_CHARACTER);
    515 //      }
    516 //      }
    517 //      return text.toString();
    518 //  }
    519 
    520     // If the value contains a space, add speech marks
    521     //   (Except for metadata elements, which won't have spaces when written out to collect.cfg)
    522     if (value.indexOf(StaticStrings.SPACE_CHARACTER) != -1 && !(type == METADATUM || type == METADATA)) {
    523         value = StaticStrings.SPEECH_CHARACTER + value + StaticStrings.SPEECH_CHARACTER;
    524     }
    525 
    526     text.append(value);
    527     return text.toString();
    528     }
    529 
    530     /** parse the <Option> XML from eg import.pl -xml or pluginfo.pl -xml */
    531     public void parseXML(Element option) {
    532 
    533     for(Node node = option.getFirstChild(); node != null; node = node.getNextSibling()) {
    534         String node_name = node.getNodeName();
    535         if(node_name.equals("Name")) {
    536         setName(XMLTools.getValue(node));
    537         }
    538         else if(node_name.equals("Desc")) {
    539         setDescription(XMLTools.getValue(node));
    540         }
    541         else if(node_name.equals("Type")) {
    542         setType(XMLTools.getValue(node));
    543         }
    544         else if(node_name.equals("Default")) {
    545         setDefaultValue(XMLTools.getValue(node));
    546         }
    547         else if(node_name.equals("Required")) {
    548         String v = XMLTools.getValue(node);
    549         if(v != null && v.equals("yes")) {
    550             setRequired(true);
    551         }
    552         }
    553         else if(node_name.equals("List")) {
    554         // Two final loops are required to parse lists.
    555         for(Node value = node.getFirstChild(); value != null; value = value.getNextSibling()) {
    556             if(value.getNodeName().equals("Value")) {
    557             String key = null;
    558             String desc = "";
    559             for(Node subvalue = value.getFirstChild(); subvalue != null; subvalue = subvalue.getNextSibling()) {
    560                 node_name = subvalue.getNodeName();
    561                 if(node_name.equals("Name")) {
    562                 key = XMLTools.getValue(subvalue);
    563                 }
    564                 else if(node_name.equals("Desc")) {
    565                 desc = XMLTools.getValue(subvalue);
    566                 }
    567             }
    568             if(key != null) {
    569                 addOption(key, desc);
    570             }
    571             }
    572         }
    573         }
    574         else if(node_name.equals("Range")) {
    575         String range_raw = XMLTools.getValue(node);
    576         int index = -1;
    577         if((index = range_raw.indexOf(StaticStrings.COMMA_CHARACTER)) != -1) {
    578             if(index > 0) {
    579             try {
    580                 String first_number = range_raw.substring(0, index);
    581                 setMinimum(Integer.parseInt(first_number));
    582                 first_number = null;
    583             }
    584             catch(Exception exception) {
    585             }
    586             }
    587            
    588             if(index + 1 < range_raw.length()) {
    589             try {
    590                 String second_number = range_raw.substring(index + 1);
    591                 setMaximum(Integer.parseInt(second_number));
    592                 second_number = null;   
    593             }
    594             catch(Exception exception) {
    595             }
    596             }
    597         }
    598         // Else it wasn't a valid range anyway, so ignore it
    599         }
    600         else if(node_name.equals("HiddenGLI")) {
    601         setHiddenGLI(true);
    602         }
    603         else if(node_name.equals("ModeGLI")) {
    604         String mode_level_str = XMLTools.getValue(node);
    605         try {
    606             int mode_level = Integer.parseInt(mode_level_str);
    607             setModeLevel(mode_level);
    608         }
    609         catch(Exception exception) {
    610             DebugStream.println("Exception in Argument.parseXML() - Unexpected but non-fatal");
    611             DebugStream.printStackTrace(exception);
    612         }
    613         }
    614        
    615     } // for each option
     53implements Comparable, Serializable {
     54    /** An element of the argument type enumeration specifying a combobox control. */
     55    static final public byte ENUM = 0;
     56    /** An element of the argument type enumeration specifying a checkbox control. */
     57    static final public byte FLAG = 1;
     58    /** An element of the argument type enumeration specifying a tree control. */
     59    static final public byte HIERARCHY = 2;
     60    /** An element of the argument type enumeration specifying a spinner control. */
     61    static final public byte INTEGER = 3;
     62    /** An element of the argument type enumeration specifying a language combobox control. */
     63    static final public byte LANGUAGE = 4;
     64    /** An element of the argument type enumeration specifying a list control. */
     65    static final public byte METADATA = 5;
     66    /** An element of the argument type enumeration specifying a metadata combobox control. */
     67    static final public byte METADATUM = 6;
     68    /** An element of the argument type enumeration specifying a text field. */
     69    static final public byte STRING = 7;
     70    /** An element of the argument type enumeration specifying a regular expression text field. */
     71    static final public byte REGEXP = 8;
     72    /** An element of the argument type enumeration specifying a metadata set combobox control. */
     73    static final public byte METADATA_SET_NAMESPACE = 9;
     74
     75    ///////////kk added the number was 9, I changed it to 10//////////////
     76    /** An element of the argument type enumeration specifying a text field. */
     77    static final public byte URL = 10;
     78    /////////////////////////////////////////////////////////////////
     79
     80    /** true if this argument should actually be hidden within the GLI. This is important for arguments such as import dir or other location critical arguments. */
     81    private boolean hidden_gli = false;
     82    /** <i>true</i> if this argument is required for the applicable script to work properly, <i>false</i> otherwise. */
     83    private boolean required = false;
     84    /** The type of this argument. Used to be an int, but bytes are cheaper. */
     85    private byte type = STRING;
     86    /** The maximum value an integer based control can have. */
     87    private int maximum = Integer.MAX_VALUE;
     88    /** The minimum value an integer based control can have. */
     89    private int minimum = Integer.MIN_VALUE;
     90    /** Every argument has a detail mode level at which it becomes available to the user to edit.
     91     * @see org.greenstone.gatherer.Configuration
     92     */
     93    private int mode_level = Configuration.LIBRARIAN_MODE;
     94    /** The DOM element this argument is built around, if any. */
     95    private Element element;
     96    /** If the argument is of type ENUM then this map holds all the various options. Each entry is an &lt;option value&gt; -&gt; &lt;description&gt; mapping. */
     97    private ArrayList option_list = null;
     98    /** A default value for parameter-type arguments. May be a Perl pattern. */
     99    private String default_value = null;
     100    /** The text description of this argument parsed from the pluginfo output. */
     101    private String description = null;
     102    /** The argument flag as it appears in the command. Also used as the unique identifier of an argument. */
     103    private String name = null;
     104    /** The plugin that owns this argument, for the purposes of visualising inheritance. */
     105    private String owner = null;
     106
     107    private String display_name = null;
     108
     109    /** Default Constructor. */
     110    public Argument() {
     111    }
     112
     113    /** Another constructor but this one is a little more interesting as it takes a DOM element.
     114     * @param element the Element this argument is based around
     115     */
     116    public Argument(Element element) {
     117        this.element = element;
     118    }
     119
     120    /** Method to add an element to the option_list.
     121     * @param name the name value of the option as a String
     122     * @param desc the description of this options as a String
     123     */
     124    public void addOption(String name, String desc) {
     125        if(type == ENUM && name != null) {
     126            if(desc == null) {
     127                desc = "";
     128            }
     129            if(option_list == null) {
     130                option_list = new ArrayList();
     131            }
     132            option_list.add(new ArgumentOption(name, desc));
     133        }
     134    }
     135
     136    /** Method to compare two arguments for ordering.
     137     * @param object the argument we are comparing to, as an Object
     138     * @return an int specifying the argument order, using values as set out in String
     139     * @see org.greenstone.gatherer.cdm.Argument
     140     */
     141    public int compareTo(Object object) {
     142        if(object instanceof Argument) {
     143            return getName().compareTo(((Argument)object).getName());
     144        }
     145        else {
     146            return toString().compareTo(object.toString());
     147        }
     148    }
     149
     150    /** Create a copy of this argument.
     151     * @return a newly created Argument with the same details as this one
     152     */
     153    public Argument copy() {
     154        Argument copy = new Argument();
     155        copy.setDefaultValue(default_value);
     156        copy.setDescription(description);
     157        copy.setOptions(option_list);
     158        copy.setOwner(owner);
     159        copy.setName(name);     
     160        copy.setDispalyName(display_name);
     161        copy.setRequired(required);
     162        copy.setType(type);
     163        copy.setMinimum(minimum);
     164        copy.setMaximum(maximum);
     165        copy.setModeLevel(mode_level);
     166        copy.setHiddenGLI(hidden_gli);
     167        return copy;
     168    }
     169
     170    /** Method to determine if two arguments are equal.
     171     * @param object the argument to test against, as an Object
     172     * @return true if the arguments names match, false otherwise
     173     */
     174    public boolean equals(Object object) {
     175        return (compareTo(object) == 0);
     176    }
     177
     178    /** Method to retrieve the value of default_value.
     179     * @return a String containing the default value
     180     */
     181    public String getDefaultValue() {
     182        return default_value;
     183    }
     184
     185    /** Method to retrieve this arguments description.
     186     * @return a String containing the description
     187     */
     188    public String getDescription() {
     189        return description;
     190    }
     191
     192    public Element getElement() {
     193        return element;
     194    }
     195    /** Retrieve the upper bound of a range based argument.
     196     * @return the maximum as an int
     197     */
     198    public int getMaximum() {
     199        return maximum;
     200    }
     201
     202    /** Retrieve the lower bound of a range based argument.
     203     * @return the minimum as an int
     204     */
     205    public int getMinimum() {
     206        return minimum;
     207    }
     208
     209    /** Retrieves the mode level at which this argument should become available. Any higher levels should also see this argument.
     210     * @return the mode level as an int
     211     */
     212    public int getModeLevel() {
     213        return mode_level;
     214    }
     215
     216    /** Method to retrieve the value of name.
     217     * @return a String containing the argument name
     218     * @see org.greenstone.gatherer.util.StaticStrings#NAME_ATTRIBUTE
     219     */
     220    public String getName() {
     221        if(name == null && element != null) {
     222            name = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
     223        }
     224        return name;
     225    }
     226
     227    public String getDisplayName() {
     228        if(display_name==null)
     229            return "";
     230        return display_name;
     231    }
     232
     233    /** Method to retrieve the option list for this argument.
     234     * @return a HashMap containing &lt;option value&gt; -&gt; &lt;description&gt; entries
     235     */
     236    public ArrayList getOptions() {
     237        return option_list;
     238    }
     239
     240    /** Retrieve the name of the owner of this argument.
     241     * @return the owners name as a String
     242     */
     243    public String getOwner() {
     244        return owner;
     245    }
     246
     247    /** Method to determine the type of this argument.
     248     * @return a byte specifying the type
     249     */
     250    public byte getType() {
     251        return type;
     252    }
     253
     254    /** Method to retrieve the value of value.
     255     * @return the value of value as a String
     256     * @see org.greenstone.gatherer.Gatherer#c_man
     257     * @see org.greenstone.gatherer.collection.CollectionManager#getCollection
     258     */
     259    public String getValue()
     260    {
     261        // Only assigned arguments have values.
     262        if (element == null) {
     263            return null;
     264        }
     265
     266        return XMLTools.getValue(element);
     267    }
     268
     269
     270    /** Method to determine if this argument has been assigned.
     271     * @return true if it has, false otherwise
     272     * @see org.greenstone.gatherer.util.StaticStrings#ASSIGNED_ATTRIBUTE
     273     * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
     274     */
     275    public boolean isAssigned() {
     276        return (element != null && element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.TRUE_STR));
     277    }
     278
     279    /** Determine if this is a custom argument ie one that has been parsed from the config file but doesn't have a matching entry in the argument library.
     280     * @return true if this argument is a custom, false otherwise
     281     * @see org.greenstone.gatherer.util.StaticStrings#CUSTOM_ATTRIBUTE
     282     * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
     283     */
     284    public boolean isCustomArgument() {
     285        return (element != null && element.getAttribute(StaticStrings.CUSTOM_ATTRIBUTE).equals(StaticStrings.TRUE_STR));
     286    }
     287
     288    /** Determine if this argument is hidden in GLI
     289     * @return true if the argument is hidden, false otherwise
     290     */
     291    public boolean isHiddenGLI() {
     292        return hidden_gli;
     293    }
     294
     295    /** Method to determine of this argument is required for the associated script to work.
     296     * @return true if this argument is required, false otherwise
     297     */
     298    public boolean isRequired() {
     299        return required;
     300    }
     301
     302    /** Method to allow for the activation of arguments that might never have their setValue() method called.
     303     * @param assigned the desired state as a boolean
     304     * @see org.greenstone.gatherer.util.StaticStrings#ASSIGNED_ATTRIBUTE
     305     * @see org.greenstone.gatherer.util.StaticStrings#FALSE_STR
     306     * @see org.greenstone.gatherer.util.StaticStrings#TRUE_STR
     307     */
     308    public void setAssigned(boolean assigned) {
     309        if(element != null) {
     310            element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (assigned ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
     311        }
     312    }
     313
     314    /** Sets the value of default_value.
     315     * @param default_value The new value for default_value as a <strong>String</strong>.
     316     */
     317    public void setDefaultValue(String default_value) {
     318        this.default_value = default_value;
     319    }
     320
     321    /** Set the value of desc.
     322     * @param description the new value of desc as a String
     323     */
     324    public void setDescription(String description) {
     325        this.description = description;
     326    }
     327
     328    /** Set the element this argument should be based upon.
     329     * @param element the Element
     330     */
     331    public void setElement(Element element) {
     332        this.element = element;
     333    }
     334
     335    /** Mark this argument as being hidden in GLI. */
     336    public void setHiddenGLI(boolean hidden) {
     337        this.hidden_gli = hidden;
     338    }
     339
     340    /** Set the upper bound for a range type argument.
     341     * @param maximum the maximum as an int
     342     */
     343    public void setMaximum(int maximum) {
     344        this.maximum = maximum;
     345    }
     346
     347    /** Set the lower bound for a range type argument.
     348     * @param minimum the minimum as an int
     349     */
     350    public void setMinimum(int minimum) {
     351        this.minimum = minimum;
     352    }
     353
     354    /** Set the detail mode level where this argument will become available.
     355     * @param mode_level the mode level as an int
     356     */
     357    public void setModeLevel(int mode_level) {
     358        this.mode_level = mode_level;
     359    }
     360
     361    /** Set the value of name.
     362     * @param name the new value of name as a String
     363     */
     364    public void setName(String name) {
     365        this.name = name;
     366    }
    616367   
    617     } // parseXML
    618 
    619     public class ArgumentOption
     368    public void setDispalyName(String name) {       
     369        this.display_name = name;
     370    }   
     371
     372    /** Sets the value of the options list.
     373     * @param list the new options list as a HashMap
     374     */
     375    public void setOptions(ArrayList list) {
     376        this.option_list = list;
     377    }
     378
     379    /** Set the owner of this argument.
     380     * @param owner the name of the owner of this argument as a String
     381     */
     382    public void setOwner(String owner) {
     383        this.owner = owner;
     384    }
     385
     386    /** Set the value of required.
     387     * @param required the new value of required as a boolean
     388     */
     389    public void setRequired(boolean required) {
     390        this.required = required;
     391    }
     392
     393    /** Set the value of type.
     394     * @param type the new value of type as an byte
     395     */
     396    public void setType(byte type) {
     397        this.type = type;
     398    }
     399
     400    /** Set the value of type, by matching a type to the given string.
     401     * @param new_type a String which contains the name of a certain argument type
     402     * @see org.greenstone.gatherer.util.StaticStrings#ENUM_STR
     403     * @see org.greenstone.gatherer.util.StaticStrings#FLAG_STR
     404     * @see org.greenstone.gatherer.util.StaticStrings#HIERARCHY_STR
     405     * @see org.greenstone.gatherer.util.StaticStrings#INT_STR
     406     * @see org.greenstone.gatherer.util.StaticStrings#LANGUAGE_STR
     407     * @see org.greenstone.gatherer.util.StaticStrings#METADATA_TYPE_STR
     408     * @see org.greenstone.gatherer.util.StaticStrings#METADATUM_TYPE_STR
     409     * @see org.greenstone.gatherer.util.StaticStrings#REGEXP_STR
     410     */
     411    public void setType(String new_type) {
     412        if(new_type.equalsIgnoreCase(StaticStrings.ENUM_STR)) {
     413            this.type = ENUM;
     414            option_list = new ArrayList();
     415        }
     416        else if(new_type.equalsIgnoreCase(StaticStrings.FLAG_STR)) {
     417            this.type = FLAG;
     418        }
     419        else if(new_type.equalsIgnoreCase(StaticStrings.HIERARCHY_STR)) {
     420            this.type = HIERARCHY;
     421        }
     422        else if(new_type.equalsIgnoreCase(StaticStrings.INT_STR)) {
     423            this.type = INTEGER;
     424        }
     425        else if(new_type.equalsIgnoreCase(StaticStrings.LANGUAGE_STR)) {
     426            this.type = LANGUAGE;
     427        }
     428        else if(new_type.equalsIgnoreCase(StaticStrings.METADATA_TYPE_STR)) {
     429            this.type = METADATA;
     430        }
     431        else if(new_type.equalsIgnoreCase(StaticStrings.METADATUM_TYPE_STR)) {
     432            this.type = METADATUM;
     433        }
     434        else if(new_type.equalsIgnoreCase(StaticStrings.REGEXP_STR)) {
     435            this.type = REGEXP;
     436        }
     437        else {
     438            this.type = STRING;
     439        }
     440    }
     441
     442    /** Method to set the value of this argument.
     443     * @param value the new value for the argument
     444     * @see org.greenstone.gatherer.Gatherer#println
     445     */
     446    public void setValue(String value) {
     447        if(element != null) {
     448            XMLTools.setValue(element, value);
     449        }
     450        else {
     451            DebugStream.println("Argument.setValue(" + value + ") called on a base Argument.");
     452        }
     453    }
     454
     455    /** Set the values vector to the given values. Currently I just assign the new values, whereas I may later want to implement a deep clone.
     456     * @param values an ArrayList of values
     457     * @see org.greenstone.gatherer.Gatherer#println
     458     */
     459    public void setValues(ArrayList values) {
     460        if(element != null) {
     461            StringBuffer value = new StringBuffer();
     462            int value_length = values.size();
     463            for(int i = 0; i < value_length; i++) {
     464                value.append(values.get(i));
     465                value.append(StaticStrings.COMMA_CHARACTER);
     466            }
     467            value.deleteCharAt(value.length() - 1); // Remove last ','
     468            XMLTools.setValue(element, value.toString());
     469        }
     470        else {
     471            DebugStream.println("Argument.setValues([" + values.size() + " items]) called on a base Argument.");
     472        }
     473    }
     474
     475    /** Method for translating the data of this class into a string.
     476     * @return a String containing a fragment of the total arguments string
     477     * @see org.greenstone.gatherer.Gatherer#c_man
     478     * @see org.greenstone.gatherer.collection.CollectionManager#getCollection
     479     * @see org.greenstone.gatherer.util.StaticStrings#COMMA_CHARACTER
     480     * @see org.greenstone.gatherer.util.StaticStrings#NAME_ATTRIBUTE
     481     * @see org.greenstone.gatherer.util.StaticStrings#SPACE_CHARACTER
     482     * @see org.greenstone.gatherer.util.StaticStrings#SPEECH_CHARACTER
     483     */
     484    public String toString()
     485    {
     486        StringBuffer text = new StringBuffer("-");
     487
     488        if (element == null) {
     489            return text.toString();
     490        }
     491
     492        if (name == null) {
     493            name = element.getAttribute(StaticStrings.NAME_ATTRIBUTE);
     494        }
     495        text.append(name);
     496
     497        String value = XMLTools.getValue(element);
     498        if (value.length() == 0) {
     499            return text.toString();
     500        }
     501
     502        text.append(StaticStrings.SPACE_CHARACTER);
     503
     504//      // Handle metadata elements specially
     505//      if (type == METADATA || type == METADATUM) {
     506//      // Tokenize the string
     507//      StringTokenizer tokenizer = new StringTokenizer(value, ",");
     508//      while (tokenizer.hasMoreTokens()) {
     509//      String token = tokenizer.nextToken();
     510
     511//      MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName(token);
     512//      if (metadata_element != null) {
     513//      text.append(metadata_element.getFullName());
     514//      }
     515//      else {
     516//      text.append(token);
     517//      }
     518
     519//      if (tokenizer.hasMoreTokens()) {
     520//      text.append(StaticStrings.COMMA_CHARACTER);
     521//      }
     522//      }
     523//      return text.toString();
     524//      }
     525
     526        // If the value contains a space, add speech marks
     527        //   (Except for metadata elements, which won't have spaces when written out to collect.cfg)
     528        if (value.indexOf(StaticStrings.SPACE_CHARACTER) != -1 && !(type == METADATUM || type == METADATA)) {
     529            value = StaticStrings.SPEECH_CHARACTER + value + StaticStrings.SPEECH_CHARACTER;
     530        }
     531
     532        text.append(value);
     533        return text.toString();
     534    }
     535
     536    /** parse the <Option> XML from eg import.pl -xml or pluginfo.pl -xml */
     537    public void parseXML(Element option) {
     538
     539        for(Node node = option.getFirstChild(); node != null; node = node.getNextSibling()) {
     540            String node_name = node.getNodeName();
     541            if(node_name.equals("Name")) {
     542                setName(XMLTools.getValue(node));
     543            }
     544            else if(node_name.equals("DisplayName")) {
     545                setDispalyName(XMLTools.getValue(node));
     546            }
     547            else if(node_name.equals("Desc")) {
     548                setDescription(XMLTools.getValue(node));
     549            }
     550            else if(node_name.equals("Type")) {
     551                setType(XMLTools.getValue(node));
     552            }
     553            else if(node_name.equals("Default")) {
     554                setDefaultValue(XMLTools.getValue(node));
     555            }
     556            else if(node_name.equals("Required")) {
     557                String v = XMLTools.getValue(node);
     558                if(v != null && v.equals("yes")) {
     559                    setRequired(true);
     560                }
     561            }
     562            else if(node_name.equals("List")) {
     563                // Two final loops are required to parse lists.
     564                for(Node value = node.getFirstChild(); value != null; value = value.getNextSibling()) {
     565                    if(value.getNodeName().equals("Value")) {
     566                        String key = null;
     567                        String desc = "";
     568                        for(Node subvalue = value.getFirstChild(); subvalue != null; subvalue = subvalue.getNextSibling()) {
     569                            node_name = subvalue.getNodeName();
     570                            if(node_name.equals("Name")) {
     571                                key = XMLTools.getValue(subvalue);
     572                            }
     573                            else if(node_name.equals("Desc")) {
     574                                desc = XMLTools.getValue(subvalue);
     575                            }
     576                        }
     577                        if(key != null) {
     578                            addOption(key, desc);
     579                        }
     580                    }
     581                }
     582            }
     583            else if(node_name.equals("Range")) {
     584                String range_raw = XMLTools.getValue(node);
     585                int index = -1;
     586                if((index = range_raw.indexOf(StaticStrings.COMMA_CHARACTER)) != -1) {
     587                    if(index > 0) {
     588                        try {
     589                            String first_number = range_raw.substring(0, index);
     590                            setMinimum(Integer.parseInt(first_number));
     591                            first_number = null;
     592                        }
     593                        catch(Exception exception) {
     594                        }
     595                    }
     596
     597                    if(index + 1 < range_raw.length()) {
     598                        try {
     599                            String second_number = range_raw.substring(index + 1);
     600                            setMaximum(Integer.parseInt(second_number));
     601                            second_number = null;   
     602                        }
     603                        catch(Exception exception) {
     604                        }
     605                    }
     606                }
     607                // Else it wasn't a valid range anyway, so ignore it
     608            }
     609            else if(node_name.equals("HiddenGLI")) {
     610                setHiddenGLI(true);
     611            }
     612            else if(node_name.equals("ModeGLI")) {
     613                String mode_level_str = XMLTools.getValue(node);
     614                try {
     615                    int mode_level = Integer.parseInt(mode_level_str);
     616                    setModeLevel(mode_level);
     617                }
     618                catch(Exception exception) {
     619                    DebugStream.println("Exception in Argument.parseXML() - Unexpected but non-fatal");
     620                    DebugStream.printStackTrace(exception);
     621                }
     622            }
     623
     624        } // for each option
     625
     626    } // parseXML
     627
     628    public class ArgumentOption
    620629    implements Comparable {
    621     public String name;
    622     public String description;
    623     private String text; // cached version
    624 
    625     public ArgumentOption(String name, String desc) {
    626         this.name = name;
    627         this.description = desc;
    628     }
    629    
    630     public int compareTo(Object obj) {
    631         return toString().compareTo(obj.toString());
    632     }
    633 
    634     public boolean equals(Object obj) {     
    635         return (obj != null && compareTo(obj) == 0);
    636     }
    637    
    638     public String toString() {
    639         return name + " "+ StaticStrings.MINUS_CHARACTER + " "+ description;
    640     }
    641    
    642     public String getToolTip() {
    643         return Utility.formatHTMLWidth(name+": "+description, 80);
    644     }
    645     }
     630        public String name;
     631        public String description;
     632        private String text; // cached version
     633
     634        public ArgumentOption(String name, String desc) {
     635            this.name = name;
     636            this.description = desc;
     637        }
     638
     639        public int compareTo(Object obj) {
     640            return toString().compareTo(obj.toString());
     641        }
     642
     643        public boolean equals(Object obj) {     
     644            return (obj != null && compareTo(obj) == 0);
     645        }
     646
     647        public String toString() {
     648            return name + " "+ StaticStrings.MINUS_CHARACTER + " "+ description;
     649        }
     650
     651        public String getToolTip() {
     652            return Utility.formatHTMLWidth(name+": "+description, 80);
     653        }
     654    }
    646655}
  • gli/trunk/src/org/greenstone/gatherer/cdm/ArgumentContainer.java

    r12826 r14783  
    4343 */
    4444abstract public class ArgumentContainer
    45     extends ArrayList
    46     implements Comparable, DOMProxyListEntry, Serializable  {
    47 
    48     // The DOM Element this container is modelled on
    49     protected Element element;
    50     protected boolean is_abstract = false;
    51     protected ArgumentContainer super_container;
    52     protected String description;
    53     protected String name;
    54 
    55     /** Constructor used in DOMProxyListModel initializations
    56      */
    57     public ArgumentContainer() {
    58     }
    59 
    60     public ArgumentContainer(Element element, ArgumentContainer base_container) {
    61 
    62     super();
    63     this.element = element;
    64     this.name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    65 
    66     // Parse in any argument options for this container, keeping a list of the ones found
    67     HashMap known_arguments = new HashMap();
    68     NodeList option_elements = element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
    69     int option_elements_length = option_elements.getLength();
    70     for(int i = 0; i < option_elements_length; i++) {
    71         Element option_element = (Element) option_elements.item(i);
    72         Argument argument = new Argument(option_element);
    73         ///ystem.err.println("Rebuilding existing argument: " + argument.getName());
    74         known_arguments.put(argument.getName(), argument);
    75     }
    76     // If a base classifier was given
    77     if(base_container != null) {
    78         // Copy the details, and add a reference to whatever the base container's super container is
    79         description = base_container.getDescription();
    80         // Now search through the 'dummy' arguments belonging to the base container. For each found, if it is already assigned, fill out further details such as type. If any are found that are not already assigned for this container, copy them and add them, but without a value.
    81         ArrayList all_arguments = base_container.getArguments();
    82         int argument_count = all_arguments.size();
    83         for(int j = 0; j < argument_count; j++) {
    84         Argument base_argument = (Argument) all_arguments.get(j);
    85         String base_argument_name = base_argument.getName();
    86         ///ystem.err.println("Library indicates this container should have an argument: " + base_argument_name);
    87         Argument existing_argument = (Argument) known_arguments.get(base_argument_name);
    88         // Found an existing argument. Complete its details
    89         if(existing_argument != null) {
    90             ///ystem.err.println("Found existing argument. Filling out details.");
    91             known_arguments.remove(base_argument_name);
    92             existing_argument.setDefaultValue(base_argument.getDefaultValue());
    93             existing_argument.setDescription(base_argument.getDescription());
    94             existing_argument.setOptions(base_argument.getOptions());
    95             existing_argument.setRequired(base_argument.isRequired());
    96             existing_argument.setType(base_argument.getType());
    97             existing_argument.setMinimum(base_argument.getMinimum());
    98             existing_argument.setMaximum(base_argument.getMaximum());
    99             existing_argument.setOwner(base_argument.getOwner());
    100             existing_argument.setHiddenGLI(base_argument.isHiddenGLI());
    101             add(existing_argument);
    102         }
    103         // No existing argument. Copy base_argument and add it, but set its assigned flag to false
    104         else {
    105             ///atherer.println("No such argument. Adding new, unassigned, argument.");
    106             // The trick thing is that we have to create a new element in the DOM as well.
    107             Argument new_argument = base_argument.copy();
    108             Element argument_element = CollectionConfiguration.createElement(StaticStrings.OPTION_ELEMENT);
    109             argument_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, base_argument_name);
    110             argument_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
    111             new_argument.setElement(argument_element);
    112             // All done. Add it.
    113             element.appendChild(argument_element);
    114             add(new_argument);
    115         }
    116         }
    117     }
    118    
    119     // The first time we do this, the args come from the config file and
    120     // may contain invalid args. Here we remove them from the DOM.
    121     if (!known_arguments.isEmpty()) {
    122         Set entry_set = known_arguments.entrySet();
    123         Iterator entry_iterator = entry_set.iterator();
    124         while (entry_iterator.hasNext()) {
    125         Argument arg = (Argument)((Map.Entry)entry_iterator.next()).getValue();
    126         Element e = arg.getElement();
    127         element.removeChild(e);
    128         }
    129     }
    130     }
    131 
    132 
    133    
    134 
    135     /** Constructor used for the plugins that are in the DOMProxyList */
    136     /** Method to add an argument to this container. Only adds the argument if it isn't already present.
    137      * @param argument The <strong>Argument</strong> to add.
    138      */
    139     public void addArgument(Argument argument) {
    140     if(element == null && !contains(argument)) {
    141         add(argument);
    142         argument.setOwner(name);
    143     }
    144     }
    145 
    146     /** Method to compare two containers for ordering.
    147      * @param object The container we are comparing to, as an <strong>Object</strong>.
    148      * @return An <i>int</i> specifying the container order, using values as set out in String.
    149      * @see java.lang.String#compareTo
    150      */
    151     public int compareTo(Object object) {
    152     if(object == null ) {
    153         return -1;
    154     }
    155     return toString().compareTo(object.toString());
    156     }
    157 
    158     /** Method to determine if two containers are equal.
    159      * @param object The container to test against, as an <strong>Object</strong>.
    160      * @return <i>true</i> if they match (based on the equals method), <i>false</i> otherwise.
    161      */
    162 
    163     public boolean equals(Object object) {
    164     return (compareTo(object) == 0);
    165     }
    166 
    167     abstract public DOMProxyListEntry create(Element element);
    168     /** Method to retrieve an argument by its name.
    169      * @param name The name of the argument as a <strong>String</strong>.
    170      * @return The <strong>Argument</strong> requested, or <i>null</i> if no such argument.
    171      */
    172     public Argument getArgument(String name) {
    173     // The name given may still include the '-'
    174     if(name.startsWith("-")) {
    175         name = name.substring(1);
    176     }
    177     //ArrayList arguments = getArguments(true, true);
    178     ArrayList arguments = getArguments();
    179     for(int i = 0; i < arguments.size(); i++) {
    180         Argument argument = (Argument)arguments.get(i);
    181         if(argument.getName().equals(name)) {
    182         return argument;
    183         }
    184     }
    185     return null;
    186     }
    187 
    188     /** Method to retrieve the list of arguments from this container. Note that this method returns both the containers arguments plus its 'supers' arguments if any, and alphabetically orders them.
    189      * @return the arguments within a ArrayList
    190      */
    191     public ArrayList getArguments() {
    192     ArrayList arguments = new ArrayList();
    193     arguments.addAll(this);
    194     if(super_container != null) {
    195         ArrayList remainder = super_container.getArguments();
    196         remainder.removeAll(arguments);
    197         arguments.addAll(remainder);
    198     }
    199     return arguments;
    200 
    201     }
    202 
    203     public String getDescription() {
    204     return description;
    205     }
    206 
    207     public Element getElement() {
    208     return element;
    209     }
    210     /** Method to retrieve the name associated with this argument container.
    211      * @return the name as a String
    212      */
    213     public String getName() {
    214     if(name == null && element != null) {
    215         name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    216     }
    217     return name;
    218     }
    219 
    220     public boolean isAbstract() {
    221     return is_abstract;
    222     }
    223 
    224     public boolean isAssigned() {
    225     return (element != null && !element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR));
    226     }
    227 
    228     public void setAssigned(boolean assigned) {
    229     if(element != null) {
    230         element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (assigned ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
    231     }
    232     }
    233 
    234     public void setDescription(String description) {
    235     this.description = description;
    236     }
    237 
    238     public void setElement(Element element) {
    239     this.element = element;
    240     }
    241 
    242     public void setIsAbstract(boolean is_abstract) {
    243     this.is_abstract = is_abstract;
    244     }
    245 
    246     public void setName(String name) {
    247     this.name = name;
    248     }
    249 
    250     /** Method to set the value of the super_container.
    251      * @param super_container The new value of super_container as a <strong>ArgumentContainer</strong>, or <i>null</i> if this class has no inheritance.
    252      */
    253     public void setSuper(ArgumentContainer super_container) {
    254     this.super_container = super_container;
    255     }
    256 
    257     public String toString()
    258     {
    259     if (element == null) {
    260         return name;
    261     }
    262 
    263     if (name == null) {
    264         name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
    265     }
    266 
    267     StringBuffer text = new StringBuffer(" ");
    268     if (!isAssigned()) {
    269         text.append("#");
    270     }
    271     text.append(name);
    272 
    273     ArrayList arguments = getArguments();
    274     for (int i = 0; i < arguments.size(); i++) {
    275         Argument argument = (Argument) arguments.get(i);
    276         if (argument.isAssigned()) {
    277         text.append(" ");
    278         text.append(argument.toString());
    279         }
    280     }
    281 
    282     return text.toString();
    283     }
    284 
    285     public ArrayList getArguments(boolean include_normal, boolean include_custom){
    286     return this;
    287     }
     45extends ArrayList
     46implements Comparable, DOMProxyListEntry, Serializable  {
     47
     48    // The DOM Element this container is modelled on
     49    protected Element element;
     50    protected boolean is_abstract = false;
     51    protected ArgumentContainer super_container;
     52    protected String description;
     53    protected String name;
     54
     55    /** Constructor used in DOMProxyListModel initializations
     56     */
     57    public ArgumentContainer() {
     58    }
     59
     60    public ArgumentContainer(Element element, ArgumentContainer base_container) {
     61
     62        super();
     63        this.element = element;
     64        this.name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
     65
     66        // Parse in any argument options for this container, keeping a list of the ones found
     67        HashMap known_arguments = new HashMap();
     68        NodeList option_elements = element.getElementsByTagName(StaticStrings.OPTION_ELEMENT);
     69        int option_elements_length = option_elements.getLength();
     70        for(int i = 0; i < option_elements_length; i++) {
     71            Element option_element = (Element) option_elements.item(i);
     72            Argument argument = new Argument(option_element);
     73            ///ystem.err.println("Rebuilding existing argument: " + argument.getName());
     74            known_arguments.put(argument.getName(), argument);
     75        }
     76        // If a base classifier was given
     77        if(base_container != null) {
     78            // Copy the details, and add a reference to whatever the base container's super container is
     79            description = base_container.getDescription();
     80            // Now search through the 'dummy' arguments belonging to the base container. For each found, if it is already assigned, fill out further details such as type. If any are found that are not already assigned for this container, copy them and add them, but without a value.
     81            ArrayList all_arguments = base_container.getArguments();
     82            int argument_count = all_arguments.size();
     83            for(int j = 0; j < argument_count; j++) {
     84                Argument base_argument = (Argument) all_arguments.get(j);
     85                String base_argument_name = base_argument.getName();
     86                ///ystem.err.println("Library indicates this container should have an argument: " + base_argument_name);
     87                Argument existing_argument = (Argument) known_arguments.get(base_argument_name);
     88                // Found an existing argument. Complete its details
     89                if(existing_argument != null) {
     90                    ///ystem.err.println("Found existing argument. Filling out details.");
     91                    known_arguments.remove(base_argument_name);
     92                    existing_argument.setDispalyName(base_argument.getDisplayName());
     93                    existing_argument.setDefaultValue(base_argument.getDefaultValue());
     94                    existing_argument.setDescription(base_argument.getDescription());
     95                    existing_argument.setOptions(base_argument.getOptions());
     96                    existing_argument.setRequired(base_argument.isRequired());
     97                    existing_argument.setType(base_argument.getType());
     98                    existing_argument.setMinimum(base_argument.getMinimum());
     99                    existing_argument.setMaximum(base_argument.getMaximum());
     100                    existing_argument.setOwner(base_argument.getOwner());
     101                    existing_argument.setHiddenGLI(base_argument.isHiddenGLI());
     102                    add(existing_argument);
     103                }
     104                // No existing argument. Copy base_argument and add it, but set its assigned flag to false
     105                else {
     106                    ///atherer.println("No such argument. Adding new, unassigned, argument.");
     107                    // The trick thing is that we have to create a new element in the DOM as well.
     108                    Argument new_argument = base_argument.copy();
     109                    Element argument_element = CollectionConfiguration.createElement(StaticStrings.OPTION_ELEMENT);
     110                    argument_element.setAttribute(StaticStrings.NAME_ATTRIBUTE, base_argument_name);
     111                    argument_element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, StaticStrings.FALSE_STR);
     112                    new_argument.setElement(argument_element);
     113                    // All done. Add it.
     114                    element.appendChild(argument_element);
     115                    add(new_argument);
     116                }
     117            }
     118        }
     119
     120        // The first time we do this, the args come from the config file and
     121        // may contain invalid args. Here we remove them from the DOM.
     122        if (!known_arguments.isEmpty()) {
     123            Set entry_set = known_arguments.entrySet();
     124            Iterator entry_iterator = entry_set.iterator();
     125            while (entry_iterator.hasNext()) {
     126                Argument arg = (Argument)((Map.Entry)entry_iterator.next()).getValue();
     127                Element e = arg.getElement();
     128                element.removeChild(e);
     129            }
     130        }
     131    }
     132
     133
     134
     135
     136    /** Constructor used for the plugins that are in the DOMProxyList */
     137    /** Method to add an argument to this container. Only adds the argument if it isn't already present.
     138     * @param argument The <strong>Argument</strong> to add.
     139     */
     140    public void addArgument(Argument argument) {
     141        if(element == null && !contains(argument)) {
     142            add(argument);
     143            argument.setOwner(name);
     144        }
     145    }
     146
     147    /** Method to compare two containers for ordering.
     148     * @param object The container we are comparing to, as an <strong>Object</strong>.
     149     * @return An <i>int</i> specifying the container order, using values as set out in String.
     150     * @see java.lang.String#compareTo
     151     */
     152    public int compareTo(Object object) {
     153        if(object == null ) {
     154            return -1;
     155        }
     156        return toString().compareTo(object.toString());
     157    }
     158
     159    /** Method to determine if two containers are equal.
     160     * @param object The container to test against, as an <strong>Object</strong>.
     161     * @return <i>true</i> if they match (based on the equals method), <i>false</i> otherwise.
     162     */
     163
     164    public boolean equals(Object object) {
     165        return (compareTo(object) == 0);
     166    }
     167
     168    abstract public DOMProxyListEntry create(Element element);
     169    /** Method to retrieve an argument by its name.
     170     * @param name The name of the argument as a <strong>String</strong>.
     171     * @return The <strong>Argument</strong> requested, or <i>null</i> if no such argument.
     172     */
     173    public Argument getArgument(String name) {
     174        // The name given may still include the '-'
     175        if(name.startsWith("-")) {
     176            name = name.substring(1);
     177        }
     178        //ArrayList arguments = getArguments(true, true);
     179        ArrayList arguments = getArguments();
     180        for(int i = 0; i < arguments.size(); i++) {
     181            Argument argument = (Argument)arguments.get(i);
     182            if(argument.getName().equals(name)) {
     183                return argument;
     184            }
     185        }
     186        return null;
     187    }
     188
     189    /** Method to retrieve the list of arguments from this container. Note that this method returns both the containers arguments plus its 'supers' arguments if any, and alphabetically orders them.
     190     * @return the arguments within a ArrayList
     191     */
     192    public ArrayList getArguments() {
     193        ArrayList arguments = new ArrayList();
     194        arguments.addAll(this);
     195        if(super_container != null) {
     196            ArrayList remainder = super_container.getArguments();
     197            remainder.removeAll(arguments);
     198            arguments.addAll(remainder);
     199        }
     200        return arguments;
     201
     202    }
     203
     204    public String getDescription() {
     205        return description;
     206    }
     207
     208    public Element getElement() {
     209        return element;
     210    }
     211    /** Method to retrieve the name associated with this argument container.
     212     * @return the name as a String
     213     */
     214    public String getName() {
     215        if(name == null && element != null) {
     216            name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
     217        }
     218        return name;
     219    }
     220
     221    public boolean isAbstract() {
     222        return is_abstract;
     223    }
     224
     225    public boolean isAssigned() {
     226        return (element != null && !element.getAttribute(StaticStrings.ASSIGNED_ATTRIBUTE).equals(StaticStrings.FALSE_STR));
     227    }
     228
     229    public void setAssigned(boolean assigned) {
     230        if(element != null) {
     231            element.setAttribute(StaticStrings.ASSIGNED_ATTRIBUTE, (assigned ? StaticStrings.TRUE_STR : StaticStrings.FALSE_STR));
     232        }
     233    }
     234
     235    public void setDescription(String description) {
     236        this.description = description;
     237    }
     238
     239    public void setElement(Element element) {
     240        this.element = element;
     241    }
     242
     243    public void setIsAbstract(boolean is_abstract) {
     244        this.is_abstract = is_abstract;
     245    }
     246
     247    public void setName(String name) {
     248        this.name = name;
     249    }
     250
     251    /** Method to set the value of the super_container.
     252     * @param super_container The new value of super_container as a <strong>ArgumentContainer</strong>, or <i>null</i> if this class has no inheritance.
     253     */
     254    public void setSuper(ArgumentContainer super_container) {
     255        this.super_container = super_container;
     256    }
     257
     258    public String toString()
     259    {
     260        if (element == null) {
     261            return name;
     262        }
     263
     264        if (name == null) {
     265            name = element.getAttribute(StaticStrings.TYPE_ATTRIBUTE);
     266        }
     267
     268        StringBuffer text = new StringBuffer(" ");
     269        if (!isAssigned()) {
     270            text.append("#");
     271        }
     272        text.append(name);
     273
     274        ArrayList arguments = getArguments();
     275        for (int i = 0; i < arguments.size(); i++) {
     276            Argument argument = (Argument) arguments.get(i);
     277            if (argument.isAssigned()) {
     278                text.append(" ");
     279                text.append(argument.toString());
     280            }
     281        }
     282
     283        return text.toString();
     284    }
     285
     286    public ArrayList getArguments(boolean include_normal, boolean include_custom){
     287        return this;
     288    }
    288289}
  • gli/trunk/src/org/greenstone/gatherer/cdm/ArgumentControl.java

    r13158 r14783  
    2626/** This class encapsulates all the technical difficulty of creating a specific control based on an Argument. */
    2727public class ArgumentControl
    28     extends JPanel {
    29 
    30     static protected Dimension LABEL_SIZE = new Dimension(175, 25);
    31     static protected Dimension ROW_SIZE = new Dimension(400, 30);
    32     /** The Argument this control will be based on. */
    33     private Argument argument = null;
    34 
    35     /** A checkbox to allow enabling or diabling of this Argument. */
    36     private JCheckBox enabled = null;
    37     /** Some form of editor component, such as a JComboBox or JTextField, used to set parameters to an Argument. */
    38     private JComponent value_control = null;
    39    
    40     /** Constructor.
    41      */
    42     public ArgumentControl(Argument argument, boolean is_enabled, String preset_value) {
    43     this.argument = argument;
    44 
    45     String tip = "<html>" + argument.getName()+": "+argument.getDescription() + "</html>";
    46     tip = Utility.formatHTMLWidth(tip, 80);
    47 
    48     setBackground(Configuration.getColor("coloring.collection_tree_background", false));
    49     setBorder(BorderFactory.createEmptyBorder(2,0,2,0));
    50     setLayout(new BorderLayout());
    51     setPreferredSize(ROW_SIZE);
    52 
    53     if (argument.isRequired()) {
    54         JLabel label = new JLabel(argument.getName());
    55         label.setOpaque(false);
    56         label.setPreferredSize(LABEL_SIZE);
    57         label.setToolTipText(tip);
    58         add(label, BorderLayout.WEST);
    59     } else {
    60         enabled = new JCheckBox(argument.getName());
    61         enabled.setOpaque(false);
    62         enabled.setPreferredSize(LABEL_SIZE);
    63         enabled.setToolTipText(tip);
    64         add(enabled, BorderLayout.WEST);
    65     }
    66    
    67     String initial_value;
    68     if (preset_value != null && !preset_value.equals("")) {
    69         initial_value = preset_value;
    70     }
    71     else {
    72         initial_value = argument.getValue();
    73     }
    74     if (initial_value == null || initial_value.equals("")) {
    75         initial_value = argument.getDefaultValue();
    76     }
    77     if (initial_value == null) {
    78         initial_value = "";
    79     }
    80    
    81     switch(argument.getType()) {
    82     case Argument.ENUM:
    83         ArrayList option_list = argument.getOptions();
    84         value_control = new GComboBox(option_list.toArray(), false, false);
    85         selectValue((JComboBox)value_control, initial_value); // also sets the tooltip
    86         ((JComboBox)value_control).addActionListener(new ToolTipUpdater());
    87         break;
    88        
    89     case Argument.FLAG:
    90         // Only need the check box.
    91         break;
    92 
    93     case Argument.INTEGER:
    94         // Build a spinner
    95         int initial_int=0;
    96         // If there was an original value, set it.
    97         try {
    98         initial_int = Integer.parseInt(initial_value);
    99         } catch (Exception error) {
    100         DebugStream.println("ArgumentControl Error: "+error);
    101         }
    102         if (initial_int < argument.getMinimum()) {
    103         initial_int = argument.getMinimum();
    104         } else if (initial_int > argument.getMaximum()) {
    105         initial_int = argument.getMaximum();
    106         }
    107        
    108         JSpinner spinner = new JSpinner(new SpinnerNumberModel(initial_int, argument.getMinimum(), argument.getMaximum(), 1));
    109 
    110         // And remember it
    111         value_control = spinner;
    112         break;
    113 
    114     case Argument.REGEXP:
    115     case Argument.STRING:
    116         value_control = new JTextField(initial_value);
    117         break;
     28extends JPanel {
     29
     30    static protected Dimension LABEL_SIZE = new Dimension(175, 25);
     31    static protected Dimension ROW_SIZE = new Dimension(400, 30);
     32    /** The Argument this control will be based on. */
     33    private Argument argument = null;
     34
     35    /** A checkbox to allow enabling or diabling of this Argument. */
     36    private JCheckBox enabled = null;
     37    /** Some form of editor component, such as a JComboBox or JTextField, used to set parameters to an Argument. */
     38    private JComponent value_control = null;
     39
     40    /** Constructor.
     41     */
     42    public ArgumentControl(Argument argument, boolean is_enabled, String preset_value) {
     43        this.argument = argument;
     44
     45        String tip = "<html>" + argument.getName()+": "+argument.getDescription() + "</html>";
     46        tip = Utility.formatHTMLWidth(tip, 80);
     47
     48        setBackground(Configuration.getColor("coloring.collection_tree_background", false));
     49        setBorder(BorderFactory.createEmptyBorder(2,0,2,0));
     50        setLayout(new BorderLayout());
     51        setPreferredSize(ROW_SIZE);
    11852       
    119     case Argument.LANGUAGE:
    120         value_control = new GComboBox(CollectionDesignManager.language_manager.getLanguageCodes().toArray(), false);
    121         // we want to display the language name not the code
    122         ((JComboBox)value_control).setRenderer(new LanguageListCellRenderer());
    123         // Now ensure we have the existing value or default value selected if either exist in our known languages
    124         String lang_name = CollectionDesignManager.language_manager.getLanguageName(initial_value);
    125         if (lang_name != null) {
    126         ((JComboBox)value_control).setSelectedItem(initial_value);
    127         }
    128         break;
    129 
    130     case Argument.METADATUM:
    131     case Argument.METADATA:
    132         value_control = new GComboBox(MetadataSetManager.getEveryMetadataSetElement(), false);
    133 
    134         // Editable for advanced modes (allows things like dc.Title,ex.Title)
    135         if (Configuration.getMode() > Configuration.ASSISTANT_MODE) {
    136         ((JComboBox) value_control).setEditable(true);
    137         }
    138         // Now ensure we have the existing value or default value selected if either exist.
    139         String existing_value = preset_value;
    140         if (existing_value == null || existing_value.length() == 0) {
    141         existing_value = argument.getValue();
    142         }
    143         if (existing_value != null && existing_value.length() > 0) {
    144         boolean found = selectValue((JComboBox) value_control, existing_value);
    145         // It's possible that this is a custom value and so doesn't exist in the combobox
    146         if (!found) {
    147             // If so, add it then select it
    148             ((JComboBox) value_control).addItem(existing_value);
    149             ((JComboBox) value_control).setSelectedItem(existing_value);
    150         }
    151         }
    152         else {
    153         String default_value = argument.getDefaultValue();
    154         if (default_value != null) {
    155             // if no namespace for default value, add ex.
    156             // won't work if we want to set a non-metadata value
    157             if (MetadataTools.getMetadataSetNamespace(default_value).equals("")) {
    158             default_value = StaticStrings.EXTRACTED_NAMESPACE+default_value;
    159             }
    160             selectValue((JComboBox) value_control, default_value);
    161         }
    162         }
    163         break;
    164 
    165     case Argument.METADATA_SET_NAMESPACE:
    166         value_control = new JComboBox();
    167         // !! Hack for exploding metadata databases: add the (empty) exploded metadata set
    168         File exploded_metadata_set_file = new File(Gatherer.getGLIMetadataDirectoryPath() + "exp" + StaticStrings.METADATA_SET_EXTENSION);
    169         MetadataSet exploded_metadata_set = new MetadataSet(exploded_metadata_set_file);
    170         Gatherer.c_man.importMetadataSet(exploded_metadata_set);
    171 
    172         // All the loaded metadata sets except the extracted metadata set are applicable
    173         ArrayList metadata_sets = MetadataSetManager.getMetadataSets();
    174         for (int i = metadata_sets.size() - 1; i >= 0; i--) {
    175         MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
    176         if (!(metadata_set.getNamespace().equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE))) {
    177             ((JComboBox)value_control).addItem(metadata_set);
    178         }
    179         }
    180 
    181         selectValue((JComboBox) value_control, initial_value);
    182 
    183     } // end of switch
    184 
    185     // Enable or disable as necessary.
    186     if(argument.isRequired() || argument.isAssigned() || is_enabled) {
    187         if (enabled != null) {
     53        // display the name set in the disp option if there is one
     54        // otherwise display name option value instead
     55        String dispName = argument.getDisplayName();
     56        if(dispName.equals("")){
     57            dispName = argument.getName();
     58        }
     59
     60        if (argument.isRequired()) {       
     61            //JLabel label = new JLabel(argument.getName());
     62            JLabel label = new JLabel(dispName);
     63
     64            label.setOpaque(false);
     65            label.setPreferredSize(LABEL_SIZE);
     66            label.setToolTipText(tip);
     67            add(label, BorderLayout.WEST);
     68        } else {
     69            //enabled = new JCheckBox(argument.getName());
     70            enabled = new JCheckBox(dispName);
     71
     72            enabled.setOpaque(false);
     73            enabled.setPreferredSize(LABEL_SIZE);
     74            enabled.setToolTipText(tip);
     75            add(enabled, BorderLayout.WEST);
     76        }
     77
     78        String initial_value;
     79        if (preset_value != null && !preset_value.equals("")) {
     80            initial_value = preset_value;
     81        }
     82        else {
     83            initial_value = argument.getValue();
     84        }
     85        if (initial_value == null || initial_value.equals("")) {
     86            initial_value = argument.getDefaultValue();
     87        }
     88        if (initial_value == null) {
     89            initial_value = "";
     90        }
     91
     92        switch(argument.getType()) {
     93        case Argument.ENUM:
     94            ArrayList option_list = argument.getOptions();
     95            value_control = new GComboBox(option_list.toArray(), false, false);
     96            selectValue((JComboBox)value_control, initial_value); // also sets the tooltip
     97            ((JComboBox)value_control).addActionListener(new ToolTipUpdater());
     98            break;
     99
     100        case Argument.FLAG:
     101            // Only need the check box.
     102            break;
     103
     104        case Argument.INTEGER:
     105            // Build a spinner
     106            int initial_int=0;
     107            // If there was an original value, set it.
     108            try {
     109                initial_int = Integer.parseInt(initial_value);
     110            } catch (Exception error) {
     111                DebugStream.println("ArgumentControl Error: "+error);
     112            }
     113            if (initial_int < argument.getMinimum()) {
     114                initial_int = argument.getMinimum();
     115            } else if (initial_int > argument.getMaximum()) {
     116                initial_int = argument.getMaximum();
     117            }
     118
     119            JSpinner spinner = new JSpinner(new SpinnerNumberModel(initial_int, argument.getMinimum(), argument.getMaximum(), 1));
     120
     121            // And remember it
     122            value_control = spinner;
     123            break;
     124
     125        case Argument.REGEXP:
     126        case Argument.STRING:
     127            value_control = new JTextField(initial_value);
     128            break;
     129
     130        case Argument.LANGUAGE:
     131            value_control = new GComboBox(CollectionDesignManager.language_manager.getLanguageCodes().toArray(), false);
     132            // we want to display the language name not the code
     133            ((JComboBox)value_control).setRenderer(new LanguageListCellRenderer());
     134            // Now ensure we have the existing value or default value selected if either exist in our known languages
     135            String lang_name = CollectionDesignManager.language_manager.getLanguageName(initial_value);
     136            if (lang_name != null) {
     137                ((JComboBox)value_control).setSelectedItem(initial_value);
     138            }
     139            break;
     140
     141        case Argument.METADATUM:
     142        case Argument.METADATA:
     143            value_control = new GComboBox(MetadataSetManager.getEveryMetadataSetElement(), false);
     144
     145            // Editable for advanced modes (allows things like dc.Title,ex.Title)
     146            if (Configuration.getMode() > Configuration.ASSISTANT_MODE) {
     147                ((JComboBox) value_control).setEditable(true);
     148            }
     149            // Now ensure we have the existing value or default value selected if either exist.
     150            String existing_value = preset_value;
     151            if (existing_value == null || existing_value.length() == 0) {
     152                existing_value = argument.getValue();
     153            }
     154            if (existing_value != null && existing_value.length() > 0) {
     155                boolean found = selectValue((JComboBox) value_control, existing_value);
     156                // It's possible that this is a custom value and so doesn't exist in the combobox
     157                if (!found) {
     158                    // If so, add it then select it
     159                    ((JComboBox) value_control).addItem(existing_value);
     160                    ((JComboBox) value_control).setSelectedItem(existing_value);
     161                }
     162            }
     163            else {
     164                String default_value = argument.getDefaultValue();
     165                if (default_value != null) {
     166                    // if no namespace for default value, add ex.
     167                    // won't work if we want to set a non-metadata value
     168                    if (MetadataTools.getMetadataSetNamespace(default_value).equals("")) {
     169                        default_value = StaticStrings.EXTRACTED_NAMESPACE+default_value;
     170                    }
     171                    selectValue((JComboBox) value_control, default_value);
     172                }
     173            }
     174            break;
     175
     176        case Argument.METADATA_SET_NAMESPACE:
     177            value_control = new JComboBox();
     178            // !! Hack for exploding metadata databases: add the (empty) exploded metadata set
     179            File exploded_metadata_set_file = new File(Gatherer.getGLIMetadataDirectoryPath() + "exp" + StaticStrings.METADATA_SET_EXTENSION);
     180            MetadataSet exploded_metadata_set = new MetadataSet(exploded_metadata_set_file);
     181            Gatherer.c_man.importMetadataSet(exploded_metadata_set);
     182
     183            // All the loaded metadata sets except the extracted metadata set are applicable
     184            ArrayList metadata_sets = MetadataSetManager.getMetadataSets();
     185            for (int i = metadata_sets.size() - 1; i >= 0; i--) {
     186                MetadataSet metadata_set = (MetadataSet) metadata_sets.get(i);
     187                if (!(metadata_set.getNamespace().equals(MetadataSetManager.EXTRACTED_METADATA_NAMESPACE))) {
     188                    ((JComboBox)value_control).addItem(metadata_set);
     189                }
     190            }
     191
     192            selectValue((JComboBox) value_control, initial_value);
     193
     194        } // end of switch
     195
     196        // Enable or disable as necessary.
     197        if(argument.isRequired() || argument.isAssigned() || is_enabled) {
     198            if (enabled != null) {
     199                enabled.setSelected(true);
     200            }
     201            if(value_control != null) {
     202                value_control.setOpaque(true);
     203                value_control.setBackground(Color.white);
     204                value_control.setEnabled(true);
     205                if(value_control instanceof JSpinner) {
     206                    // Set enabled
     207                    JComponent c = ((JSpinner)value_control).getEditor();
     208                    if ( c instanceof JSpinner.DefaultEditor ) {
     209                        JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
     210                        JFormattedTextField field = editor.getTextField();
     211                        field.setEditable(true);
     212                        field.setBackground(Color.white);
     213                    }
     214                }
     215            }
     216        }
     217        else {
     218            if (enabled != null) {
     219                enabled.setSelected(false);
     220            }
     221            if(value_control != null) {
     222                value_control.setOpaque(true);
     223                value_control.setBackground(Color.lightGray);
     224                value_control.setEnabled(false);
     225                if(value_control instanceof JSpinner) {
     226                    // Set enabled
     227                    JComponent c = ((JSpinner)value_control).getEditor();
     228                    if ( c instanceof JSpinner.DefaultEditor ) {
     229                        JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
     230                        JFormattedTextField field = editor.getTextField();
     231                        field.setEditable(false);
     232                        field.setBackground(Color.lightGray);
     233                    }
     234                }
     235            }
     236        }
     237
     238        // Listener
     239        if(value_control != null) {
     240            if (argument.getType() != Argument.ENUM) {
     241                // enums have already set tooltips based on option value
     242                value_control.setToolTipText(tip);
     243            }
     244            add(value_control, BorderLayout.CENTER);
     245            if (!argument.isRequired()) {
     246                enabled.addActionListener(new EnabledListener(value_control));
     247            }
     248        }
     249    }
     250
     251    public Argument getArgument() {
     252        return argument;
     253    }
     254
     255    public String getArgumentName() {
     256        return argument.getName();
     257    }
     258
     259    public String getValue() {
     260        if(value_control == null) {
     261            return null;
     262        }
     263        if (value_control instanceof JSpinner) {
     264            return ((JSpinner)value_control).getValue().toString();
     265        }
     266        if(value_control instanceof JComboBox) {
     267            Object selected_item = ((JComboBox)value_control).getSelectedItem();
     268            if (selected_item != null) {
     269                if (argument.getType() == Argument.METADATA_SET_NAMESPACE) {
     270                    return ((MetadataSet) selected_item).getNamespace();
     271                }
     272                if (selected_item instanceof Argument.ArgumentOption) {
     273                    return ((Argument.ArgumentOption)selected_item).name;
     274                }
     275                if (selected_item instanceof MetadataElement) {
     276                    return ((MetadataElement) selected_item).getFullName();
     277                }
     278                return selected_item.toString();
     279            }   
     280            return null;
     281        }
     282        if(value_control instanceof JTextField) {
     283            return ((JTextField)value_control).getText();
     284        }
     285        return null;
     286    }
     287    /** Retrieve the control used for storing values.
     288     * @return JComponent
     289     */
     290    public JComponent getValueControl() {
     291        return value_control;
     292    }
     293
     294    public boolean isEnabled() {
     295        if (enabled == null) {
     296            return true; // always enabled
     297        }
     298        return enabled.isSelected();
     299    }
     300
     301
     302    /** Identifies this control by returning the name of the Argument it is based on.
     303     * @return The name of the Argument as a <strong>String</strong>.
     304     * @see org.greenstone.gatherer.cdm.Argument
     305     */
     306    public String toString() {
     307        return argument.getName();
     308    }
     309    /** Updates the enwrapped Argument using the values provided by the controls.
     310     * @return <i>true</i> if the update was successful, <i>false</i> otherwise.
     311     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.Argument.ArgumentOption
     312     * @see org.greenstone.gatherer.cdm.Language
     313     */
     314    public boolean updateArgument() {
     315        if(argument.isRequired() || enabled.isSelected() ) {
     316            argument.setAssigned(false);
     317            String result = null;
     318            switch(argument.getType()) {
     319            case Argument.ENUM:
     320                Argument.ArgumentOption option = (Argument.ArgumentOption)((JComboBox)value_control).getSelectedItem();
     321                if(option != null && option.name.length() > 0) {
     322                    argument.setValue(option.name);
     323                }
     324                else {
     325                    String args[] = new String[1];
     326                    args[0] = argument.getName();
     327                    if(argument.isRequired()) {
     328                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     329                    }
     330                    // They've left the field blank
     331                    else {
     332                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     333                        argument.setValue(null);
     334                    }
     335                    args = null;
     336                    return false;
     337                }
     338                argument.setAssigned(true);
     339                return true;
     340            case Argument.FLAG:
     341                // Should have already been handled above.
     342                argument.setAssigned(true);
     343                return true;
     344            case Argument.INTEGER:
     345                result = ((JSpinner)value_control).getValue().toString();
     346                if(result.length() > 0) {
     347                    // Test if the value entered is a valid int.
     348                    try {
     349                        int x = Integer.parseInt(result);
     350                    }
     351                    catch(NumberFormatException nfe) {
     352                        String args[] = new String[2];
     353                        args[0] = argument.getName();
     354                        args[1] = result;
     355                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Bad_Integer", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     356                        args = null;
     357                        return false;
     358                    }
     359                    argument.setValue(result);
     360                }
     361                else {
     362                    String args[] = new String[1];
     363                    args[0] = argument.getName();
     364                    if(argument.isRequired()) {
     365                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     366                    }
     367                    // They've left the field blank
     368                    else {
     369                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     370                        argument.setValue(null);
     371                    }
     372                    args = null;
     373                    return false;
     374                }
     375                argument.setAssigned(true);
     376                return true;
     377            case Argument.LANGUAGE:
     378                String language = (((JComboBox)value_control).getSelectedItem()).toString();
     379                argument.setValue(language);
     380                // Kinda lucked out here. Its impossible not to choose an entry from these comboboxes as they are restricted.
     381                argument.setAssigned(true);
     382                return true;
     383            case Argument.METADATUM:
     384            case Argument.METADATA:
     385                Object new_value_raw = ((JComboBox) value_control).getSelectedItem();
     386                if (new_value_raw instanceof MetadataElement) {
     387                    argument.setValue(((MetadataElement) new_value_raw).getFullName());
     388                }
     389                else {
     390                    // But we have to be careful as an arbitary string object could be zero length
     391                    String new_value = new_value_raw.toString();
     392                    ///ystem.err.println("The current value is: " + new_value);
     393                    if(new_value.length() > 0) {
     394                        argument.setValue(new_value);
     395                    }
     396                    else {
     397                        String args[] = new String[1];
     398                        args[0] = argument.getName();
     399                        if(argument.isRequired()) {
     400                            JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     401                        }
     402                        // They've left the field blank
     403                        else {
     404                            JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     405                            argument.setValue(null);
     406                        }
     407                        args = null;
     408                        return false;
     409                    }
     410                }
     411                argument.setAssigned(true);
     412                return true;
     413            case Argument.REGEXP:
     414            case Argument.STRING:
     415                result = ((JTextField)value_control).getText();
     416                if(result.length() > 0) {
     417                    argument.setValue(result);
     418                }
     419                else {
     420                    String args[] = new String[1];
     421                    args[0] = argument.getName();
     422                    if(argument.isRequired()) {
     423                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     424                    }
     425                    // They've left the field blank
     426                    else {
     427                        JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
     428                        argument.setValue(null);
     429                    }
     430                    args = null;
     431                    return false;
     432                }
     433                argument.setAssigned(true);
     434                return true;
     435            }
     436            return false;
     437        }
     438        else {
     439            argument.setAssigned(false);
     440            return true;
     441        }
     442    }
     443
     444
     445    public boolean updateArgument(boolean checkRequired) {
     446
     447
     448        if (checkRequired){
     449            return updateArgument();
     450        }
     451        else{
     452            if (argument.getType() == Argument.STRING){
     453                String result = ((JTextField)value_control).getText();
     454
     455                if(result.length() > 0) {
     456                    argument.setValue(result);
     457                    argument.setAssigned(true);                   
     458                }
     459            }   
     460        }
     461
     462        return true;
     463
     464    }
     465
     466
     467
     468    /** Method to ensure that a certain value is selected, if it exists within that combobox to begin with.
     469     * @param combobox The <strong>JComboBox</strong> whose selection we are trying to preset.
     470     * @param target The desired value of the selection as a <strong>String</strong>.
     471     * @return true if the item was found and selected, false otherwise
     472     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.Argument.ArgumentOption
     473     */
     474    public static boolean selectValue(JComboBox combobox, String target)
     475    {
     476        for (int i = 0; i < combobox.getItemCount(); i++) {
     477            Object object = combobox.getItemAt(i);
     478
     479            if (object instanceof Argument.ArgumentOption) {
     480                Argument.ArgumentOption opt = (Argument.ArgumentOption) object;
     481                if (opt.name.startsWith(target)) {
     482                    combobox.setSelectedIndex(i);
     483                    combobox.setToolTipText(opt.getToolTip());
     484                    return true;
     485                }
     486            }
     487            else if (object instanceof MetadataElement) {
     488                if(((MetadataElement)object).getFullName().equals(target)) {
     489                    combobox.setSelectedIndex(i);
     490                    return true;
     491                }
     492            }
     493            else if (object.toString().equals(target)) {
     494                combobox.setSelectedIndex(i);
     495                return true;
     496            }
     497        }
     498
     499        return false;
     500    }
     501
     502
     503    /** Forces the control into an 'enabled' mode. */
     504    public void setEnabled() {
    188505        enabled.setSelected(true);
    189         }
    190         if(value_control != null) {
    191         value_control.setOpaque(true);
    192         value_control.setBackground(Color.white);
    193         value_control.setEnabled(true);
    194         if(value_control instanceof JSpinner) {
    195             // Set enabled
    196             JComponent c = ((JSpinner)value_control).getEditor();
    197             if ( c instanceof JSpinner.DefaultEditor ) {
    198             JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
    199             JFormattedTextField field = editor.getTextField();
    200             field.setEditable(true);
    201             field.setBackground(Color.white);
    202             }
    203         }
    204         }
    205     }
    206     else {
    207         if (enabled != null) {
    208         enabled.setSelected(false);
    209         }
    210         if(value_control != null) {
    211         value_control.setOpaque(true);
    212         value_control.setBackground(Color.lightGray);
    213         value_control.setEnabled(false);
    214         if(value_control instanceof JSpinner) {
    215             // Set enabled
    216             JComponent c = ((JSpinner)value_control).getEditor();
    217             if ( c instanceof JSpinner.DefaultEditor ) {
    218             JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
    219             JFormattedTextField field = editor.getTextField();
    220             field.setEditable(false);
    221             field.setBackground(Color.lightGray);
    222             }
    223         }
    224         }
    225     }
    226    
    227     // Listener
    228     if(value_control != null) {
    229         if (argument.getType() != Argument.ENUM) {
    230         // enums have already set tooltips based on option value
    231         value_control.setToolTipText(tip);
    232         }
    233         add(value_control, BorderLayout.CENTER);
    234         if (!argument.isRequired()) {
    235         enabled.addActionListener(new EnabledListener(value_control));
    236         }
    237     }
    238     }
    239    
    240     public Argument getArgument() {
    241     return argument;
    242     }
    243 
    244     public String getArgumentName() {
    245     return argument.getName();
    246     }
    247 
    248     public String getValue() {
    249     if(value_control == null) {
    250         return null;
    251     }
    252     if (value_control instanceof JSpinner) {
    253         return ((JSpinner)value_control).getValue().toString();
    254     }
    255     if(value_control instanceof JComboBox) {
    256         Object selected_item = ((JComboBox)value_control).getSelectedItem();
    257         if (selected_item != null) {
    258         if (argument.getType() == Argument.METADATA_SET_NAMESPACE) {
    259             return ((MetadataSet) selected_item).getNamespace();
    260         }
    261         if (selected_item instanceof Argument.ArgumentOption) {
    262             return ((Argument.ArgumentOption)selected_item).name;
    263         }
    264         if (selected_item instanceof MetadataElement) {
    265             return ((MetadataElement) selected_item).getFullName();
    266         }
    267         return selected_item.toString();
    268         }   
    269         return null;
    270     }
    271     if(value_control instanceof JTextField) {
    272         return ((JTextField)value_control).getText();
    273     }
    274     return null;
    275     }
    276     /** Retrieve the control used for storing values.
    277      * @return JComponent
    278      */
    279     public JComponent getValueControl() {
    280     return value_control;
    281     }
    282 
    283     public boolean isEnabled() {
    284     if (enabled == null) {
    285         return true; // always enabled
    286     }
    287     return enabled.isSelected();
    288     }
    289 
    290 
    291     /** Identifies this control by returning the name of the Argument it is based on.
    292      * @return The name of the Argument as a <strong>String</strong>.
    293      * @see org.greenstone.gatherer.cdm.Argument
    294      */
    295     public String toString() {
    296     return argument.getName();
    297     }
    298     /** Updates the enwrapped Argument using the values provided by the controls.
    299      * @return <i>true</i> if the update was successful, <i>false</i> otherwise.
    300      * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.Argument.ArgumentOption
    301      * @see org.greenstone.gatherer.cdm.Language
    302      */
    303     public boolean updateArgument() {
    304     if(argument.isRequired() || enabled.isSelected() ) {
    305         argument.setAssigned(false);
    306         String result = null;
    307         switch(argument.getType()) {
    308         case Argument.ENUM:
    309         Argument.ArgumentOption option = (Argument.ArgumentOption)((JComboBox)value_control).getSelectedItem();
    310         if(option != null && option.name.length() > 0) {
    311             argument.setValue(option.name);
    312         }
    313         else {
    314             String args[] = new String[1];
    315             args[0] = argument.getName();
    316             if(argument.isRequired()) {
    317             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    318             }
    319             // They've left the field blank
    320             else {
    321             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    322             argument.setValue(null);
    323             }
    324             args = null;
    325             return false;
    326         }
    327         argument.setAssigned(true);
    328         return true;
    329         case Argument.FLAG:
    330         // Should have already been handled above.
    331         argument.setAssigned(true);
    332         return true;
    333         case Argument.INTEGER:
    334         result = ((JSpinner)value_control).getValue().toString();
    335         if(result.length() > 0) {
    336             // Test if the value entered is a valid int.
    337             try {
    338             int x = Integer.parseInt(result);
    339             }
    340             catch(NumberFormatException nfe) {
    341             String args[] = new String[2];
    342             args[0] = argument.getName();
    343             args[1] = result;
    344             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Bad_Integer", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    345             args = null;
    346             return false;
    347             }
    348             argument.setValue(result);
    349         }
    350         else {
    351             String args[] = new String[1];
    352             args[0] = argument.getName();
    353             if(argument.isRequired()) {
    354             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    355             }
    356             // They've left the field blank
    357             else {
    358             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    359             argument.setValue(null);
    360             }
    361             args = null;
    362             return false;
    363         }
    364         argument.setAssigned(true);
    365         return true;
    366         case Argument.LANGUAGE:
    367         String language = (((JComboBox)value_control).getSelectedItem()).toString();
    368         argument.setValue(language);
    369         // Kinda lucked out here. Its impossible not to choose an entry from these comboboxes as they are restricted.
    370         argument.setAssigned(true);
    371         return true;
    372         case Argument.METADATUM:
    373         case Argument.METADATA:
    374         Object new_value_raw = ((JComboBox) value_control).getSelectedItem();
    375         if (new_value_raw instanceof MetadataElement) {
    376             argument.setValue(((MetadataElement) new_value_raw).getFullName());
    377         }
    378         else {
    379             // But we have to be careful as an arbitary string object could be zero length
    380             String new_value = new_value_raw.toString();
    381             ///ystem.err.println("The current value is: " + new_value);
    382             if(new_value.length() > 0) {
    383             argument.setValue(new_value);
    384             }
    385             else {
    386             String args[] = new String[1];
    387             args[0] = argument.getName();
    388             if(argument.isRequired()) {
    389                 JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    390             }
    391             // They've left the field blank
     506    }
     507    /** Explicitly sets the value of a JTextField type control to the given String.
     508     * @param value_str The new value of the control as a <strong>String</strong>.
     509     */
     510    public void setValue(String value_str) {
     511        ((JTextField)value_control).setText(value_str);
     512    }
     513
     514    /** Listens for actions apon the enable checkbox, and if detected enables or diables control appropriately. */
     515    private class EnabledListener
     516    implements ActionListener {
     517        /** An editor component, such as a JComboBox or JTextField, that might have its enabled state changed by this listener. */
     518        private JComponent target = null;
     519
     520        /** Constructor. */
     521        public EnabledListener(JComponent target) {
     522            this.target = target;
     523        }
     524
     525        /** Any implementation of ActionListener must include this method so that we can be informed when an action has been performed on or registered check box, prompting us to change the state of the other controls as per the users request.
     526         * @param event An <strong>ActionEvent</strong> containing information about the click.
     527         */
     528        public void actionPerformed(ActionEvent event) {
     529            if (this.target == null) {
     530                return;
     531            }
     532            JCheckBox source = (JCheckBox)event.getSource();
     533            if(source.isSelected()) {
     534                target.setBackground(Color.white);
     535                target.setEnabled(true);
     536            }
    392537            else {
    393                 JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    394                 argument.setValue(null);
    395             }
    396             args = null;
    397             return false;
    398             }
    399         }
    400         argument.setAssigned(true);
    401         return true;
    402         case Argument.REGEXP:
    403         case Argument.STRING:
    404         result = ((JTextField)value_control).getText();
    405         if(result.length() > 0) {
    406             argument.setValue(result);
    407         }
    408         else {
    409             String args[] = new String[1];
    410             args[0] = argument.getName();
    411             if(argument.isRequired()) {
    412             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    413             }
    414             // They've left the field blank
    415             else {
    416             JOptionPane.showMessageDialog(this, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
    417             argument.setValue(null);
    418             }
    419             args = null;
    420             return false;
    421         }
    422         argument.setAssigned(true);
    423         return true;
    424         }
    425         return false;
    426     }
    427     else {
    428         argument.setAssigned(false);
    429         return true;
    430     }
    431     }
    432 
    433    
    434     public boolean updateArgument(boolean checkRequired) {
    435 
    436      
    437     if (checkRequired){
    438         return updateArgument();
    439     }
    440     else{
    441         if (argument.getType() == Argument.STRING){
    442         String result = ((JTextField)value_control).getText();
    443                
    444         if(result.length() > 0) {
    445             argument.setValue(result);
    446                     argument.setAssigned(true);                   
    447         }
    448         }   
    449     }
    450 
    451     return true;
    452    
    453     }
    454      
    455    
    456 
    457     /** Method to ensure that a certain value is selected, if it exists within that combobox to begin with.
    458      * @param combobox The <strong>JComboBox</strong> whose selection we are trying to preset.
    459      * @param target The desired value of the selection as a <strong>String</strong>.
    460      * @return true if the item was found and selected, false otherwise
    461      * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.Argument.ArgumentOption
    462      */
    463     public static boolean selectValue(JComboBox combobox, String target)
    464     {
    465     for (int i = 0; i < combobox.getItemCount(); i++) {
    466         Object object = combobox.getItemAt(i);
    467 
    468         if (object instanceof Argument.ArgumentOption) {
    469         Argument.ArgumentOption opt = (Argument.ArgumentOption) object;
    470         if (opt.name.startsWith(target)) {
    471             combobox.setSelectedIndex(i);
    472             combobox.setToolTipText(opt.getToolTip());
    473             return true;
    474         }
    475         }
    476         else if (object instanceof MetadataElement) {
    477         if(((MetadataElement)object).getFullName().equals(target)) {
    478             combobox.setSelectedIndex(i);
    479             return true;
    480         }
    481         }
    482         else if (object.toString().equals(target)) {
    483         combobox.setSelectedIndex(i);
    484         return true;
    485         }
    486     }
    487 
    488     return false;
    489     }
    490 
    491 
    492     /** Forces the control into an 'enabled' mode. */
    493     public void setEnabled() {
    494     enabled.setSelected(true);
    495     }
    496     /** Explicitly sets the value of a JTextField type control to the given String.
    497      * @param value_str The new value of the control as a <strong>String</strong>.
    498      */
    499     public void setValue(String value_str) {
    500     ((JTextField)value_control).setText(value_str);
    501     }
    502 
    503     /** Listens for actions apon the enable checkbox, and if detected enables or diables control appropriately. */
    504     private class EnabledListener
     538                target.setBackground(Color.lightGray);
     539                target.setEnabled(false);
     540            }
     541            // Special case of stupid JSpinners who don't let their backgrounds change properly.
     542            if(target instanceof JSpinner) {
     543                JSpinner spinner = (JSpinner) target;
     544                JComponent c = spinner.getEditor();
     545                if ( c instanceof JSpinner.DefaultEditor ) {
     546                    JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
     547                    JFormattedTextField field = editor.getTextField();
     548                    field.setEditable(source.isSelected());
     549                    if(source.isSelected()) {
     550                        field.setBackground(Color.white);
     551                    }
     552                    else {
     553                        field.setBackground(Color.lightGray);
     554                    }
     555                }
     556            }
     557        }
     558    }
     559
     560
     561    /** Listener that sets the tooltip associated to a combobox to the tooltip relevant to the selected item. */
     562    private class ToolTipUpdater
    505563    implements ActionListener {
    506     /** An editor component, such as a JComboBox or JTextField, that might have its enabled state changed by this listener. */
    507     private JComponent target = null;
    508    
    509     /** Constructor. */
    510     public EnabledListener(JComponent target) {
    511         this.target = target;
    512     }
    513    
    514     /** Any implementation of ActionListener must include this method so that we can be informed when an action has been performed on or registered check box, prompting us to change the state of the other controls as per the users request.
    515      * @param event An <strong>ActionEvent</strong> containing information about the click.
    516      */
    517     public void actionPerformed(ActionEvent event) {
    518         if (this.target == null) {
    519         return;
    520         }
    521         JCheckBox source = (JCheckBox)event.getSource();
    522         if(source.isSelected()) {
    523         target.setBackground(Color.white);
    524         target.setEnabled(true);
    525         }
    526         else {
    527         target.setBackground(Color.lightGray);
    528         target.setEnabled(false);
    529         }
    530         // Special case of stupid JSpinners who don't let their backgrounds change properly.
    531         if(target instanceof JSpinner) {
    532         JSpinner spinner = (JSpinner) target;
    533         JComponent c = spinner.getEditor();
    534         if ( c instanceof JSpinner.DefaultEditor ) {
    535             JSpinner.DefaultEditor editor = (JSpinner.DefaultEditor) c;
    536             JFormattedTextField field = editor.getTextField();
    537             field.setEditable(source.isSelected());
    538             if(source.isSelected()) {
    539             field.setBackground(Color.white);
    540             }
    541             else {
    542             field.setBackground(Color.lightGray);
    543             }
    544         }
    545         }
    546     }
    547     }
    548    
    549 
    550     /** Listener that sets the tooltip associated to a combobox to the tooltip relevant to the selected item. */
    551     private class ToolTipUpdater
    552     implements ActionListener {
    553     /** Any implementation of an ActionListener must include this method so that we can be informed when the selection in a combobox has changed and update the tooltip accordingly.
    554      * @param event An <strong>ActionEvent</strong> containing information about the action that fired this call.
    555      */
    556     public void actionPerformed(ActionEvent event) {
    557         JComboBox source = (JComboBox)event.getSource();
    558         Object object = source.getSelectedItem();
    559         if(object instanceof Argument.ArgumentOption) {
    560         Argument.ArgumentOption opt = (Argument.ArgumentOption)object;
    561         if(opt != null) {
    562             source.setToolTipText(opt.getToolTip());
    563         }
    564         else {
    565             source.setToolTipText(StaticStrings.EMPTY_STR);
    566         }
    567         }
    568     }
    569     }
     564        /** Any implementation of an ActionListener must include this method so that we can be informed when the selection in a combobox has changed and update the tooltip accordingly.
     565         * @param event An <strong>ActionEvent</strong> containing information about the action that fired this call.
     566         */
     567        public void actionPerformed(ActionEvent event) {
     568            JComboBox source = (JComboBox)event.getSource();
     569            Object object = source.getSelectedItem();
     570            if(object instanceof Argument.ArgumentOption) {
     571                Argument.ArgumentOption opt = (Argument.ArgumentOption)object;
     572                if(opt != null) {
     573                    source.setToolTipText(opt.getToolTip());
     574                }
     575                else {
     576                    source.setToolTipText(StaticStrings.EMPTY_STR);
     577                }
     578            }
     579        }
     580    }
    570581}
Note: See TracChangeset for help on using the changeset viewer.