Changeset 6336

Timestamp:

Oct 28, 2013, 12:57:45 PM (10 years ago)

Author:

Nicklas Nordborg

Message:

Fixes #1774: Independent sort direction for columns when sorting on multiple colums

Location:

trunk

Files:

• doc/src/docbook/appendix/incompatible.xml (modified) (1 diff)
• src/clients/web/net/sf/basedb/clients/web/taglib/table/ColumnDef.java (modified) (2 diffs)
• src/clients/web/net/sf/basedb/clients/web/taglib/table/Table.java (modified) (3 diffs)
• src/core/net/sf/basedb/core/ItemContext.java (modified) (11 diffs)
• www/include/scripts/table.js (modified) (1 diff)

trunk/doc/src/docbook/appendix/incompatible.xml

@@ -45 +45 @@
       that expect the parent chain of biomaterials to always be fully initialized
       without explicitely having told the BASE core to do so.
+    </para>
+    
+    <bridgehead>Tables can have columns with different sort order</bridgehead>
+    <para>
+      A new feature has been implemented which allows columns in a table to
+      have different sort order. This is implemented by allowing '+' or '-'
+      as a prefix to properties returned by the <methodname>ItemContext.getSortProperty()</methodname>
+      method. Properties without a prefix still use the global sort order as returned
+      by <methodname>ItemContext.getSortDirection()</methodname>.
+    </para>
+    
+    <para>
+      Code that is not aware of the prefixes may fail since '+' and '-' are not
+      allowed in property names.
     </para>
   </sect1>

trunk/src/clients/web/net/sf/basedb/clients/web/taglib/table/ColumnDef.java

@@ -679 +679 @@
         else
         {
-          boolean sortOnThis = table.isSortedby(getSortproperty());
-          String image = sortOnThis ? table.getDirectionImage() : "";
-          ItemContext.SortDirection direction = sortOnThis ? table.getReverseDirection() : table.getDirection();
+          // Current sort direction
+          ItemContext.SortDirection sortDirection = table.getSortDirection(getSortproperty());
+          String image = table.getDirectionImage(sortDirection);
+          
+          // Next sort direction if clicking on this column
+          ItemContext.SortDirection nextDirection = 
+              sortDirection == null ? table.getDirection() : sortDirection.getReverseDirection();
+
           String theTooltip = getTooltip() != null ? 
             getTooltip() : "Sort by "+getTitle() + "; hold CTRL, ALT or SHIFT to sort by multiple columns";
@@ -687 +692 @@
           sb.append(" id=\"").append(idPrefix).append(".sort\"");
           sb.append(" data-sort-property=\"").append(HTML.encodeTags(getSortproperty())).append("\"");
-          sb.append(" data-sort-direction=\"").append(direction.name()).append("\"");
+          sb.append(" data-sort-direction=\"").append(nextDirection.name()).append("\"");
           sb.append(" title=\"").append(theTooltip).append("\">");
           sb.append(getTitle()).append("</span>").append(image);

trunk/src/clients/web/net/sf/basedb/clients/web/taglib/table/Table.java

@@ -229 +229 @@
   */
   private String sortby = null;
-  private Set<String> sortbyMultiple = null;
+  private Map<String, ItemContext.SortDirection> sortColumns = null;
   
   private String action = null;
@@ -313 +313 @@
   {
     this.sortby = sortby;
-    if (sortby != null) sortbyMultiple = new HashSet<String>(Arrays.asList(sortby.split(",")));
+    if (sortby != null) 
+    {
+      sortColumns = new HashMap<String, ItemContext.SortDirection>();
+      for (String col : sortby.split(","))
+      {
+        if (col.startsWith("-"))
+        {
+          sortColumns.put(col.substring(1), ItemContext.SortDirection.DESC);
+        }
+        else if (col.startsWith("+"))
+        {
+          sortColumns.put(col.substring(1), ItemContext.SortDirection.ASC);
+        }
+        else
+        {
+          sortColumns.put(col, null); // NOTE! Default direction may not be set yet
+        }
+      }
+    }
   }
   public String getSortby()
@@ -467 +485 @@
     return visibleColumns.size();
   }
