Changeset 18352


Ignore:
Timestamp:
2009-01-12T11:17:16+13:00 (15 years ago)
Author:
kjdon
Message:

updated the rtl-gli branch with files from trunk. Result of a merge 14807:18318

Location:
gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm
Files:
13 edited
1 copied

Legend:

Unmodified
Added
Removed

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/Argument.java

    r12824 r18352  
    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.setDisplayName(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 setDisplayName(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                setDisplayName(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/branches/rtl-gli/src/org/greenstone/gatherer/cdm/ArgumentConfiguration.java

    r12749 r18352  
    211211    int current_mode = Configuration.getMode();
    212212
    213     String previous_owner = ((Argument) arguments.get(0)).getOwner();
    214     addHeader(previous_owner, colour_two);
     213    String previous_owner = "";
     214    if(arguments.size() > 0) {
     215        previous_owner = ((Argument) arguments.get(0)).getOwner();
     216        addHeader(previous_owner, colour_two);
     217    }
    215218
    216219    for(int i = 0; i < arguments.size(); i++) {

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/ArgumentContainer.java

    r12826 r18352  
    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.setDisplayName(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/branches/rtl-gli/src/org/greenstone/gatherer/cdm/CollectionConfiguration.java

    r14636 r18352  
    293293                value = tokenizer.nextToken ();
    294294                // Test if the value is actually a name, and if so add the name by itself, then put value into name so that it is parsed correctly during the next loop.
    295                 if(value.startsWith (StaticStrings.MINUS_CHARACTER)) {
     295        // The value is not a name if it contains a space character: it's a quoted value
     296                if (value.startsWith(StaticStrings.MINUS_CHARACTER) && value.indexOf(StaticStrings.SPACE_CHARACTER) == -1) {
    296297                    arguments.put (name, null);
    297298                    name = value;
    … …  
    439440        int option_elements_length = option_elements.getLength ();
    440441        for(int j = 0; j < option_elements_length; j++) {
    441             Element option_element = (Element) option_elements.item (j);
     442      Element option_element = (Element) option_elements.item (j);
    442443            if(option_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
    443                 text.append (StaticStrings.SPACE_CHARACTER);
    444                 text.append (StaticStrings.MINUS_CHARACTER);
    445                 text.append (option_element.getAttribute (StaticStrings.NAME_ATTRIBUTE));
    446                 String value_str = XMLTools.getValue (option_element);
    447                
     444          text.append (StaticStrings.SPACE_CHARACTER);
     445          text.append (StaticStrings.MINUS_CHARACTER);
     446          text.append (option_element.getAttribute (StaticStrings.NAME_ATTRIBUTE));
     447          String value_str = XMLTools.getValue (option_element);
     448             
    448449                // Convert metadata element names to internal names, and remove extracted metadata namespaces
    449450                if (value_str.length () > 0) {
    … …  
    13301331                // The next token is the type
    13311332                String type = tokenizer.nextToken ();
     1333        type = ensureNewPluginName(type);
    13321334                command_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, type);
    13331335                // Now we parse out the remaining arguments into a hashmapping from name to value
    … …  
    13721374        }
    13731375        catch(Exception exception) {
     1376        // This catch clause had been left empty.  If this is deliberate then
     1377        // we should have a comment here explaining why there is no need to
     1378        // print anything out.  Am assuming this is mistake for now, and
     1379        // have added in a call to printStackTrace()
     1380        System.err.println("Malformed plugin statement");
     1381        exception.printStackTrace();
    13741382        }
    13751383        return command_element;
    … …  
    14201428                    command_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, StaticStrings.INCLUDE_STR);
    14211429                }
    1422                 StringTokenizer pattern_tokenizer = new StringTokenizer (full_pattern_str, StaticStrings.SEPARATOR_CHARACTER);
    1423                 if(pattern_tokenizer.countTokens () >= 2) {
    1424                     String content_str = pattern_tokenizer.nextToken ();
     1430
     1431                // Let's make sure it is a valid Greenstone configuration line
     1432                String[] results = full_pattern_str.split("\\" + StaticStrings.SEPARATOR_CHARACTER, 3);
     1433
     1434                if (results.length >= 2) {
     1435                    String content_str = results[0];
    14251436                    // Since the contents of indexes have to be certain keywords, or metadata elements, if the content isn't a keyword and doesn't yet have a namespace, append the extracted metadata namespace.
    1426                     if(!content_str.equals (StaticStrings.FILENAME_STR) && content_str.indexOf (StaticStrings.NS_SEP) == -1) {
     1437                    if (!content_str.equals (StaticStrings.FILENAME_STR) && content_str.indexOf (StaticStrings.NS_SEP) == -1) {
    14271438                        content_str = StaticStrings.EXTRACTED_NAMESPACE + content_str;
    14281439                    }
    14291440                    command_element.setAttribute (StaticStrings.CONTENT_ATTRIBUTE, content_str);
    1430                     XMLTools.setValue (command_element, pattern_tokenizer.nextToken ());
    1431                     if(pattern_tokenizer.hasMoreTokens ()) {
    1432                         command_element.setAttribute (StaticStrings.OPTIONS_ATTRIBUTE, pattern_tokenizer.nextToken ());
    1433                     }
    1434                 }
    1435                 pattern_tokenizer = null;
     1441                    XMLTools.setValue (command_element, results[1]);
     1442                    if (results.length >= 3) {
     1443                        command_element.setAttribute (StaticStrings.OPTIONS_ATTRIBUTE, results[2]);
     1444                    }
     1445                }
    14361446            }
    14371447        }
    … …  
    15211531   
    15221532    static private String pluginToString (Element command_element, boolean show_extracted_namespace) {
    1523         StringBuffer text = new StringBuffer ();
    1524         if(!command_element.getAttribute (StaticStrings.SEPARATOR_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
    1525             text.append (StaticStrings.PLUGIN_STR);
    1526             text.append (StaticStrings.TAB_CHARACTER);
    1527             text.append (StaticStrings.TAB_CHARACTER);
    1528             text.append (command_element.getAttribute (StaticStrings.TYPE_ATTRIBUTE));
    1529             // Retrieve, and output, the arguments
    1530             NodeList option_elements = command_element.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
    1531             int option_elements_length = option_elements.getLength ();
    1532             if(option_elements_length > 0) {
    1533                 for(int j = 0; j < option_elements_length; j++) {
    1534                     Element option_element = (Element) option_elements.item (j);
    1535                     if(option_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
    1536                         text.append (StaticStrings.SPACE_CHARACTER);
    1537                         text.append (StaticStrings.MINUS_CHARACTER);
    1538                         text.append (option_element.getAttribute (StaticStrings.NAME_ATTRIBUTE));
    1539                         String value_str = XMLTools.getValue (option_element);
    1540                         if(!show_extracted_namespace && value_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
    1541                             value_str = value_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
    1542                         }
    1543                         if(value_str.length () > 0) {
    1544                             text.append (StaticStrings.SPACE_CHARACTER);
    1545                             if(value_str.indexOf (StaticStrings.SPACE_CHARACTER) == -1) {
    1546                                 text.append (value_str);
    1547                             }
    1548                             else {
    1549                                 text.append (StaticStrings.SPEECH_CHARACTER);
    1550                                 text.append (value_str);
    1551                                 text.append (StaticStrings.SPEECH_CHARACTER);
    1552                             }
    1553                         }
    1554                         value_str = null;
    1555                     }
    1556                     option_element = null;
    1557                 }
    1558             }
    1559             option_elements = null;
    1560         }
    1561         return text.toString ();
     1533        if(command_element.getAttribute (StaticStrings.SEPARATOR_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
     1534      return "";
     1535    }
     1536        StringBuffer text = new StringBuffer (StaticStrings.PLUGIN_STR);
     1537    text.append (StaticStrings.TAB_CHARACTER);
     1538    text.append (command_element.getAttribute (StaticStrings.TYPE_ATTRIBUTE));
     1539    // Retrieve, and output, the arguments
     1540    NodeList option_elements = command_element.getElementsByTagName (StaticStrings.OPTION_ELEMENT);
     1541    int option_elements_length = option_elements.getLength ();
     1542    if(option_elements_length > 0) {
     1543      for(int j = 0; j < option_elements_length; j++) {
     1544        Element option_element = (Element) option_elements.item (j);
     1545        if(option_element.getAttribute (StaticStrings.ASSIGNED_ATTRIBUTE).equals (StaticStrings.TRUE_STR)) {
     1546          text.append (StaticStrings.SPACE_CHARACTER);
     1547          text.append (StaticStrings.MINUS_CHARACTER);
     1548          text.append (option_element.getAttribute (StaticStrings.NAME_ATTRIBUTE));
     1549          String value_str = XMLTools.getValue (option_element);
     1550
     1551         
     1552          // Convert metadata element names to internal names, and remove extracted metadata namespaces
     1553          if (value_str.length () > 0) {
     1554        StringTokenizer string_tokenizer = new StringTokenizer (value_str, ",");
     1555        StringBuffer value_buffer = new StringBuffer ();
     1556        while (string_tokenizer.hasMoreElements ()) {
     1557          String raw_token = (String) string_tokenizer.nextElement ();
     1558          String token = raw_token.trim ();
     1559          MetadataElement metadata_element = MetadataTools.getMetadataElementWithDisplayName (token);
     1560          if (metadata_element != null) {
     1561            token = metadata_element.getFullName ();
     1562          }
     1563                       
     1564          if (token.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
     1565            token = token.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
     1566          }
     1567          value_buffer.append (token);
     1568          if (string_tokenizer.hasMoreElements ()) {
     1569            value_buffer.append (",");
     1570          }
     1571        }
     1572        value_str = value_buffer.toString ();
     1573          }
     1574
     1575          // if(!show_extracted_namespace && value_str.startsWith (StaticStrings.EXTRACTED_NAMESPACE)) {
     1576          //            value_str = value_str.substring (StaticStrings.EXTRACTED_NAMESPACE.length ());
     1577          //        }
     1578          if(value_str.length () > 0) {
     1579        text.append (StaticStrings.SPACE_CHARACTER);
     1580        if(value_str.indexOf (StaticStrings.SPACE_CHARACTER) == -1) {
     1581          text.append (value_str);
     1582        }
     1583        else {
     1584          text.append (StaticStrings.SPEECH_CHARACTER);
     1585          text.append (value_str);
     1586          text.append (StaticStrings.SPEECH_CHARACTER);
     1587        }
     1588          }
     1589          value_str = null;
     1590        }
     1591        option_element = null;
     1592      }
     1593    }
     1594    option_elements = null;
     1595   
     1596    return text.toString ();
    15621597    }
    15631598   
    … …  
    17191754            e.setAttribute (StaticStrings.LANGUAGE_ATTRIBUTE, lang);
    17201755            XMLTools.setNodeText (e, text);
    1721            
    17221756            display_item_list.add (e);
    17231757        }
    … …  
    18731907            Element e = (Element)index_children.item (i);
    18741908            String index_str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
    1875             String index_str_display = index_str;//for creating collectionmetadata for this index
     1909            String index_str_display = index_str;//for creating collectionmetadata for this index 
    18761910           
    18771911            // Handling 'index' element
    … …  
    20472081            Element e = (Element)plugin_children.item (i);
    20482082            String str = e.getAttribute (StaticStrings.NAME_ATTRIBUTE);
     2083        str = ensureNewPluginName(str);
    20492084            Element plugin_element = to.createElement (StaticStrings.PLUGIN_ELEMENT);
    20502085            plugin_element.setAttribute (StaticStrings.TYPE_ATTRIBUTE, str);
    … …  
    21972232            }
    21982233            if (format != null) {
    2199                 String gsf_text = XMLTools.xmlNodeToStringWithoutNewline(format);
    2200                 
     2234                String gsf_text = XMLTools.xmlNodeToStringWithoutIndenting(format);
     2235               
    22012236                if (gsf_text.startsWith("<") && (gsf_text.indexOf("<") != gsf_text.lastIndexOf("<"))) {
    22022237                    gsf_text = gsf_text.substring(gsf_text.indexOf("<gsf"),
    … …  
    30903125            StaticStrings.NAME_ATTRIBUTE, index_value);
    30913126           
    3092             if (collectionmetadata_list == null) {
    3093                 //try adding the "." prefix
    3094                 index_value = StaticStrings.DOT_CHARACTER + index_value;
    3095                 collectionmetadata_list = XMLTools.getNamedElementList (source,
    3096                 StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3097                 StaticStrings.NAME_ATTRIBUTE, index_value);
    3098             }
    30993127            if (collectionmetadata_list != null) {
    31003128               
    … …  
    31493177            StaticStrings.NAME_ATTRIBUTE, name_str);
    31503178           
    3151             if (collectionmetadata_list == null) {
    3152                 //try adding the "." prefix
    3153                 name_str = StaticStrings.DOT_CHARACTER + name_str;
    3154                 collectionmetadata_list = XMLTools.getNamedElementList (source,
    3155                 StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3156                 StaticStrings.NAME_ATTRIBUTE, name_str);
    3157             }
    31583179            if (collectionmetadata_list != null) {
    31593180               
    … …  
    32913312            StaticStrings.NAME_ATTRIBUTE, temp_str);
    32923313           
    3293             if (collectionmetadata_list == null) {
    3294                 //try adding the "." prefix
    3295                 String with_dot_str = StaticStrings.DOT_CHARACTER + temp_str;
    3296                 collectionmetadata_list = XMLTools.getNamedElementList (source,
    3297                 StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3298                 StaticStrings.NAME_ATTRIBUTE, with_dot_str);
    3299                
    3300                 if (collectionmetadata_list == null) {
    3301                     //try the full name, i.e. with 'ex.'
    3302                     if (mg_indexer == true) {
    3303                         full_index_name = level_str+StaticStrings.COLON_CHARACTER+full_index_name;
    3304                     }
    3305                     collectionmetadata_list = XMLTools.getNamedElementList (source,
    3306                     StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3307                     StaticStrings.NAME_ATTRIBUTE, full_index_name);
    3308                 }
    3309                 if (collectionmetadata_list == null) {
    3310                     with_dot_str = StaticStrings.DOT_CHARACTER + full_index_name;
    3311                     collectionmetadata_list = XMLTools.getNamedElementList (source,
    3312                     StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3313                     StaticStrings.NAME_ATTRIBUTE, with_dot_str);
    3314                 }
    3315             }
     3314        if (collectionmetadata_list == null) {
     3315          //try the full name, i.e. with 'ex.'
     3316          if (mg_indexer == true) {
     3317        // but first append level info if we are mg
     3318        full_index_name = level_str+StaticStrings.COLON_CHARACTER+full_index_name;
     3319          }
     3320          collectionmetadata_list = XMLTools.getNamedElementList (source,
     3321                 StaticStrings.COLLECTIONMETADATA_ELEMENT,
     3322                 StaticStrings.NAME_ATTRIBUTE, full_index_name);
     3323        }
     3324   
    33163325            if (collectionmetadata_list != null) {
    33173326               
    … …  
    33683377            StaticStrings.NAME_ATTRIBUTE, name_str);
    33693378           
    3370             if (collectionmetadata_list == null) {
    3371                 //try adding the "." prefix
    3372                 name_str = StaticStrings.DOT_CHARACTER + name_str;
    3373                 collectionmetadata_list = XMLTools.getNamedElementList (source,
    3374                 StaticStrings.COLLECTIONMETADATA_ELEMENT,
    3375                 StaticStrings.NAME_ATTRIBUTE, name_str);
    3376             }
    33773379            if (collectionmetadata_list != null) {
    33783380               
    … …  
    37323734        // If we're using a remote Greenstone server, upload the new 'collectionConfig.xml' file
    37333735        if (Gatherer.isGsdlRemote) {
    3734             RemoteGreenstoneServer.uploadCollectionFile (collection_name, collect_cfg_file);
     3736            Gatherer.remoteGreenstoneServer.uploadCollectionFile (collection_name, collect_cfg_file);
    37353737        }
    37363738       
    … …  
    38243826            // If we're using a remote Greenstone server, upload the new collect.cfg file
    38253827            if (Gatherer.isGsdlRemote) {
    3826                 RemoteGreenstoneServer.uploadCollectionFile (collection_name, collect_cfg_file);
     3828                Gatherer.remoteGreenstoneServer.uploadCollectionFile (collection_name, collect_cfg_file);
    38273829            }
    38283830        }
    … …  
    38863888        return skeleton;
    38873889    }
     3890
     3891  static private HashMap plugin_map = null;
     3892 
     3893  private void setUpPluginNameMap() {
     3894    plugin_map = new HashMap();
     3895    plugin_map.put("GAPlug", "GreenstoneXMLPlugin");
     3896    plugin_map.put("RecPlug", "DirectoryPlugin");
     3897    plugin_map.put("ArcPlug","ArchivesInfPlugin");
     3898    plugin_map.put("TEXTPlug","TextPlugin");
     3899    plugin_map.put("XMLPlug","ReadXMLFile");
     3900    plugin_map.put("EMAILPlug","EmailPlugin");
     3901    plugin_map.put("SRCPlug","SourceCodePlugin");
     3902    plugin_map.put("NULPlug","NulPlugin");
     3903    plugin_map.put("W3ImgPlug","HTMLImagePlugin");
     3904    plugin_map.put("PagedImgPlug","PagedImagePlugin");
     3905    plugin_map.put("METSPlug", "GreenstoneMETSPlugin");
     3906    plugin_map.put("DBPlug", "DatabasePlugin");
     3907    plugin_map.put("PPTPlug", "PowerPointPlugin");
     3908    plugin_map.put("PSPlug", "PostScriptPlugin");
     3909  }
     3910
     3911  private String ensureNewPluginName(String plugin) {
     3912    if (plugin.endsWith("Plugin")) return plugin;
     3913    if (plugin_map == null) {
     3914      setUpPluginNameMap();
     3915    }
     3916    String new_name = (String)plugin_map.get(plugin);
     3917    if (new_name != null) return new_name;
     3918    new_name = plugin.replaceAll("Plug", "Plugin");
     3919    return new_name;
     3920  }
     3921   
     3922
    38883923    ///*********************************************************************************************************///
    38893924}
     3925

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/CollectionDesignManager.java

    r14237 r18352  
    7878    /** The text translation manager. */
    7979    static public TranslationView translation_manager;
     80    /** A manager of configuring depositor metadata */
     81    static public DepositorMetadataManager depositormetadata_manager;
    8082    /** These mark what needs to happen when building a collection where ONLY design options have been changed.
    8183        The build requirements of the higher numbers must include doing everything from the lower numbers. */
    … …  
    128130    supercollection_manager = new SuperCollectionManager(collect_config.getSuperCollection());
    129131    searchmetadata_manager = new SearchMetadataManager();
     132    depositormetadata_manager = new DepositorMetadataManager();
    130133    translation_manager = new TranslationView();
    131134    if (Gatherer.GS3) {
    … …  
    160163    supercollection_manager.destroy();
    161164    supercollection_manager = null;
     165    depositormetadata_manager.destroy();
     166    depositormetadata_manager = null;
    162167    translation_manager.destroy();
    163168    translation_manager = null;
    … …  
    178183    language_manager.modeChanged(mode);
    179184    searchmetadata_manager.modeChanged(mode);
     185    depositormetadata_manager.modeChanged(mode);
    180186    }
    181187

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/Format.java

    r13368 r18352  
    4242
    4343    /** The default features (not all of these are in the Greenstone Developer's Guide). */
    44     static final public String DEFAULT_FEATURES[] = { "", "AllowExtendedOptions", "Document", "DocumentArrowsBottom", "DocumentArrowsTop","DocumentSearchResultLinks", "DocumentButtons", "DocumentContents", "DocumentHeading", "DocumentImages", "DocumentText", "DocumentTitles", "DocumentUseHTML", "RelatedDocuments", "Search", "SearchTypes" };
     44    static final public String DEFAULT_FEATURES[] = { "", "AllowExtendedOptions", "Document", "DocumentArrowsBottom", "DocumentArrowsTop","DocumentSearchResultLinks", "DocumentButtons", "DocumentContents", "DocumentHeading", "DocumentImages", "DocumentText", "DocumentTitles", "DocumentUseHTML", "NavigationBar", "RelatedDocuments", "Search", "SearchTypes" };
    4545    /** The list of known feature parts. */
    4646    static final public String DEFAULT_PARTS[] = { "", "DateList", "HList", "VList" };

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/FormatManager.java

    r14746 r18352  
    7777  static final private String SEARCHTYPES_DEFAULT_FORMAT = "plain,form";
    7878 
     79  static final private String NAVBAR = "NavigationBar";
     80  static final private String NAVBAR_OPTION = "pulldown";
     81
    7982  static private HashMap default_format_map = null;
    8083 
    … …  
    98101    default_format_map.put(DOCUMENTBUTTONS, DOCUMENTBUTTONS_DEFAULT_FORMAT);
    99102    default_format_map.put(SEARCHTYPES, SEARCHTYPES_DEFAULT_FORMAT);
     103    default_format_map.put(NAVBAR, NAVBAR_OPTION);
    100104    default_format_map.put("", "");
    101105   

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/GeneralManager.java

    r14587 r18352  
    299299        String creator_email_str = creator_emailfield.getText();
    300300        creator_collectionmeta.setValue(creator_email_str);
    301         // If the email is currently empty, store this email
    302         if(Configuration.getEmail() == null) {
    303         Configuration.setEmail(creator_email_str); // Store the email address in the configuration
    304         }
    305301        collection_extra_collectionmeta.setValue(description_textarea.getText());
    306302        icon_collection_collectionmeta.setValue(icon_textfield.getText());
    … …  
    348344                // If we're using a remote Greenstone server, upload the image
    349345                if (Gatherer.isGsdlRemote) {
    350                 RemoteGreenstoneServer.uploadCollectionFile(CollectionManager.getLoadedCollectionName(), collection_image_file);
     346                Gatherer.remoteGreenstoneServer.uploadCollectionFile(
     347                                   CollectionManager.getLoadedCollectionName(), collection_image_file);
    351348                }
    352349            }

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/IndexOptionManager.java

    r13468 r18352  
    190190    private JCheckBox casefold_checkbox = new JCheckBox();
    191191    private JCheckBox accentfold_checkbox = new JCheckBox();
    192 
     192    private JCheckBox separate_cjk_checkbox =new JCheckBox();
     193   
    193194    public StemmingControl()
    194195    {
    … …  
    197198       
    198199        stem_checkbox.setText(Dictionary.get("CDM.IndexingManager.Stem"));
     200        stem_checkbox.setToolTipText(Dictionary.get("CDM.IndexingManager.Stem_Tooltip"));
    199201        stem_checkbox.setActionCommand(StaticStrings.STEM_OPTION_STR);
    200202       
    201203        casefold_checkbox.setText(Dictionary.get("CDM.IndexingManager.Casefold"));
     204        casefold_checkbox.setToolTipText(Dictionary.get("CDM.IndexingManager.Casefold_Tooltip"));
    202205        casefold_checkbox.setActionCommand(StaticStrings.CASEFOLD_OPTION_STR);
    203206       
    204207        accentfold_checkbox.setText(Dictionary.get("CDM.IndexingManager.Accent_fold"));
     208        accentfold_checkbox.setToolTipText(Dictionary.get("CDM.IndexingManager.Accent_fold_Tooltip"));
    205209        accentfold_checkbox.setActionCommand(StaticStrings.ACCENTFOLD_OPTION_STR);
    206210        // Accent-folding is currently not available for MG
    207211        accentfold_checkbox.setEnabled(!build_type.equals(BuildTypeManager.BUILD_TYPE_MG));
    208        
     212   
     213        separate_cjk_checkbox.setText(Dictionary.get("CDM.IndexingManager.Separate_cjk"));
     214        separate_cjk_checkbox.setToolTipText(Dictionary.get("CDM.IndexingManager.Separate_cjk_Tooltip"));
     215        separate_cjk_checkbox.setActionCommand(StaticStrings.SEPARATE_CJK_OPTION_STR);
     216
    209217        JPanel checkbox_panel = new JPanel();
    210         checkbox_panel.setLayout(new GridLayout(1, 3));
    211         checkbox_panel.add(stem_checkbox);
    212         checkbox_panel.add(casefold_checkbox);
    213         checkbox_panel.add(accentfold_checkbox);
    214        
     218        checkbox_panel.setLayout(new GridLayout(2, 1));
     219       
     220        JPanel stem_panel = new JPanel();
     221        stem_panel.setLayout(new GridLayout(1,3));
     222        stem_panel.add(stem_checkbox);
     223        stem_panel.add(casefold_checkbox);
     224        stem_panel.add(accentfold_checkbox);
     225       
     226        JPanel other_panel = new JPanel();
     227        other_panel.setLayout(new GridLayout(1,1));
     228        other_panel.add(separate_cjk_checkbox);
     229
     230        checkbox_panel.add(stem_panel);
     231        checkbox_panel.add(other_panel);
     232
    215233        add(new JLabel(Dictionary.get("CDM.IndexingManager.Options")), BorderLayout.WEST);
    216234        add(checkbox_panel, BorderLayout.CENTER);
    … …  
    227245            stem_model.addOption(StaticStrings.ACCENTFOLD_OPTION_STR);
    228246        }
     247        separate_cjk_checkbox.setSelected(false);
    229248        }
    230249        else {
    … …  
    238257            accentfold_checkbox.setSelected(true);
    239258        }
     259        if (stem_model.getOption(StaticStrings.SEPARATE_CJK_OPTION_STR) != null) {
     260            separate_cjk_checkbox.setSelected(true);
     261        }
     262       
    240263       
    241264        }
    … …  
    245268        casefold_checkbox.addActionListener(cbl);
    246269        accentfold_checkbox.addActionListener(cbl);
    247 
     270        separate_cjk_checkbox.addActionListener(cbl);
     271       
    248272        // changing stem indexes changes build settings
    249273        stem_checkbox.addActionListener(CollectionDesignManager.buildcol_change_listener);
    250274        casefold_checkbox.addActionListener(CollectionDesignManager.buildcol_change_listener);
    251275        accentfold_checkbox.addActionListener(CollectionDesignManager.buildcol_change_listener);
    252 
     276        separate_cjk_checkbox.addActionListener(CollectionDesignManager.buildcol_change_listener);
    253277       
    254278    }
    … …  
    258282        if (new_build_type.equals(BuildTypeManager.BUILD_TYPE_MG)) {
    259283        //changing to MG
     284        accentfold_checkbox.setSelected(false);
    260285        accentfold_checkbox.setEnabled(false);
    261286        if (accentfold_checkbox.isSelected()) {
    … …  
    307332        document_checkbox = new JCheckBox();
    308333        document_checkbox.setText(Dictionary.get("CDM.LevelManager.Document"));
     334        document_checkbox.setActionCommand(StaticStrings.DOCUMENT_STR);
    309335        document_default_radio = new JRadioButton();
    310336        document_default_radio.setBackground(Configuration.getColor("coloring.collection_tree_background", false));
    … …  
    316342        section_checkbox = new JCheckBox();
    317343        section_checkbox.setText(Dictionary.get("CDM.LevelManager.Section"));
     344        section_checkbox.setActionCommand(StaticStrings.SECTION_STR);
    318345        section_default_radio = new JRadioButton();
    319346        section_default_radio.setOpaque(true);

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/MacrosManager.java

    r13591 r18352  
    217217        // Users need to wait until the upload has finished before pressing Preview Collection!
    218218        if (Gatherer.isGsdlRemote) {
    219             RemoteGreenstoneServer.uploadCollectionFile(CollectionManager.getLoadedCollectionName(), extra_dm_file);
     219            Gatherer.remoteGreenstoneServer.uploadCollectionFile(CollectionManager.getLoadedCollectionName(), extra_dm_file);
    220220        }
    221221        }

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/Plugin.java

    r13177 r18352  
    4242    private String default_process_expression = "";
    4343    private boolean does_explode_metadata_databases = false;
    44     private boolean loading_options_failed = false;
    45 
    46    
     44    private boolean does_replace_srcdocs_with_html = false; // to work with replace_srcdoc_with_html.pl
     45    /** Plugins are loaded as needed. This variable indicates 1. whether a plugin has been loaded already; 2. whether a
     46     * plugin has been successfully loaded. When both are true, has_loaded_options will be true. */
     47    private boolean has_loaded_options = false;
     48
    4749    /** Constructor used in DOMProxyListModel initializations, and Library Level. Used for Base plugins (those in the list of available plugins, not ones that are in the DOMProxyList)
    4850     */
    … …  
    8486
    8587
    86     public boolean didLoadingOptionsFail()
    87     {
    88     return loading_options_failed;
     88    public boolean hasLoadedOptions()
     89    {
     90    return has_loaded_options;
    8991    }
    9092
    … …  
    100102    }
    101103
     104    /** Checks whether the plugin this instance is based on processes source documents that can be replaced with their Greenstone generated html variants.
     105     * This method works with replace_srcdoc_with_html.pl */
     106    public boolean doesReplaceSrcDocsWithHtml()
     107    {
     108    //return does_replace_srcdocs_with_html;
     109    Plugin base_plugin = Plugins.getPlugin(getName(), false);
     110    if (base_plugin == null) {
     111      return false;
     112    }
     113    return base_plugin.does_replace_srcdocs_with_html;
     114    }
    102115
    103116    /** Checks whether this plugin instance will process the specified file (given its block_exp). */
    … …  
    211224    }
    212225
    213 
    214     public void setLoadingOptionsFailed()
    215     {
    216     this.loading_options_failed = true;
     226    // To work with replace_srcdoc_with_html.pl
     227    public void setDoesReplaceSrcDocsWithHtml(boolean does_replace_srcdocs_with_html)
     228    {
     229    this.does_replace_srcdocs_with_html = does_replace_srcdocs_with_html;
     230    }
     231
     232    public void setHasLoadedOptions(boolean hasLoadedOptions)
     233    {
     234    this.has_loaded_options = hasLoadedOptions;
    217235    }
    218236}

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/PluginManager.java

    r14234 r18352  
    7070    private JPanel separator;
    7171    private Plugin separator_plugin;
     72
     73  /** The number of plugins that are fixed 'below the line' */
     74  private static int NUM_FIXED_PLUGINS = 3;
    7275    /** Constructor.
    7376     */
    … …  
    9396    private void ensureMetadataXMLPlugIsLoaded() {
    9497
    95     Plugin metaxmlplug = Plugins.getPlugin("MetadataXMLPlug", false);
     98    Plugin metaxmlplug = Plugins.getPlugin(StaticStrings.METADATAXMLPLUG_STR, false);
    9699    if (metaxmlplug!= null) {
    97100        if (!contains(metaxmlplug)) {
    … …  
    117120        if (!plugin.isAbstract()) {
    118121        String plugin_name = plugin.getName();
    119         if (!plugin_name.equals(StaticStrings.ARCPLUG_STR) && !plugin_name.equals(StaticStrings.RECPLUG_STR)) {
    120             available.add(plugin);
     122        if (!plugin_name.equals(StaticStrings.ARCPLUG_STR) && !plugin_name.equals(StaticStrings.RECPLUG_STR) && !plugin_name.equals(StaticStrings.METADATAXMLPLUG_STR)) {
     123          available.add(plugin);
    121124        }
    122125        }
    … …  
    148151    return exploder_plugins;   
    149152    }
    150 
    151153   
    152154    public boolean isFileExplodable(File file)
    … …  
    163165    }
    164166
     167    // Works with replace_srcdoc_with_html.pl
     168    public ArrayList getSrcReplacerPlugins(File file)
     169    {
     170    ArrayList srcreplacer_plugins = new ArrayList();
     171    ArrayList plugins_list = Plugins.getPluginsList();
     172    for (int i = 0; i < plugins_list.size(); i++) {
     173        Plugin plugin = (Plugin) plugins_list.get(i);
     174        if (plugin.doesReplaceSrcDocsWithHtml() == true && plugin.doesProcessFile(file)) {
     175        srcreplacer_plugins.add(plugin);
     176        }
     177    }
     178
     179    return srcreplacer_plugins;
     180    }   
     181
     182    // Works with replace_srcdoc_with_html.pl
     183    public boolean isFileSrcReplaceable(File file)
     184    {
     185    ArrayList plugins_list = Plugins.getPluginsList();
     186    for (int i = 0; i < plugins_list.size(); i++) {
     187        Plugin plugin = (Plugin) plugins_list.get(i);
     188       
     189        if (plugin.doesReplaceSrcDocsWithHtml() == true && plugin.doesProcessFile(file) == true) {
     190        return true;
     191        }
     192    }
     193
     194    return false;
     195    }   
    165196
    166197    /** Method to assign a plugin
    … …  
    168199     */
    169200    private void assignPlugin(Plugin plugin) {
    170     if(plugin.getName().equals(StaticStrings.RECPLUG_STR) || plugin.getName().equals(StaticStrings.ARCPLUG_STR)) {
     201      if(plugin.getName().equals(StaticStrings.RECPLUG_STR) || plugin.getName().equals(StaticStrings.ARCPLUG_STR) || plugin.getName().equals(StaticStrings.METADATAXMLPLUG_STR)) {
    171202        addAfter(plugin, separator_plugin); // Adds after separator
    172203    } else {
    … …  
    245276    int result = super.getSize();
    246277    if(modify_row_count) {
    247         result = result-3;
     278      result = result-(NUM_FIXED_PLUGINS+1);
    248279    }
    249280    return result;
    … …  
    267298    private void movePlugin(Plugin plugin, boolean direction, boolean all) {
    268299    // Can't ever move RecPlug or ArcPlug
    269     if(super.getSize() < 4) {
     300      if(super.getSize() < (NUM_FIXED_PLUGINS+2)) {
    270301        //DebugStream.println("Not enough plugins to allow moving.");
    271302        return;
    272303    }
    273     if(plugin.getName().equals(StaticStrings.ARCPLUG_STR) || plugin.getName().equals(StaticStrings.RECPLUG_STR)) {
     304    if(plugin.getName().equals(StaticStrings.ARCPLUG_STR) || plugin.getName().equals(StaticStrings.RECPLUG_STR) || plugin.getName().equals(StaticStrings.METADATAXMLPLUG_STR)) {
    274305        JOptionPane.showMessageDialog(Gatherer.g_man, Dictionary.get("CDM.Move.Fixed"), Dictionary.get("CDM.Move.Title"), JOptionPane.ERROR_MESSAGE);
    275306        return;
    … …  
    336367        Plugin plugin = (Plugin) getElementAt(index);
    337368        String name = plugin.getName();
    338         if(name.equals(StaticStrings.RECPLUG_STR) || name.equals(StaticStrings.ARCPLUG_STR)) {
     369        if(name.equals(StaticStrings.RECPLUG_STR) || name.equals(StaticStrings.ARCPLUG_STR) || name.equals(StaticStrings.METADATAXMLPLUG_STR)) {
    339370            found_fixed = true;
    340371            index--;
    … …  
    370401
    371402
    372     /** Inform the model to hide/show the last three lines on the list.
    373      * @param modify_row_count true to hide the last three lines, false otherwise
     403    /** Inform the model to hide/show the last four lines on the list.
     404     * @param modify_row_count true to hide the last four lines, false otherwise
    374405     */
    375406    private void setHideLines(boolean modify_row_count) {
    … …  
    377408    int original_size = super.getSize();
    378409    if(modify_row_count) {
    379         fireIntervalRemoved(this, original_size - 4, original_size - 1);
     410      fireIntervalRemoved(this, original_size - (NUM_FIXED_PLUGINS+2), original_size - 1);
    380411    }
    381412    else {
    382         fireIntervalAdded(this, original_size - 4, original_size - 1);
     413      fireIntervalAdded(this, original_size - (NUM_FIXED_PLUGINS+2), original_size - 1);
    383414    }
    384415    }
    … …  
    696727            String plugin_name = selected_plugin.getName();
    697728            // Some buttons are only available for plugins other than ArcPlug and RecPlug
    698             if(plugin_name.equals(StaticStrings.ARCPLUG_STR) || plugin_name.equals(StaticStrings.RECPLUG_STR) ) {
     729            if(plugin_name.equals(StaticStrings.ARCPLUG_STR) || plugin_name.equals(StaticStrings.RECPLUG_STR) || plugin_name.equals(StaticStrings.METADATAXMLPLUG_STR)) {
    699730              move_up_button.setEnabled(false);
    700731              move_down_button.setEnabled(false);
    701732              remove.setEnabled(false);
    702             } else if (plugin_name.equals(StaticStrings.METADATAXMLPLUG_STR)) {
    703               remove.setEnabled(false);
    704             }
     733            }
    705734           
    706735            else {
    707               // don't let people remove special plugins such GAPlug an METSPlug,
     736              // don't let people remove special plugins such GreenstoneXMLPlug and GreenstoneMETSPlug,
    708737              // unless they are in systems mode or above
    709738              int mode = Configuration.getMode();

  • gli/branches/rtl-gli/src/org/greenstone/gatherer/cdm/SearchMetadataManager.java

    r13057 r18352  
    3333import org.greenstone.gatherer.Configuration;
    3434import org.greenstone.gatherer.Dictionary;
     35import org.greenstone.gatherer.Gatherer;
    3536import org.greenstone.gatherer.gui.DesignPaneHeader;
    3637import org.greenstone.gatherer.util.StaticStrings;
    … …  
    182183   
    183184    public String getMetaID() {
    184         return StaticStrings.STOP_CHARACTER+id;
     185      if (Gatherer.GS3) {
     186        // we don't use any dots in gs3
     187        return id;
     188      }
     189      return StaticStrings.STOP_CHARACTER+id;
     190     
    185191    }
    186192    public String getValue() {
Note: See TracChangeset for help on using the changeset viewer.