Index: /trunk/gsdl/perllib/classify/GenericList.pm
===================================================================
--- /trunk/gsdl/perllib/classify/GenericList.pm	(revision 10497)
+++ /trunk/gsdl/perllib/classify/GenericList.pm	(revision 10498)
@@ -55,21 +55,21 @@
 
       # The interesting options
-      { 'name' => "alwaysgrouplastelement",
-	'desc' => "{GenericList.alwaysgrouplastelement}",
-	'type' => "string" },
-      { 'name' => "hlistgrouptype",
-	'desc' => "{GenericList.hlistgrouptype}",
+      { 'name' => "always_bookshelf_last_level",
+	'desc' => "{GenericList.always_bookshelf_last_level}",
+	'type' => "flag" },
+      { 'name' => "classify_sections",
+	'desc' => "{GenericList.classify_sections}",
+	'type' => "flag" },
+      { 'name' => "partition_type_within_level",
+	'desc' => "{GenericList.partition_type_within_level}",
 	'type' => "string",
 	'deft' => "none" },
-      { 'name' => "hlistgroupsize",
-	'desc' => "{GenericList.hlistgroupsize}",
+      { 'name' => "partition_size_within_level",
+	'desc' => "{GenericList.partition_size_within_level}",
 	'type' => "string" },
-      { 'name' => "leafnodesort",
-	'desc' => "{GenericList.leafnodesort}",
+      { 'name' => "sort_leaf_nodes_using",
+	'desc' => "{GenericList.sort_leaf_nodes_using}",
 	'type' => "metadata",
-	'deft' => "Title" },
-      { 'name' => "classify_sections",
-	'desc' => "{GenericList.classify_sections}",
-	'type' => "flag" } ];
+	'deft' => "Title" } ];
 
 my $options = { 'name'     => "GenericList",
@@ -98,7 +98,7 @@
     my $metadata = $self->{'metadata'};
     my $buttonname = $self->{'buttonname'};
-    my $hlistgrouptype = $self->{'hlistgrouptype'};
-    my $hlistgroupsize = $self->{'hlistgroupsize'};
-    my $leafnodesort = $self->{'leafnodesort'};
+    my $partition_type_within_level = $self->{'partition_type_within_level'};
+    my $partition_size_within_level = $self->{'partition_size_within_level'};
+    my $sort_leaf_nodes_using = $self->{'sort_leaf_nodes_using'};
 
     # The metadata elements to use (required)
@@ -120,37 +120,37 @@
     # Whether to group single items into a bookshelf (must be true for all metadata fields except the last)
     foreach my $metagroup (@metalist) {
-	$self->{$metagroup . ".alwaysgroup"} = "t";
-    }
-    if (!$self->{'alwaysgrouplastelement'}) {
+	$self->{$metagroup . ".always_bookshelf"} = "t";
+    }
+    if (!$self->{'always_bookshelf_last_level'}) {
 	# Default: leave leafnodes ungrouped (equivalent to AZCompactList -mingroup 2)
 	my $lastmetagroup = $metalist[$#metalist];
-	$self->{$lastmetagroup . ".alwaysgroup"} = "f";
+	$self->{$lastmetagroup . ".always_bookshelf"} = "f";
     }
 
     # How the items are grouped into hlists
-    if (!$hlistgrouptype) {
+    if (!$partition_type_within_level) {
 	# Default: none
-	$hlistgrouptype = "none";
-    }
-    $self->{"hlistgrouptype"} = $hlistgrouptype;
+	$partition_type_within_level = "none";
+    }
+    $self->{"partition_type_within_level"} = $partition_type_within_level;
 
     # The number of items in each group
-    if (!$hlistgroupsize) {
+    if (!$partition_size_within_level) {
 	# Default: 20
 	foreach my $metagroup (@metalist) {
-	    $self->{$metagroup . ".hlistgroupsize"} = 20;
+	    $self->{$metagroup . ".partition_size_within_level"} = 20;
 	}
     }
     else {
-	my @hlistgroupsizelist = split(/\//, $hlistgroupsize);
-
-	# Assign values based on the hlistgroupsize parameter
+	my @partition_size_within_levellist = split(/\//, $partition_size_within_level);
+
+	# Assign values based on the partition_size_within_level parameter
 	foreach my $metagroup (@metalist) {
-	    my $hlistgroupsizeelem = shift(@hlistgroupsizelist);
-	    if (defined($hlistgroupsizeelem)) {
-		$self->{$metagroup . ".hlistgroupsize"} = $hlistgroupsizeelem;
+	    my $partition_size_within_levelelem = shift(@partition_size_within_levellist);
+	    if (defined($partition_size_within_levelelem)) {
+		$self->{$metagroup . ".partition_size_within_level"} = $partition_size_within_levelelem;
 	    }
 	    else {
-		$self->{$metagroup . ".hlistgroupsize"} = $self->{$metalist[0] . ".hlistgroupsize"};
+		$self->{$metagroup . ".partition_size_within_level"} = $self->{$metalist[0] . ".partition_size_within_level"};
 	    }
 	}
@@ -158,9 +158,9 @@
 
     # The metadata elements to use to sort the leaf nodes
-    my @leafnodesortmetalist = ( "Title" );
-    if ($leafnodesort) {
-	@leafnodesortmetalist = split(/\;/, $leafnodesort);
-    }
-    $self->{'leafnodesortmetalist'} = \@leafnodesortmetalist;
+    my @sort_leaf_nodes_usingmetalist = ( "Title" );
+    if ($sort_leaf_nodes_using) {
+	@sort_leaf_nodes_usingmetalist = split(/\;/, $sort_leaf_nodes_using);
+    }
+    $self->{'sort_leaf_nodes_usingmetalist'} = \@sort_leaf_nodes_usingmetalist;
 
     return bless $self, $class;
@@ -211,5 +211,5 @@
 	    # Create a hash for the metadata values of each metadata element we're interested in
 	    my %metagroupsdone = ();
-	    foreach my $metagroup (@metalist, @{$self->{'leafnodesortmetalist'}}) {
+	    foreach my $metagroup (@metalist, @{$self->{'sort_leaf_nodes_usingmetalist'}}) {
 		# Take care not to do a metadata group more than once
 		unless ($metagroupsdone{$metagroup}) {
@@ -283,6 +283,6 @@
 
     # Partition the values (if necessary)
-    my $hlistgrouptype = $self->{"hlistgrouptype"};
-    if ($hlistgrouptype =~ /^perletter$/i) {
+    my $partition_type_within_level = $self->{"partition_type_within_level"};
+    if ($partition_type_within_level =~ /^per_letter$/i) {
 	# Generate one hlist for each letter
 	my @sortedmetavalues = sort(keys %metavaluetoOIDhash);
@@ -312,6 +312,6 @@
     else {
 	# Generate hlists of a certain size
-	my $hlistgroupsize = $self->{$metagroup . ".hlistgroupsize"};
-	if ($hlistgrouptype =~ /^constantsize$/i && scalar(keys %metavaluetoOIDhash) > $hlistgroupsize) {
+	my $partition_size_within_level = $self->{$metagroup . ".partition_size_within_level"};
+	if ($partition_type_within_level =~ /^constant_size$/i && scalar(keys %metavaluetoOIDhash) > $partition_size_within_level) {
 	    my @sortedmetavalues = sort(keys %metavaluetoOIDhash);
 	    my $itemsdone = 0;
@@ -330,5 +330,5 @@
 
 		# Is this the end of the partition?
-		if ($itemsinpartition == $hlistgroupsize || $itemsdone == @sortedmetavalues) {
+		if ($itemsinpartition == $partition_size_within_level || $itemsdone == @sortedmetavalues) {
 		    my $partitionend = &generate_partition_end($metavalue, $partitionstart);
 		    my $partitionname = $partitionstart;
@@ -436,6 +436,6 @@
 	my @OIDlist = @{$metavaluetoOIDhash{$metavalue}};
 
-	# If there is only one item and 'alwaysgroup' is false, add the item to the list
-	if (@OIDlist == 1 && $self->{$metagroup . ".alwaysgroup"} eq "f") {
+	# If there is only one item and 'always_bookshelf' is false, add the item to the list
+	if (@OIDlist == 1 && $self->{$metagroup . ".always_bookshelf"} eq "f") {
 	    push(@{$classifyinfo->{'contains'}}, { 'OID' => $OIDlist[0] });
 	}
@@ -453,8 +453,8 @@
 	    # Otherwise just add the documents as children of this list
 	    else {
-		# Sort the leaf nodes by the metadata elements specified with -leafnodesort
-		my @leafnodesortmetalist = @{$self->{'leafnodesortmetalist'}};
-		foreach my $leafnodesortmetaelem (reverse @leafnodesortmetalist) {
-		    my %OIDtometavaluehash = %{$self->{$leafnodesortmetaelem . ".list"}};
+		# Sort the leaf nodes by the metadata elements specified with -sort_leaf_nodes_using
+		my @sort_leaf_nodes_usingmetalist = @{$self->{'sort_leaf_nodes_usingmetalist'}};
+		foreach my $sort_leaf_nodes_usingmetaelem (reverse @sort_leaf_nodes_usingmetalist) {
+		    my %OIDtometavaluehash = %{$self->{$sort_leaf_nodes_usingmetaelem . ".list"}};
 		    # Force a stable sort (Perl 5.6's sort isn't stable)
 		    # !! The [0] bits aren't ideal (multiple metadata values) !! 
Index: /trunk/gsdl/perllib/strings.rb
===================================================================
--- /trunk/gsdl/perllib/strings.rb	(revision 10497)
+++ /trunk/gsdl/perllib/strings.rb	(revision 10498)
@@ -434,10 +434,10 @@
 DateList.sort:An extra metadata field to sort by in the case where two documents have the same date.
 
-GenericList.alwaysgrouplastelement:Create a bookshelf icon even if there is only one item in each group at the leaf nodes.
+GenericList.always_bookshelf_last_level:Create a bookshelf icon even if there is only one item in each group at the leaf nodes.
 GenericList.classify_sections:Classify sections instead of documents.
 GenericList.desc:A general and flexible list classifier with most of the abilities of AZCompactList, but with better Unicode, metadata and sorting capabilities.
-GenericList.hlistgroupsize:The number of items in each hlist group (constantsize hlistgrouptype only).
-GenericList.hlistgrouptype:The type of hlist grouping done: either perletter, constantsize, or none.
-GenericList.leafnodesort:Metadata fields used for sorting the leaf nodes. Use ';' to separate the metadata groups to stable sort and ',' to separate metadata fields within each group.
+GenericList.partition_size_within_level:The number of items in each partition (only applies when partition_type_within_level is set to 'constant_size').
+GenericList.partition_type_within_level:The type of partitioning done: either 'per_letter', 'constant_size', or 'none'.
+GenericList.sort_leaf_nodes_using:Metadata fields used for sorting the leaf nodes. Use ';' to separate the metadata groups to stable sort and ',' to separate metadata fields within each group.
 GenericList.metadata:Metadata fields used for classification. Use '/' to separate the levels in the hierarchy and ',' to separate metadata fields within each level.
 