-  boolean isSortedby(String sortcolumn)
-  {
-    return (sortbyMultiple != null) && sortbyMultiple.contains(sortcolumn);
-  }
-  ItemContext.SortDirection getReverseDirection()
-  {
-    return sortDirection == ItemContext.SortDirection.ASC ? ItemContext.SortDirection.DESC : ItemContext.SortDirection.ASC;
-  }
-  String getDirectionImage()
-  {
-    return "<img src=\""+getPage().getRoot()+"images/" + 
-      (sortDirection == ItemContext.SortDirection.ASC ? "sort_asc.png" : "sort_desc.png") +
-      "\" alt=\"" + (sortDirection == ItemContext.SortDirection.ASC ? "▼" : "▲") + "\">";
+  /**
+    Get the sort direction on the given column. If it is not
+    used for sorting, null is returned.
+    @since 3.3
+  */
+  ItemContext.SortDirection getSortDirection(String colum)
+  {
+    ItemContext.SortDirection direction = null;
+    if (sortColumns != null && sortColumns.containsKey(colum))
+    {
+      direction = sortColumns.get(colum);
+      if (direction == null) direction = getDirection();
+    }
+    return direction;
+  }
+  
+  /**
+    Get sort direction <img> element for the given direction.
+    Return an empty string if direction = null.
+    @since 3.3
+  */
+  String getDirectionImage(ItemContext.SortDirection direction)
+  {
+    String image = "";
+    if (direction != null)
+    {
+      image = "<img src=\""+getPage().getRoot()+"images/" + 
+          (direction == ItemContext.SortDirection.ASC ? "sort_asc.png" : "sort_desc.png") +
+          "\" alt=\"" + (direction == ItemContext.SortDirection.ASC ? "▼" : "▲") + "\">";
+    }
+    return image;
   }
 

trunk/src/core/net/sf/basedb/core/ItemContext.java

@@ -382 +382 @@
     Get the name of the property the current listing is sorted by.
     If multiple properties are used for sorting they are separated by a comma.
+    Each property may also be prefixed by a '+' or '-' to override the
+    global sort direction.
   */
   public String getSortProperty()
@@ -391 +393 @@
     Set the name of the property that the current listing is sorted by.
     If you want to sort by multiple properties, separate them with a 
-    comma.
+    comma. By default, each property uses the same sort direction ({@link #getSortDirection()},
+    but this can be overridden by using '+' or '-' as a prefix for
+    a property.
     This property is stored in the database.
     @param sortProperty The name of the property
@@ -434 +438 @@
       String sortProperty = sp[0];
       String alias = null;
+      SortDirection sortDirection = getSortDirection();
+      
+      if (sortProperty.startsWith("+"))
+      {
+        sortDirection = SortDirection.ASC;
+        sortProperty = sortProperty.substring(1);
+      }
+      else if (sortProperty.startsWith("-"))
+      {
+        sortDirection = SortDirection.DESC;
+        sortProperty = sortProperty.substring(1);
+      }
       if (sortProperty.startsWith("$"))
       {
@@ -452 +468 @@
       }
       Expression hqlSortby = Hql.property(alias, sortProperty);
-      sortOrder = (SortDirection.ASC == getSortDirection() ? Orders.asc(hqlSortby) : Orders.desc(hqlSortby));
+      sortOrder = sortDirection.sortBy(hqlSortby);
     }
     return sortOrder;
@@ -1176 +1192 @@
       sign it is interpreted as a <code>alias.property</code> value, ignoring
       the root alias of the query. The sort property may contain multiple properties
-      if they are separated by a comma.
+      if they are separated by a comma. Each property may also be prefixed by
+      a '+' (ASC) or '-' (DESC) to override the global sort direction.
       
     <li>{@link #getInclude()} is used to set {@link EntityQuery#include(Include[])}
@@ -1216 +1233 @@
         if (propertyInspector == null || propertyInspector.evaluate(sortProperty))
         {
+          SortDirection sortDirection = getSortDirection();
+          
           Expression hqlSortby = null;
           String alias = null;
+          
+          // Check if sort direction has been overridden
+          if (sortProperty.startsWith("-"))
+          {
+            sortDirection = SortDirection.DESC;
+            sortProperty = sortProperty.substring(1);
+          }
+          else if (sortProperty.startsWith("+"))
+          {
+            sortDirection = SortDirection.ASC;
+            sortProperty = sortProperty.substring(1);
+          }
+          
           // Extract the 'alias' part if there is one
           if (sortProperty.startsWith("$"))
@@ -1261 +1293 @@
           if (hqlSortby != null)
           {
-            query.order(SortDirection.ASC == getSortDirection() ? Orders.asc(hqlSortby) : Orders.desc(hqlSortby));
+            query.order(sortDirection.sortBy(hqlSortby));
           }
         }
@@ -1477 +1509 @@
         if (propertyInspector == null || propertyInspector.evaluate(sortProperty))
         {
+          SortDirection sortDirection = getSortDirection();
+          
+          // Check if sort direction has been overridden
+          if (sortProperty.startsWith("-"))
+          {
+            sortDirection = SortDirection.DESC;
+            sortProperty = sortProperty.substring(1);
+          }
+          else if (sortProperty.startsWith("+"))
+          {
+            sortDirection = SortDirection.ASC;
+            sortProperty = sortProperty.substring(1);
+          }
+
           Expression sortby = getDynamicExpression(dc, sortProperty);
           if (sortby != null)
           {
-            query.order(SortDirection.ASC == getSortDirection() ? Orders.asc(sortby) : Orders.desc(sortby));
+            query.order(sortDirection.sortBy(sortby));
             if (selectionList == null || !selectionList.contains(sortProperty))
             {
@@ -1708 +1754 @@
         return Orders.asc(e);
       }
+      @Override
+      public SortDirection getReverseDirection()
+      {
+        return DESC;
+      }
     },
     
@@ -1719 +1770 @@
       {
         return Orders.desc(e);
+      }
+      @Override
+      public SortDirection getReverseDirection()
+      {
+        return ASC;
       }
     };
@@ -1779 +1835 @@
     public abstract Order sortBy(Expression e);
     
+    /**
+      Get the reverse sort direction.
+      @since 3.3
+    */
+    public abstract SortDirection getReverseDirection();
+    
     @Override
     public String toString()

trunk/www/include/scripts/table.js

@@ -151 +151 @@
     var tableId = Data.get(column, 'table-id');
     var frm = document.forms[tableId];
-    
-    if (frm.sortby.value != sortProperty || frm.direction.value != sortDirection)
+    var mainDirection = frm.direction.value;
+    if (frm.sortby.value != sortProperty || mainDirection != sortDirection)
     {
       if (event.altKey || event.ctrlKey || event.shiftKey) 
       {
         // Append the current sort property to the list of already sorted columns
-        // First, if the sort property is already used we remove it
+        // If the sort property is already used we keep it, but use the new sort direction
         var sortArray = frm.sortby.value.split(',');
         var index = sortArray.indexOf(sortProperty);
-        if (index >= 0) sortArray.splice(index, 1);
+        // Check for '+' and '-' prefix if the sort order is different from main direction
+        if (index == -1) index = sortArray.indexOf('+'+sortProperty);
+        if (index == -1) index = sortArray.indexOf('-'+sortProperty);
+        // Currently not sorted, insert at end
+        if (index == -1) index = sortArray.length;
         // Add the sort property as the last property
-        sortArray[sortArray.length] = sortProperty;
+        if (sortDirection != mainDirection)
+        {
+          sortProperty = (sortDirection == 'ASC' ? '+' : '-') + sortProperty;
+          sortDirection = mainDirection;
+        }
+        sortArray[index] = sortProperty;
         sortProperty = sortArray.join(',');
       }