Changeset 8083

trunk

Property svn:mergeinfo changed
/branches/3.19-stable merged: 8044,8046-8080
/tags/3.19.4 (added) merged: 8081

trunk/doc/src/docbook/user/webclient.xml

-                      r7982
+                      r8083
         <variablelist>
         <varlistentry>
           <term><guilabel>Item type</guilabel></term>
+          <term><guilabel>Parent/child</guilabel></term>
           <listitem>
             <para>
 …
             <para>
               This list will automatically be updated with all available subtypes
               for the selected main item type. It is not possible to select items
               without a subtype.
+              for the selected parent or child item type. It is not possible to select
+              items without a subtype.
             </para>
           </listitem>
         </varlistentry>
         <varlistentry>
+          <term><guilabel>Column</guilabel></term>
+          <listitem>
+            <para>
+              Once the subtype has been selected, this list will display all possible
+              columns that can be added to the table. Most regular properties such as
+          <term><guilabel>with link to</guilabel></term>
+          <listitem>
+            <para>
+              This is an optional selection that is only available if a parent item type has
+              been selected in the left list. In this list is possible to select
+              an item type that should be a child type of the selected parent type.
+              A subtype for the child item must also be selected.
+            </para>
+          </listitem>
+        </varlistentry>
+        <varlistentry>
+          <term><guilabel>Columns/Annotations/Extensions</guilabel></term>
+          <listitem>
+            <para>
+              When the parent/child selection contains a valid combination,
+              the table will display all possible columns that can be selected
+              and added to the table. Most regular properties such as
               <guilabel>Name</guilabel> and <guilabel>Registration date</guilabel>
+              can be selected, as well as all annotation types that has been defined
+              and linked to the selected subtype (marked with <guilabel>[A]</guilabel>).
+              can be selected and are displayed in the <guilabel>Columns</guilabel>
+              column. All annotation types that has been defined and linked to the
+              selected subtype are displayed in the <guilabel>Annotations</guilabel>
+              column. It is also possible for external extensions to add more columns
+              that can be selected in the <guilabel>Extensions</guilabel> column.
             </para>
           </listitem>
 …
           <para>
             Use the <guibutton>Add</guibutton> button to add columns to the table.
             It is possible change the main item type and subtype to add more columns.
             When you are done, use the &gbClose; button to close the dialog.
+            It is possible change the parent/child item type and subtype to add more
+            columns. When you are done, use the &gbClose; button to close the dialog.
           </para>

trunk/src/clients/web/net/sf/basedb/clients/web/Base.java

-                      r7982
+                      r8083
 import net.sf.basedb.core.Platform;
 import net.sf.basedb.core.PlatformVariant;
+import net.sf.basedb.core.Project;
 import net.sf.basedb.core.Protocol;
 import net.sf.basedb.core.ReporterList;
 …
           cc.getSelected().add(Values.getInt(itemId));
+        }
-        String allColumns = cc.getSetting("columns");
-        Set<String> visibleParentCols = new HashSet<>();
-        if (allColumns != null)
+        {
-          for (String col : allColumns.split(","))
+          {
-            if (col.startsWith("/")) visibleParentCols.add(col);
+          }
+        }
         while (names.hasMoreElements())
 …
               property = property.substring(0, split);
+            }
-            if (property.startsWith("/") && value != null)
+            {
-              // If the filter is on a parent item and the column is no
-              // longer visible, we need to remove the filter, since it
-              // will get very confusing otherwise
-              // There are some variants when column is the name of a parent item
-              boolean isOkFilter = visibleParentCols.contains(property)
-                || visibleParentCols.contains(property.replace("/name", "/."))
-                || visibleParentCols.contains(property.replace(".name", ""));
-              if (!isOkFilter) value = null;
+            }
             if (value != null)
+            {
 …
     // Modified annotations
     String modified = Values.getStringOrNull(request.getParameter("modifiedAnnotations"));
+    int projectId = Values.getInt(request.getParameter("project_id"), -1);
+    Project project = projectId > 0 ? Project.getById(dc, projectId) : null;
     if (newItem == null) newItem = oldItem;
     if (modified != null)
 …
         if (annotationId != null)
+        {
           a = Annotation.getById(dc, annotationId.intValue());
+          a = Annotation.getById(dc, annotationId.intValue(), projectId >= 0);
           if ("DELETE".equals(modifyType))
 …
             if (source == Annotation.Source.PRIMARY)
+            {
+              newAs.removeAnnotation(at);
+              if (projectId >= 0)
+              {
+                newAs.removeProjectAnnotation(at, project);
+              }
+              else
+              {
+                newAs.removeAnnotation(at);
+              }
+            }
             else
 …
           if (!"DELETE".equals(modifyType))
+          {
             a = newAs.getAnnotation(at);
+            a = projectId >= 0 ? newAs.getProjectAnnotation(at, project) : newAs.getAnnotation(at);
+          }
+        }

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/JspContext.java

-                      r8045
+                      r8083
   /**
+    Add several scripts in one go. If the collection is null or empty
+    nothing is done.
+    @since 3.19.4
+  */
+  public void addScripts(Collection<String> scriptsToAdd)
+  {
+    if (scriptsToAdd == null || scriptsToAdd.isEmpty()) return;
+    if (scripts == null) scripts = new HashMap<>();
+    getSet(scripts, null).addAll(scriptsToAdd);
+    if (needResourcesPerExtension)
+    {
+      getSet(scripts, getCurrentExtension().getId()).addAll(scriptsToAdd);
+    }
+  }
+  /**
     Get the Set that is stored under the given key. If
     no Set exists it is created and stored in the map.
 …
+    }
+  }
+  /**
+    Add several stylesheets in one go. If the collection is null or empty
+    nothing is done.
+    @since 3.19.4
+  */
+  public void addStylesheets(Collection<String> stylesheetsToAdd)
+  {
+    if (stylesheetsToAdd == null || stylesheetsToAdd.isEmpty()) return;
+    if (stylesheets == null) stylesheets = new HashMap<>();
+    getSet(stylesheets, null).addAll(stylesheetsToAdd);
+    if (needResourcesPerExtension)
+    {
+      getSet(stylesheets, getCurrentExtension().getId()).addAll(stylesheetsToAdd);
+    }
+  }
   /**

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/AbstractListColumnBean.java

-                      r7908
+                      r8083
 */
 package net.sf.basedb.clients.web.extensions.list;
+import java.util.Collection;
 import net.sf.basedb.core.DbControl;
 …
   private Enumeration<String, String> enumeration;
   private Formatter<? super V> formatter;
+  private Formatter<Collection<? super V>> collectionFormatter;
   public AbstractListColumnBean()
 …
+  {
     this.exportFormatter = exportFormatter;
+  }
+  @Override
+  public Formatter<Collection<? super V>> getCollectionFormatter()
+  {
+    return collectionFormatter == null ? ListColumnAction.super.getCollectionFormatter() : collectionFormatter;
+  }
+  public void setCollectionFormatter(Formatter<Collection<? super V>> collectionFormatter)
+  {
+    this.collectionFormatter = collectionFormatter;
+  }

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/AnyLinkColumnActionFactory.java

-                      r7874
+                      r8083
 import net.sf.basedb.clients.web.extensions.fileviewer.FileViewerContext;
 import net.sf.basedb.clients.web.extensions.fileviewer.FileViewerUtil;
+import net.sf.basedb.clients.web.extensions.list.RelatedItemColumn.Specification;
 import net.sf.basedb.core.BasicItem;
 import net.sf.basedb.core.DbControl;
 …
     String subContext = Values.getString(guiContext.getSubContext(), "");
+    ItemContext cc = sc.getCurrentContext(item, subContext, null);
+    if (cc == null) return false;
+    String allColumns = cc.getSetting("columns");
+    String allColumns = null;
+    if (RelatedItemExtensionColumn.SUBCONTEXT.equals(subContext))
+    {
+      // The current item should be a Specification instance that may specify
+      // the column. Otherwise we load the columns from the regular list context
+      // which makes it possible to select linked item columns from a parent/child
+      // that are currently available
+      Specification spec = jspContext.getCurrentItem();
+      if (spec != null) allColumns = spec.actionId;
+      subContext = "";
+    }
+    if (allColumns == null)
+    {
+      ItemContext cc = sc.getCurrentContext(item, subContext, null);
+      if (cc == null) return false;
+      allColumns = cc.getSetting("columns");
+    }
     if (allColumns == null || !allColumns.contains("|")) return false;
 …
     Item item = guiContext.getItem();
     String subContext = Values.getString(guiContext.getSubContext(), "");
+    ItemContext cc = sc.getCurrentContext(item, subContext, null);
+    if (cc == null) return null;
+    String allColumns = cc.getSetting("columns");
+    String allColumns = null;
+    if (RelatedItemExtensionColumn.SUBCONTEXT.equals(subContext))
+    {
+      // The current item should be a Specification instance that may specify
+      // the column. Otherwise we load the columns from the regular list context
+      Specification spec = jspContext.getCurrentItem();
+      if (spec != null) allColumns = spec.actionId;
+      subContext = "";
+    }
+    if (allColumns == null)
+    {
+      ItemContext cc = sc.getCurrentContext(item, subContext, null);
+      if (cc == null) return null;
+      allColumns = cc.getSetting("columns");
+    }
     if (allColumns == null || !allColumns.contains("|")) return null;

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/ListColumnAction.java

-                      r7908
+                      r8083
 package net.sf.basedb.clients.web.extensions.list;
+import java.util.Collection;
 import net.sf.basedb.core.DbControl;
 import net.sf.basedb.core.Type;
 import net.sf.basedb.util.Enumeration;
 import net.sf.basedb.util.extensions.Action;
+import net.sf.basedb.util.formatter.CollectionFormatter;
 import net.sf.basedb.util.formatter.Formatter;
 …
   /**
+    Get a formatter that is intended to format a collection of values
+    that have been retrieved from this action. The default implementation
+    will return a formatter that creates a comma-separated string of
+    the individual values where each value is formatted with the formatter
+    from {@link #getFormatter()}.
+    @since 3.19.4
+  */
+  @SuppressWarnings({ "rawtypes", "unchecked" })
+  public default Formatter<Collection<? super V>> getCollectionFormatter()
+  {
+    return new CollectionFormatter(getFormatter());
+  }
+  /**
     Get the value that should be displayed in the column. This method is
     called once for every item that is listed in the table. The returned

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/ListColumnUtil.java

-                      r7605
+                      r8083
 import net.sf.basedb.core.plugin.GuiContext;
 import net.sf.basedb.util.extensions.ExtensionPointBean;
+import net.sf.basedb.util.extensions.ExtensionsFilter;
 import net.sf.basedb.util.extensions.ExtensionsInvoker;
 import net.sf.basedb.util.extensions.Registry;
 …
   /**
+    @see #useExtensions(JspContext, ExtensionsFilter)
+  */
+  public static <I> ExtensionsInvoker<ListColumnAction<I, ?>> useExtensions(JspContext jspContext)
+  {
+    return useExtensions(jspContext, null);
+  }
+  /**
     Use list column extensions for a given gui context. This method
     will assemble all specific and generic extension points and
+    then call {@link ExtensionsControl#useExtensions(JspContext, String...)}.
+    then call {@link ExtensionsControl#useExtensions(JspContext, ExtensionsFilter, String...)}
+    or {@link ExtensionsControl#useExtensions(JspContext, String...)} (if the filter is null)
     @param jspContext The current jsp context
+    @param filter Optional filter for the extensions
     @return An invoker instance
+    @since 3.19.4
   */
   public static <I> ExtensionsInvoker<ListColumnAction<I, ?>> useExtensions(JspContext jspContext)
+  public static <I> ExtensionsInvoker<ListColumnAction<I, ?>> useExtensions(JspContext jspContext, ExtensionsFilter filter)
+  {
     String[] ep = new String[6]; // 6 is the maximum number of extension points
 …
+    }
     ep[index++] = EP_PREFIX + itemType.name().toLowerCase();
     return ExtensionsControl.useExtensions(jspContext, ep);
+    return filter == null ? ExtensionsControl.useExtensions(jspContext, ep) : ExtensionsControl.useExtensions(jspContext, filter, ep);
+  }

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemAnnotationColumn.java

-                      r7893
+                      r8083
 import java.util.Set;
+import net.sf.basedb.clients.web.formatter.FormatterFactory;
 import net.sf.basedb.clients.web.util.HTML;
 import net.sf.basedb.core.Annotatable;
 import net.sf.basedb.core.AnnotationType;
+import net.sf.basedb.core.Item;
+import net.sf.basedb.core.SyncFilter.SourceItemTransform;
+import net.sf.basedb.core.query.Restriction;
+import net.sf.basedb.core.DbControl;
 import net.sf.basedb.core.snapshot.AnnotationSnapshot;
 import net.sf.basedb.core.snapshot.AnnotationTypeFilter;
 import net.sf.basedb.util.Enumeration;
 import net.sf.basedb.util.filter.Filter;
+import net.sf.basedb.util.formatter.CollectionFormatter;
+import net.sf.basedb.util.listable.SourceItemTransformer;
 /**
 …
   private final Filter<AnnotationSnapshot> atFilter;
+  RelatedItemAnnotationColumn(int index, String id, Item sourceType, Item targetType, SourceItemTransform direction, Restriction targetRestriction, RelatedItemHelper helper, AnnotationType at)
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  RelatedItemAnnotationColumn(DbControl dc, int index, Specification spec, RelatedItemHelper helper, AnnotationType at)
+  {
     super(index, id, sourceType, targetType, direction, targetRestriction, helper);
+    super(dc, index, spec, helper);
     this.at = at;
     this.atFilter = new AnnotationTypeFilter(at);
+    setTitle(spec.generateTitle(at.getName() + " [A]"));
+    setTooltip(spec.generateTooltip(at.getName()));
+    setValueType(at.getValueType());
+    setExportFormatter(FormatterFactory.getTypeFormatter(dc.getSessionControl(), at.getValueType()));
+    if (!helper.lazy) setFormatter(new CollectionFormatter(getExportFormatter()));
     if (at.isEnumeration())
+    {
 …
   @Override
   public Object getValue(RelatedItemHelper helper, Annotatable item)
+  public Object getValue(RelatedItemHelper helper, Annotatable item, SourceItemTransformer preTransform)
+  {
     Set<Annotatable> items = getRelatedItems(item);
+    Set<Annotatable> items = getRelatedItems(item, preTransform);
     if (items.size() == 0) return null;

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemColumn.java

-                      r7893
+                      r8083
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
-import net.sf.basedb.clients.web.Base;
-import net.sf.basedb.clients.web.formatter.FormatterFactory;
-import net.sf.basedb.clients.web.formatter.LinkedItemFormatter;
 import net.sf.basedb.core.Annotatable;
 import net.sf.basedb.core.AnnotationType;
 …
 import net.sf.basedb.core.Item;
 import net.sf.basedb.core.ItemList;
-import net.sf.basedb.core.ItemQuery;
 import net.sf.basedb.core.ItemSubtype;
 import net.sf.basedb.core.Metadata;
 import net.sf.basedb.core.RawDataTypes;
 import net.sf.basedb.core.Type;
+import net.sf.basedb.core.StringUtil;
 import net.sf.basedb.core.query.Expressions;
 import net.sf.basedb.core.query.Hql;
 …
 import net.sf.basedb.core.RawDataType;
 import net.sf.basedb.core.SyncFilter.SourceItemTransform;
-import net.sf.basedb.util.Enumeration;
 import net.sf.basedb.util.NameableComparator;
 import net.sf.basedb.util.Values;
+import net.sf.basedb.util.extensions.ExtensionsInvoker;
 import net.sf.basedb.util.filter.Filter;
-import net.sf.basedb.util.formatter.CollectionFormatter;
-import net.sf.basedb.util.formatter.NameableFormatter;
-import net.sf.basedb.util.formatter.ToStringFormatter;
 import net.sf.basedb.util.listable.ListableUtil;
 import net.sf.basedb.util.listable.RestrictionTransformer;
 …
   /**
+    For now, we assume that 'expr' is /DIRECTION/ITEMTYPE/subtype-id/#annotationtype-id or
+    For now, we assume that 'expr' is one of:
+    /DIRECTION/ITEMTYPE/subtype-id/#annotationtype-id
+    /DIRECTION/ITEMTYPE/subtype-id/!extension-id#action-id
     /DIRECTION/ITEMTYPE/subtype-id/property
 …
   */
   @SuppressWarnings({ "unchecked", "rawtypes" })
   public static RelatedItemColumn create(DbControl dc, int index, Item sourceType, String expr, RelatedItemHelper helper)
+  public static RelatedItemColumn create(DbControl dc, int index, Specification spec, RelatedItemHelper helper)
+  {
     RelatedItemColumn col = null;
     try
+    {
+      String[] tmp = expr.split("/", 5);
+      SourceItemTransform direction = SourceItemTransform.CHILD_TO_PARENT;
+      int baseIndex = 1;
+      if (tmp.length == 5)
+      {
+        baseIndex = 2;
+        direction = "CHILD".equals(tmp[1]) ? SourceItemTransform.PARENT_TO_CHILD : SourceItemTransform.CHILD_TO_PARENT;
+      }
+      Item targetType = Item.valueOf(tmp[baseIndex]);
+      Filter<? super ItemList> itemListFilter = null;
+      Restriction targetRestriction = null;
+      String subtypeName = null;
+      if (targetType == Item.RAWBIOASSAY)
+      {
+        RawDataType rdt = RawDataTypes.getSafeRawDataType(tmp[baseIndex+1]);
+        subtypeName = rdt.getName();
+        targetRestriction = Restrictions.eq(Hql.property("rawDataType"), Expressions.string(rdt.getId()));
+        itemListFilter = new RawDataTypeFilter(rdt);
+      if (spec.property.startsWith("/"))
+      {
+        // This is a multi-hop path: child --> parent --> child
+        if (spec.direction != SourceItemTransform.CHILD_TO_PARENT)
+        {
+          throw new RuntimeException("First multi-hop must be to /PARENT: " + spec.expression);
+        }
+        Specification nextSpec = Specification.parse(spec.targetType, spec.property);
+        if (nextSpec.property.startsWith("/"))
+        {
+          throw new RuntimeException("More than two PARENT/CHILD hops are not allowed: " + spec.expression);
+        }
+        if (nextSpec.direction != SourceItemTransform.PARENT_TO_CHILD)
+        {
+          throw new RuntimeException("Last multi-hop must be to /CHILD: " + spec.expression);
+        }
+        RelatedItemColumn nextHop = create(dc, index, nextSpec, helper);
+        col = new RelatedItemMultiHopColumn(dc, index, spec, helper, nextHop);
+      }
+      else if (spec.property.startsWith("#"))
+      {
+        AnnotationType at = AnnotationType.getById(dc, spec.annotationId);
+        col = new RelatedItemAnnotationColumn(dc, index, spec, helper, at);
+      }
+      else if (spec.property.startsWith("!"))
+      {
+        ListColumnAction <Annotatable, ?> action = null;
+        // Get the invoker that was saved by the RelatedItemColumnActionFactory.prepareContext() method
+        ExtensionsInvoker<ListColumnAction<Annotatable, ?>> invoker = helper.jspContext.getAttribute("RelatedItemInvoker."+spec.expression);
+        if (invoker != null)
+        {
+          invoker.getClientContext().setCurrentItem(spec);
+          for (ListColumnAction<Annotatable, ?> lca : invoker)
+          {
+            if (spec.actionId.equals(lca.getId()) || spec.actionId.equals(lca.getFilterProperty()))
+            {
+              action = lca;
+              break;
+            }
+          }
+        }
+        if (action == null) throw new RuntimeException("Extension not found: "+Values.getString(spec.extensionId)+"#"+spec.actionId);
+        col = new RelatedItemExtensionColumn(dc, index, spec, helper, action);
+      }
+      else if (spec.property.equals("§itemLists"))
+      {
+        Filter<? super ItemList> itemListFilter = null;
+        if (spec.targetType == Item.RAWBIOASSAY)
+        {
+          itemListFilter = new RawDataTypeFilter(spec.getRawDataType());
+        }
+        else
+        {
+          itemListFilter = new SubtypeFilter(spec.getItemSubtype(dc));
+        }
+        col = new RelatedItemListColumn(dc, index, spec, itemListFilter, helper);
+      }
       else
+      {
-        ItemSubtype subtype = ItemSubtype.getById(dc, Values.getInt(tmp[baseIndex+1]));
-        subtypeName = subtype.getName();
-        targetRestriction = Restrictions.eq(Hql.property("itemSubtype"), Hql.entity(subtype));
-        itemListFilter = new SubtypeFilter(subtype);
+      }
-      String propSpec = tmp[baseIndex+2];
-      if (propSpec.startsWith("#"))
+      {
-        AnnotationType at = AnnotationType.getById(dc, Values.getInt(propSpec.substring(1)));
-        col = new RelatedItemAnnotationColumn(index, expr, sourceType, targetType, direction, targetRestriction, helper, at);
-        col.setTitle(subtypeName+"."+at.getName() + " [A]");
-        col.setTooltip(subtypeName + " › "+at.getName());
-        col.setValueType(at.getValueType());
-        col.setClazz("relateditemcol");
-        col.setExportFormatter(FormatterFactory.getTypeFormatter(dc.getSessionControl(), at.getValueType()));
-        if (!helper.lazy) col.setFormatter(new CollectionFormatter(col.getExportFormatter()));
+      }
-      else if (propSpec.equals("§itemLists"))
+      {
-        col = new RelatedItemListColumn(dc, index, expr, sourceType, targetType, direction, targetRestriction, itemListFilter, helper);
-        col.setTitle(subtypeName+".Item list");
-        col.setValueType(Type.INT);
-        col.setClazz("relateditemcol");
-        col.setExportFormatter(new NameableFormatter());
-        if (!helper.lazy) col.setFormatter(new CollectionFormatter(new LinkedItemFormatter()));
+      }
-      else
+      {
         PropertyPath property = null;
+        if (".".equals(propSpec)) // special case '.' is equal to the "parent" item
+        {
+          col = new RelatedItemPropertyColumn(index, expr, sourceType, targetType, direction, targetRestriction, helper, null);
+          col.setTitle(subtypeName);
+          col.setTooltip(subtypeName);
+        }
+        else
+        {
+          Metadata m = Metadata.getInstance(targetType.getItemClass());
+          property = m.getPropertyPath(propSpec, false);
+          col = new RelatedItemPropertyColumn(index, expr, sourceType, targetType, direction, targetRestriction, helper, property);
+          col.setTitle(subtypeName+"."+pathToTitle(propSpec));
+          col.setTooltip(subtypeName + " › "+propSpec);
+        }
+        col.setClazz("relateditemcol");
+        if (property == null || property.getHibernateType().isEntityType())
+        {
+          col.setExportFormatter(new NameableFormatter());
+          if (!helper.lazy) col.setFormatter(new CollectionFormatter(new LinkedItemFormatter()));
+          if ("job.itemSubtype".equals(propSpec))
+          {
+            ItemQuery<ItemSubtype> jobSubtypesQuery = Base.getSubtypesQuery(Item.JOB);
+            col.setEnumeration(Enumeration.fromItems(jobSubtypesQuery.list(dc), null));
+            col.setValueType(Type.INT);
+          }
+          else
+          {
+            if (col.getFilterProperty()==null)
+            {
+              // Add '.name' to make filtering work
+              String nameProperty = col.getProperty() + ".name";
+              if (nameProperty.contains("/..")) nameProperty = nameProperty.replace("/..", "/");
+              col.setFilterProperty(nameProperty);
+            }
+            col.setValueType(Type.STRING);
+          }
+        }
+        else
+        {
+          Type colType = Type.fromHibernateType(property.getHibernateType());
+          if (colType != null)
+          {
+            col.setValueType(colType);
+            col.setExportFormatter(FormatterFactory.getTypeFormatter(dc.getSessionControl(), colType));
+          }
+          else
+          {
+            // Last fallback -- if we get here the Type.fromHibernateType() should be update with special cases
+            col.setValueType(Type.STRING);
+            col.setExportFormatter(new ToStringFormatter<>());
+          }
+          if (!helper.lazy) col.setFormatter(new CollectionFormatter(col.getExportFormatter()));
+        }
+      }
+      col.setClazz(col.getClazz() + (direction == SourceItemTransform.CHILD_TO_PARENT ? " parentitem" : " childitem"));
+      col.setTooltip((direction == SourceItemTransform.CHILD_TO_PARENT ? "Parent › " : "Child › ")+col.getTooltip());
+        if (!".".equals(spec.property)) // special case '.' is equal to the "related" item
+        {
+          Metadata m = Metadata.getInstance(spec.targetType.getItemClass());
+          property = m.getPropertyPath(spec.property, false);
+        }
+        col = new RelatedItemPropertyColumn(dc, index, spec, helper, property);
+      }
+    }
     catch (RuntimeException ex)
+    {
       ex.printStackTrace(System.out);
+    }
+      col = new RelatedItemErrorColumn(index, spec, helper, ex.getMessage());
+    }
     return col;
+  }
-  private static Map<String, String> pathTitles = new HashMap<>();
-  static
+  {
-    // See also add_relateditem_columns.js
-    pathTitles.put("externalId", "External ID");
-    pathTitles.put("bioWell.bioPlate", "Bioplate");
-    pathTitles.put("entryDate", "Registered");
-    pathTitles.put("remainingQuantity", "Remaining quantity");
-    pathTitles.put("originalQuantity", "Original quantity");
-    pathTitles.put("creationEvent.entryDate", "Registration date");
-    pathTitles.put("creationEvent.eventDate", "Creation date");
-    pathTitles.put("creationEvent.protocol", "Protocol");
-    pathTitles.put("creationEvent.hardware", "Hardware");
-    pathTitles.put("protocol", "Protocol");
-    pathTitles.put("hardware", "Hardware");
-    pathTitles.put("software", "Software");
-    pathTitles.put("tag", "Tag");
-    pathTitles.put("job.itemSubtype", "Job type");
-    pathTitles.put("$itemLists", "Item lists");
+  }
-  /**
-    Convert some paths to a more user-friendly title instead.
-  */
-  private static String pathToTitle(String path)
+  {
-    String title = pathTitles.get(path);
-    return title == null ? path.substring(0, 1).toUpperCase() + path.substring(1) : title;
+  }
   private final int index;
+  private final Item sourceType;
+  private final Item targetType;
+  private final Specification spec;
   private final RelatedItemHelper helper;
-  private final SourceItemTransformerFactory transformerFactory;
   private final SourceItemTransformer transformer;
   RelatedItemColumn(int index, String id, Item sourceType, Item targetType, SourceItemTransform direction, Restriction targetRestriction, RelatedItemHelper helper)
+  RelatedItemColumn(DbControl dc, int index, Specification spec, RelatedItemHelper helper)
+  {
     this.index = index;
     this.helper = helper;
+    this.sourceType = sourceType;
+    this.targetType = targetType;
+    this.transformerFactory = ListableUtil.getTransformerFactory(targetType);
+    SourceItemTransformer tmp = transformerFactory.create(sourceType, direction);
+    this.transformer = targetRestriction == null ? tmp : new RestrictionTransformer(tmp, targetRestriction);
+    setId(id);
+    setProperty(id);
+    this.spec = spec;
+    if (dc != null)
+    {
+      SourceItemTransformerFactory transformerFactory = ListableUtil.getTransformerFactory(spec.targetType);
+      SourceItemTransformer tmp = transformerFactory.create(spec.sourceType, spec.direction);
+      Restriction targetRestriction = spec.createTargetTypeRestriction(dc);
+      if (targetRestriction != null) tmp = new RestrictionTransformer(tmp, targetRestriction);
+      this.transformer = tmp;
+    }
+    else
+    {
+      this.transformer = null;
+    }
+    setId(spec.expression);
+    setProperty(spec.expression);
     setExportable(true);
     setFilterable(true);
+  }
+    setClazz("relateditemcol" +
+        (spec.direction == SourceItemTransform.CHILD_TO_PARENT ? " parentitem" : " childitem")+
+        (spec.multiHop ? " multihop" : "")
+        );
+  }
+  /**
+    Is this column lazy-loaded? The default implementation
+    use the requested laza flag from the helper instance.
+    @since 3.19.4
+  */
+  protected boolean isLazy()
+  {
+    return helper.lazy;
+  }
+  /**
+    Get the transformer implementation that is used to turn source item into target items.
+    @since 3.19.4
+  */
+  protected SourceItemTransformer getTransformer()
+  {
+    return transformer;
+  }
   /**
     We finalize this implementation to make sure that the helper
     implementation always get a chance to re-cycle transactions.
     Subclasses should implement {@link #getValue(RelatedItemHelper, Annotatable)}
+    Subclasses should implement {@link #getValue(RelatedItemHelper, Annotatable, SourceItemTransformer)}
     to return the requested value from the item and use the
     DbControl from {@link RelatedItemHelper#dc}.
 …
   public final Object getValue(DbControl dc, Annotatable item)
+  {
     if (helper.lazy) return getProxyTag(item);
+    if (isLazy()) return getProxyTag(item);
     item = helper.recycle(dc, item);
     return getValue(helper, item);
+    return getValue(helper, item, null);
+  }
 …
     We finalize this implementation to make sure that the helper
     implementation always get a chance to re-cycle transactions.
     Subclasses should implement {@link #getValue(RelatedItemHelper, Annotatable)}
+    Subclasses should override {@link #getExportValue(RelatedItemHelper, Annotatable, SourceItemTransformer)}
     to return the requested value from the item and use the
     DbControl from {@link RelatedItemHelper#dc}.
 …
+  {
     item = helper.recycle(dc, item);
+    return getValue(helper, item);
+  }
+  /**
+    Alternate implementation for loading data.
+  */
+  protected abstract Object getValue(RelatedItemHelper helper, Annotatable item);
+    return getExportValue(helper, item, null);
+  }
+  /**
+    Alternate implementation for loading data. The item is normally an item of the
+    expected source type, but if a preTransform is present, the item may be of
+    different type and must be processed with the {@link SourceItemTransformer#transform(net.sf.basedb.util.listable.TransformContext, Set)}
+    method first. In most cases, implementation should simply call {@link #getRelatedItems(Annotatable, SourceItemTransformer)}
+    to load the final target items.
+  */
+  protected abstract Object getValue(RelatedItemHelper helper, Annotatable item, SourceItemTransformer preTransform);
+  /**
+    Alternate implementation for loading data. The default implementation
+    simply call the {@link #getValue(RelatedItemHelper, Annotatable, SourceItemTransformer)} method.
+    @since 3.19.4
+  */
+  protected Object getExportValue(RelatedItemHelper helper, Annotatable item, SourceItemTransformer preTransform)
+  {
+    return getValue(helper, item, preTransform);
+  }
   /**
 …
   */
   @SuppressWarnings({ "unchecked", "rawtypes" })
+  protected Set<Annotatable> getRelatedItems(Annotatable item)
+  {
+    Set<Integer> relatedIds = transformer.transform(helper.transformContext, Collections.singleton(item.getId()));
+  protected Set<Annotatable> getRelatedItems(Annotatable item, SourceItemTransformer preTransform)
+  {
+    Set<Integer> sourceIds = Collections.singleton(item.getId());
+    if (preTransform != null)
+    {
+      sourceIds = preTransform.transform(helper.transformContext, sourceIds);
+    }
+    Set<Integer> relatedIds = transformer.transform(helper.transformContext, sourceIds);
     Set<Annotatable> relatedItems = new TreeSet<Annotatable>(new NameableComparator(false));
     for (Integer id : relatedIds)
+    {
       Annotatable a = targetType.getById(helper.dc, id);
+      Annotatable a = spec.targetType.getById(helper.dc, id);
       relatedItems.add(a);
+    }
 …
+  }
+  /**
+    Represents a specification for loading a related parent or child item.
+    The general format is: /DIRECTION/ITEMTYPE/subtype-id/property
+    where
+    * DIRECTION: PARENT or CHILD
+    * ITEMTYPE: Item.name() value for the related item
+    * subtype-id: Id of an {@link ItemSubtype} or a {@link RawDataType}
+    * property: a specification of what value to retrieve from the related item.
+      It can have different formats:
+      - #annotationtype-id: Id of an annotation type
+      - !extension-id#action-id: Id of an extension and {@link ListColumnAction} to use for loading the value
+      Otherwise it is interpreted as a property that is defined on the targeted instance.
+    @since 3.19.4
+  */
+  public static class Specification
+  {
+    public static Specification parse(Item sourceType, String expression)
+    {
+      Specification spec = new Specification();
+      spec.sourceType = sourceType;
+      spec.expression = expression;
+      spec.directionRaw = "PARENT";
+      spec.direction = SourceItemTransform.CHILD_TO_PARENT;
+      String[] tmp = expression.split("/", 5);
+      int baseIndex = 1;
+      if (tmp.length == 5)
+      {
+        baseIndex = 2;
+        spec.directionRaw = tmp[1];
+        if ("CHILD".equals(spec.directionRaw)) spec.direction = SourceItemTransform.PARENT_TO_CHILD;
+      }
+      spec.targetType = Item.valueOf(tmp[baseIndex]);
+      spec.subtype = tmp[baseIndex+1];
+      spec.property = tmp[baseIndex+2];
+      if (spec.property.startsWith("/"))
+      {
+        spec.multiHop = true;
+      }
+      else if (spec.property.startsWith("#"))
+      {
+        spec.annotationId = Values.getInt(spec.property.substring(1));
+      }
+      else if (spec.property.startsWith("!"))
+      {
+        // The normal property format is: !extension-id#action-id
+        // but it may be a filter specification: !x.action-id
+        // or (but it should never happen): !action-id
+        if (spec.property.startsWith("!x."))
+        {
+          spec.actionId = spec.property.substring(3);
+        }
+        else
+        {
+          int splitAt = spec.property.indexOf('#');
+          if (splitAt > 0)
+          {
+            spec.extensionId = Values.getStringOrNull(spec.property.substring(1, splitAt));
+            spec.actionId = spec.property.substring(splitAt+1);
+          }
+          else
+          {
+            spec.actionId = spec.property.substring(1);
+          }
+        }
+      }
+      return spec;
+    }
+    String expression;
+    String directionRaw;
+    SourceItemTransform direction;
+    Item sourceType;
+    Item targetType;
+    String subtype;
+    String subtypeName;
+    String property;
+    int annotationId;
+    String extensionId;
+    String actionId;
+    boolean multiHop;
+    /**
+      Get the full expression that defines the targeted item and property.
+    */
+    public String getExpression()
+    {
+      return expression;
+    }
+    /**
+      Get the raw value of the DIRECTION.
+    */
+    public String getDirectionRaw()
+    {
+      return directionRaw;
+    }
+    /**
+      Get the parsed value of the DIRECTION.
+    */
+    public SourceItemTransform getDirection()
+    {
+      return direction;
+    }
+    /**
+      Get the source item type. This is not part of the expression, but
+      is taken from the current list.
+    */
+    public Item getSourceType()
+    {
+      return sourceType;
+    }
+    /**
+      Get the target ITEMTYPE from the expression.
+    */
+    public Item getTargetType()
+    {
+      return targetType;
+    }
+    /**
+      Get the target subtype from the expression.
+    */
+    public String getSubtype()
+    {
+      return subtype;
+    }
+    /**
+      Get the name of the targeted subtype. This may not always
+      be available.
+    */
+    public String getSubtypeName()
+    {
+      return subtypeName;
+    }
+    /**
+      Get the property from the expression.
+    */
+    public String getProperty()
+    {
+      return property;
+    }
+    /**
+      Get the annotation id from the expression. Only available if the
+      property represents an annotation (it starts with '#').
+    */
+    public int getAnnotationId()
+    {
+      return annotationId;
+    }
+    /**
+      Get the extension id from the expression. Only available if the
+      property represents an extension (it starts with '!').
+    */
+    public String getExtensionId()
+    {
+      return extensionId;
+    }
+    /**
+      Get the action id from the expression. Only available if the
+      property represents an extension (it starts with '!').
+    */
+    public String getActionId()
+    {
+      return actionId;
+    }
+    /**
+      If the property starts with a '/' it is a multi-hop specification.
+      A multi-hop specification must be from child->parent->child and must
+      not have more than two hops.
+    */
+    public boolean isMultiHop()
+    {
+      return multiHop;
+    }
+    /**
+      Generates a title using target item type and subtype as prefix.
+    */
+    public String generateTitle(String title)
+    {
+      String result = "<span class=\"";
+      result += direction == SourceItemTransform.CHILD_TO_PARENT ? "parentitem" : "childitem";
+      if (multiHop) result += " multihop";
+      result += "\">";
+      result += StringUtil.coalesce(subtypeName, targetType.name());
+      result += "</span>";
+      result += withPrefix(".", title);
+      return result;
+    }
+    /**
+      Generates a tooltip using target item type and subtype as prefix.
+    */
+    public String generateTooltip(String tooltip)
+    {
+      return (direction == SourceItemTransform.CHILD_TO_PARENT ? "Parent › " : "Child › ") +
+          StringUtil.coalesce(subtypeName, targetType.name()) + withPrefix(" › ", tooltip);
+    }
+    /**
+      Return prefix+string if string is not null or the empty string otherwise.
+    */
+    private String withPrefix(String prefix, String s)
+    {
+      return s == null ? "" : prefix+s;
+    }
+    public ItemSubtype getItemSubtype(DbControl dc)
+    {
+      ItemSubtype st = ItemSubtype.getById(dc, Values.getInt(subtype));
+      subtypeName = st.getName();
+      return st;
+    }
+    public RawDataType getRawDataType()
+    {
+      RawDataType rdt = RawDataTypes.getSafeRawDataType(subtype);
+      subtypeName = rdt.getName();
+      return rdt;
+    }
+    public Restriction createTargetTypeRestriction(DbControl dc)
+    {
+      Restriction r = null;
+      if (targetType == Item.RAWBIOASSAY)
+      {
+        RawDataType rdt = getRawDataType();
+        r = Restrictions.eq(Hql.property("rawDataType"), Expressions.string(rdt.getId()));
+      }
+      else
+      {
+        ItemSubtype subtype = getItemSubtype(dc);
+        r = Restrictions.eq(Hql.property("itemSubtype"), Hql.entity(subtype));
+      }
+      return r;
+    }
+  }
+}

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemColumnActionFactory.java

-                      r7874
+                      r8083
 import net.sf.basedb.clients.web.extensions.AbstractJspActionFactory;
+import net.sf.basedb.clients.web.extensions.ExtensionsControl;
 import net.sf.basedb.clients.web.extensions.JspContext;
+import net.sf.basedb.clients.web.extensions.list.RelatedItemColumn.Specification;
 import net.sf.basedb.core.Annotatable;
 import net.sf.basedb.core.DbControl;
 …
 import net.sf.basedb.core.Metadata.PropertyPath;
 import net.sf.basedb.core.SessionControl;
+import net.sf.basedb.core.SyncFilter.SourceItemTransform;
 import net.sf.basedb.core.plugin.GuiContext;
 import net.sf.basedb.util.Values;
+import net.sf.basedb.util.extensions.ExtensionsFilter;
+import net.sf.basedb.util.extensions.ExtensionsInvoker;
 import net.sf.basedb.util.extensions.InvokationContext;
+import net.sf.basedb.util.extensions.SingleExtensionFilter;
 /**
 …
     String subContext = Values.getString(guiContext.getSubContext(), "");
+    ItemContext cc = sc.getCurrentContext(item, subContext, null);
+    if (cc == null) return false;
+    String allColumns = cc.getSetting("columns");
+    String allColumns = null;
+    SourceItemTransform requiredDirection = null;
+    if (RelatedItemExtensionColumn.SUBCONTEXT.equals(subContext))
+    {
+      // The current item should be a Specification instance that may specify
+      // the column. Otherwise we load the columns from the regular list context
+      // which makes it possible to select linked item columns from a parent/child
+      // that are currently available
+      Specification spec = jspContext.getCurrentItem();
+      if (spec != null)
+      {
+        allColumns = spec.actionId;
+        if (spec.direction == SourceItemTransform.CHILD_TO_PARENT)
+        {
+          // We may only select CHILD columns from a PARENT
+          requiredDirection = SourceItemTransform.PARENT_TO_CHILD;
+          subContext = "";
+        }
+      }
+    }
+    if (allColumns == null)
+    {
+      ItemContext cc = sc.getCurrentContext(item, subContext, null);
+      if (cc == null) return false;
+      allColumns = cc.getSetting("columns");
+    }
     if (allColumns == null || !allColumns.contains("/")) return false;
+    jspContext.addScript(jspContext.getRoot() + "/include/scripts/lazy-items.js");
+    boolean lazy = !Boolean.FALSE.equals(jspContext.getAttribute("lazy-loading"));
+    if (lazy)
+    {
+      jspContext.addScript(jspContext.getRoot() + "/include/scripts/lazy-items.js");
+    }
+    for (String col : allColumns.split(","))
+    {
+      if (col.startsWith("/") && col.contains("!"))
+      {
+        Specification spec = Specification.parse(item, col);
+        if (requiredDirection != null && requiredDirection != spec.direction) continue;
+        if (spec.property.startsWith("/"))
+        {
+          // We support multi-hop in max two steps
+          spec = Specification.parse(spec.targetType, spec.property);
+        }
+        // Create a child context for invoking the specified extensions as if we are on the relevant list page
+        GuiContext childGuiContext = GuiContext.list(spec.targetType, RelatedItemExtensionColumn.SUBCONTEXT);
+        JspContext childJspContext = ExtensionsControl.createContext(jspContext.getDbControl(), jspContext.getPageContext(), childGuiContext, spec);
+        childJspContext.linkAttributes(jspContext);
+        ExtensionsFilter filter = spec.extensionId == null ? null : new SingleExtensionFilter(spec.extensionId);
+        ExtensionsInvoker<ListColumnAction<Annotatable, ?>> childInvoker = ListColumnUtil.useExtensions(childJspContext, filter);
+        if (childInvoker.getNumExtensions() > 0)
+        {
+          // Copy scripts and stylesheets to the main JSP context
+          jspContext.addScripts(childJspContext.getScripts());
+          jspContext.addStylesheets(childJspContext.getStylesheets());
+          // Save the invoker in the main JSP context so that we can use the same
+          // instance in getActions()->RelatedItemColumn.create()
+          jspContext.setAttribute("RelatedItemInvoker."+spec.expression, childInvoker);
+        }
+      }
+    }
     return super.prepareContext(context);
+  }
 …
     Item item = guiContext.getItem();
     String subContext = Values.getString(guiContext.getSubContext(), "");
+    String allColumns = null;
+    SourceItemTransform requiredDirection = null;
+    if (RelatedItemExtensionColumn.SUBCONTEXT.equals(subContext))
+    {
+      // The current item should be a Specification instance that may specify
+      // the column. Otherwise we load the columns from the regular list context
+      Specification spec = jspContext.getCurrentItem();
+      if (spec != null)
+      {
+        allColumns = spec.actionId;
+        if (spec.direction == SourceItemTransform.CHILD_TO_PARENT)
+        {
+          // We may only select CHILD columns from a PARENT
+          requiredDirection = SourceItemTransform.PARENT_TO_CHILD;
+          subContext = "";
+        }
+      }
+    }
     ItemContext cc = sc.getCurrentContext(item, subContext, null);
+    if (cc == null) return null;
+    String allColumns = cc.getSetting("columns");
+    if (allColumns == null)
+    {
+      if (cc == null) return null;
+      allColumns = cc.getSetting("columns");
+    }
     if (allColumns == null || !allColumns.contains("/")) return null;
     boolean lazy = !Boolean.FALSE.equals(jspContext.getAttribute("lazy-loading"));
     DbControl dc = jspContext.getDbControl();
     RelatedItemHelper helper = new RelatedItemHelper(sc, lazy);
+    RelatedItemHelper helper = new RelatedItemHelper(sc, jspContext, lazy);
     List<ListColumnAction<Annotatable, Object>> actions = new ArrayList<>();
     for (String col : allColumns.split(","))
 …
       if (col.startsWith("/"))
+      {
+        ListColumnAction<Annotatable, Object> action = RelatedItemColumn.create(dc, actions.size(), item, col, helper);
+        Specification spec = Specification.parse(item, col);
+        if (requiredDirection != null && requiredDirection != spec.direction) continue;
+        ListColumnAction<Annotatable, Object> action = RelatedItemColumn.create(dc, actions.size(), spec, helper);
         if (action != null) actions.add(action);
+      }
 …
     if (actions.size() == 0) return null;
+    // If we are lazy-loading child/parent items we need to store context attributes
+    // so that the lazy-loading feature can pick them up again
+    if (lazy) jspContext.storeAttributes(cc, "lazy-related-items-attributes");
     return actions.toArray(new ListColumnAction[actions.size()]);
+  }

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemHelper.java

-                      r7962
+                      r8083
 import java.util.Set;
+import net.sf.basedb.clients.web.extensions.JspContext;
 import net.sf.basedb.core.Annotatable;
 import net.sf.basedb.core.DbControl;
 …
   final SessionControl sc;
+  final JspContext jspContext;
   final boolean lazy;
   // Use the snapshot manager for efficient loading of annotations
 …
   TransformContext transformContext;
   RelatedItemHelper(SessionControl sc, boolean lazy)
+  RelatedItemHelper(SessionControl sc, JspContext jspContext, boolean lazy)
+  {
     this.sc = sc;
+    this.jspContext = jspContext;
     this.lazy = lazy;
     this.manager = new SnapshotManager();

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemListColumn.java

-                      r7893
+                      r8083
 import net.sf.basedb.clients.web.Base;
+import net.sf.basedb.clients.web.formatter.LinkedItemFormatter;
 import net.sf.basedb.core.Annotatable;
 import net.sf.basedb.core.DbControl;
-import net.sf.basedb.core.Item;
 import net.sf.basedb.core.ItemContext;
 import net.sf.basedb.core.ItemList;
 import net.sf.basedb.core.ItemQuery;
-import net.sf.basedb.core.SyncFilter.SourceItemTransform;
 import net.sf.basedb.core.Type;
 import net.sf.basedb.core.query.Expressions;
 import net.sf.basedb.core.query.Hql;
-import net.sf.basedb.core.query.Restriction;
 import net.sf.basedb.core.query.Restrictions;
 import net.sf.basedb.util.NameableComparator;
 import net.sf.basedb.util.filter.Filter;
+import net.sf.basedb.util.formatter.CollectionFormatter;
+import net.sf.basedb.util.formatter.NameableFormatter;
+import net.sf.basedb.util.listable.SourceItemTransformer;
 /**
 …
   private final ItemQuery<ItemList> listQuery;
+  RelatedItemListColumn(DbControl dc, int index, String id, Item sourceType, Item targetType, SourceItemTransform direction, Restriction targetRestriction, Filter<? super ItemList> itemListFilter, RelatedItemHelper helper)
+  @SuppressWarnings({ "unchecked", "rawtypes" })
+  RelatedItemListColumn(DbControl dc, int index, Specification spec, Filter<? super ItemList> itemListFilter, RelatedItemHelper helper)
+  {
+    super(index, id, sourceType, targetType, direction, targetRestriction, helper);
+    ItemContext cc = dc.getSessionControl().getCurrentContext(sourceType);
+    setEnumeration(Base.getItemListsEnum(dc, targetType, cc.getInclude(), itemListFilter));
+    super(dc, index, spec, helper);
+    ItemContext cc = dc.getSessionControl().getCurrentContext(spec.sourceType);
+    setEnumeration(Base.getItemListsEnum(dc, spec.targetType, cc.getInclude(), itemListFilter));
+    setTitle(spec.generateTitle("Item list"));
+    setTooltip(spec.generateTooltip("Item list"));
+    setValueType(Type.INT);
+    setExportFormatter(new NameableFormatter());
+    if (!helper.lazy) setFormatter(new CollectionFormatter(new LinkedItemFormatter()));
     listQuery = ItemList.getQuery();
     listQuery.setIncludes(cc.getInclude());
     listQuery.join(Hql.innerJoin("members", "m"));
     listQuery.restrict(Restrictions.eq(Hql.property("memberType"), Expressions.integer(targetType.getValue())));
+    listQuery.restrict(Restrictions.eq(Hql.property("memberType"), Expressions.integer(spec.targetType.getValue())));
     listQuery.restrict(Restrictions.in(Hql.alias("m"), Expressions.parameter("itemId", Type.INT)));
+  }
   @Override
   public Object getValue(RelatedItemHelper helper, Annotatable item)
+  public Object getValue(RelatedItemHelper helper, Annotatable item, SourceItemTransformer preTransform)
+  {
     Set<Annotatable> items = getRelatedItems(item);
+    Set<Annotatable> items = getRelatedItems(item, preTransform);
     if (items.size() == 0) return null;

trunk/src/clients/web/net/sf/basedb/clients/web/extensions/list/RelatedItemPropertyColumn.java

-                      r7893
+                      r8083
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import net.sf.basedb.clients.web.Base;
+import net.sf.basedb.clients.web.formatter.FormatterFactory;
+import net.sf.basedb.clients.web.formatter.LinkedItemFormatter;
 import net.sf.basedb.core.Annotatable;
+import net.sf.basedb.core.DbControl;
 import net.sf.basedb.core.Item;
+import net.sf.basedb.core.ItemQuery;
+import net.sf.basedb.core.ItemSubtype;
 import net.sf.basedb.core.Metadata;
+import net.sf.basedb.core.Type;
 import net.sf.basedb.core.Metadata.PropertyPath;
+import net.sf.basedb.core.SyncFilter.SourceItemTransform;
+import net.sf.basedb.core.query.Restriction;
+import net.sf.basedb.util.Enumeration;
+import net.sf.basedb.util.formatter.CollectionFormatter;
+import net.sf.basedb.util.formatter.NameableFormatter;
+import net.sf.basedb.util.formatter.ToStringFormatter;
+import net.sf.basedb.util.listable.SourceItemTransformer;
 /**
 …
+{
+  private static Map<String, String> pathTitles = new HashMap<>();
+  static
+  {
+    // See also add_relateditem_columns.js
+    pathTitles.put("externalId", "External ID");
+    pathTitles.put("bioWell.bioPlate", "Bioplate");
+    pathTitles.put("entryDate", "Registered");
+    pathTitles.put("remainingQuantity", "Remaining quantity");
+    pathTitles.put("originalQuantity", "Original quantity");
+    pathTitles.put("creationEvent.entryDate", "Registration date");
+    pathTitles.put("creationEvent.eventDate", "Creation date");
+    pathTitles.put("creationEvent.protocol", "Protocol");
+    pathTitles.put("creationEvent.hardware", "Hardware");
+    pathTitles.put("protocol", "Protocol");
+    pathTitles.put("hardware", "Hardware");
+    pathTitles.put("software", "Software");
+    pathTitles.put("tag", "Tag");
+    pathTitles.put("job.itemSubtype", "Job type");
+    pathTitles.put("$itemLists", "Item lists");
+  }
+  /**
+    Convert some paths to a more user-friendly title instead.
+  */
+  private static String pathToTitle(String path)
+  {
+    String title = pathTitles.get(path);
+    return title == null ? path.substring(0, 1).toUpperCase() + path.substring(1) : title;
+  }
   private final PropertyPath<? super Annotatable, ?> property;
+  RelatedItemPropertyColumn(int index, String id, Item sourceType, Item targetType, SourceItemTransform direction, Restriction targetRestriction, RelatedItemHelper helper, PropertyPath<? super Annotatable, ?> property)
+  @SuppressWarnings({ "rawtypes", "unchecked" })
+  RelatedItemPropertyColumn(DbControl dc, int index, Specification spec, RelatedItemHelper helper, PropertyPath<? super Annotatable, ?> property)
+  {
     super(index, id, sourceType, targetType, direction, targetRestriction, helper);
+    super(dc, index, spec, helper);
     this.property = property;
+    if (property == null)
+    {
+      setTitle(spec.generateTitle(null));
+      setTooltip(spec.generateTooltip(null));
+    }
+    else
+    {
+      setTitle(spec.generateTitle(pathToTitle(spec.property)));
+      setTooltip(spec.generateTooltip(spec.property));
+    }
+    // If the property ends with an item...
+    if (property == null || property.getHibernateType().isEntityType())
+    {
+      setExportFormatter(new NameableFormatter());
+      if (!helper.lazy) setFormatter(new CollectionFormatter(new LinkedItemFormatter()));
+      // Specical case for Job subtypes which we set as an enumeration of existing subtypes
+      if ("job.itemSubtype".equals(spec.property))
+      {
+        ItemQuery<ItemSubtype> jobSubtypesQuery = Base.getSubtypesQuery(Item.JOB);
+        setEnumeration(Enumeration.fromItems(jobSubtypesQuery.list(dc), null));
+        setValueType(Type.INT);
+      }
+      else
+      {
+        // Filtering is made on the "name"
+        if (getFilterProperty()==null)
+        {
+          // Add '.name' to make filtering work
+          String nameProperty = getProperty() + ".name";
+          if (nameProperty.contains("/..")) nameProperty = nameProperty.replace("/..", "/");
+          setFilterProperty(nameProperty);
+        }
+        setValueType(Type.STRING);
+      }
+    }
+    else
+    {
+      Type colType = Type.fromHibernateType(property.getHibernateType());
+      if (colType != null)
+      {
+        setValueType(colType);
+        setExportFormatter(FormatterFactory.getTypeFormatter(dc.getSessionControl(), colType));
+      }
+      else
+      {
+        // Last fallback -- if we get here the Type.fromHibernateType() should be update with special cases
+        setValueType(Type.STRING);
+        setExportFormatter(new ToStringFormatter<>());
+      }
+      if (!helper.lazy) setFormatter(new CollectionFormatter(getExportFormatter()));
+    }
+  }
   @Override
   public Object getValue(RelatedItemHelper helper, Annotatable item)
+  public Object getValue(RelatedItemHelper helper, Annotatable item, SourceItemTransformer preTransform)
+  {
     Set<Annotatable> items = getRelatedItems(item);
+    Set<Annotatable> items = getRelatedItems(item, preTransform);
     if (items.size() == 0) return null;

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

-                      r7943
+                      r8083
     JSONObject json = new JSONObject();
     json.put("id", getId());
+    json.put("title", getTitle());
+    json.put("title", HTML.stripMarkup(getTitle()));
+    json.put("titleHTML", getTitle());
     json.put("subtitle", getSubtitle());
     json.put("property", getProperty());
 …
+      {
         context = table.getSc().getCurrentContext(table.getItem(), table.getSubcontext());
         // Check if hidden columns have a filter
         if (!isVisible && context != null)
+        String filterProp = getFilterproperty();
+        if (context != null)
+        {
+          if (isPermission)
+          // If the filter property is not the same as the ID, we should keep
+          // a pointer between them so we can match in Base.getAndSetCurrentContext()
+          // when testing if a filter is present on a hidden column
+          if (filterProp != null && !filterProp.equals(getId()))
+          {
             hasFilter = context.getItemPermission() != null;
+            context.setObject("id2filter."+getId(), filterProp);
+          }
+          else if (getFilterproperty() != null)
+          // Check if hidden columns have a filter
+          if (!isVisible)
+          {
+            hasFilter = context.hasPropertyFilter(getFilterproperty());
+            if (isPermission)
+            {
+              hasFilter = context.getItemPermission() != null;
+            }
+            else if (filterProp != null)
+            {
+              hasFilter = context.hasPropertyFilter(filterProp);
+            }
+          }
+        }
 …
         if (!isSortable)
+        {
           String theTooltip = getTooltip() != null ? getTooltip() : getTitle();
+          String theTooltip = getTooltip() != null ? getTooltip() : HTML.stripMarkup(getTitle());
           sb.append("<span title=\"").append(theTooltip).append("\">");
           sb.append(getTitle());
 …
           String theTooltip = getTooltip() != null ?
             getTooltip() : "Sort by "+getTitle() + "; hold CTRL, ALT or SHIFT to sort by multiple columns";
+            getTooltip() : "Sort by "+HTML.stripMarkup(getTitle()) + "; hold CTRL, ALT or SHIFT to sort by multiple columns";
           sb.append("<span class=\"link table-sort\"");
           sb.append(" id=\"").append(idPrefix).append(".sort\"");
 …
       if (isFilterable && hasFilter)
+      {
         table.addFilteredColumn(getId(), isVisible);
+        table.addFilteredColumn(getFilterproperty(), isVisible);
+      }
+    }

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

-                      r7407
+                      r8083
 import net.sf.basedb.clients.web.util.HTML;
 import net.sf.basedb.util.Values;
+import java.util.List;
+import net.sf.basedb.util.formatter.Formatter;
+import java.util.Set;
 import javax.servlet.jsp.JspException;
 import javax.servlet.jsp.JspTagException;
 …
+    {
       sb.append("");
       List<String> hiddenFilteredColumns = table.getHiddenFilteredColumns();
+      Set<String> hiddenFilteredColumns = table.getHiddenFilteredColumns();
       int numHidden = hiddenFilteredColumns == null ? 0 : hiddenFilteredColumns.size();
       if (numHidden > 0)
+      {
+        String columns = Values.getString(hiddenFilteredColumns, ",", true);
+        String columns = Values.getString(hiddenFilteredColumns, ",", true,
+          new Formatter<>()
+          {
+            @Override
+            public String format(String value)
+            {
+              if (value.startsWith("/"))
+              {
+                if (value.endsWith("/name") || value.endsWith(".name"))
+                {
+                  value = value.replace("/name", "/.");
+                }
+                else if (value.endsWith(".name"))
+                {
+                  value = value.replace(".name", "");
+                }
+                else if (value.contains("/!x."))
+                {
+                  // This is an extension filter convert to /!#
+                  value = value.replace("/!x.", "/!#");
+                }
+              }
+              else if (value.startsWith("!x."))
+              {
+                value = value.substring(3);
+              }
+              return value;
+            }
+            @Override
+            public String parseString(String value)
+            {
+              return null;
+            }
+          });
         sb.append("<span class=\"link\" id=\"").append(table.getId()).append(".showcolumns\"");
         sb.append(" data-hidden-columns=\"").append(columns).append("\"");

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

-                      r7982
+                      r8083
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.LinkedList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Set;
 …
   private Map<String, String> columnSubtitle;
   private transient Map<String, Formatter<?>> columnFormatter;
   private List<String> hiddenFilteredColumns;
+  private Set<String> hiddenFilteredColumns;
   @SuppressWarnings("rawtypes")
 …
+  {
     numFilteredColumns++;
     if (!visible) hiddenFilteredColumns.add(columnId);
+  }
   List<String> getHiddenFilteredColumns()
+    if (visible) hiddenFilteredColumns.remove(columnId);
+  }
+  Set<String> getHiddenFilteredColumns()
+  {
     return hiddenFilteredColumns;
 …
     columnFilter = new HashMap<String, String>();
     columnFormatter = new HashMap<String, Formatter<?>>();
     hiddenFilteredColumns = new LinkedList<String>();
+    hiddenFilteredColumns = new LinkedHashSet<String>();
     jsonColumnDefs = new JSONArray();
     if ((columns == null) || columns.equals("all"))
 …
+      {
         addHidden("exclude", (String)exclude);
+      }
+      // Until we know more, assume that all filtered columns are hidden...
+      Collection<net.sf.basedb.core.PropertyFilter> filters = cc.getPropertyFilters();
+      if (filters != null)
+      {
+        for (net.sf.basedb.core.PropertyFilter pf : filters)
+        {
+          hiddenFilteredColumns.add(pf.getProperty());
+        }
+      }
+    }

trunk/src/core/common-queries.xml

-                      r7997
+                      r8083
   <query id="DBLOG_GET_ANNOTATIONTYPE_INFO" type="HQL">
     <sql>
       SELECT at.name, at.valueType, at.disableLogOfValues
+      SELECT at.name, at.valueType, at.disableLogOfValues, at.projectAnnotations
       FROM AnnotationTypeData at
       WHERE at.id = :annotationTypeId
     </sql>
     <description>
       An HQL query that loads the 'name', 'valueType' and 'disableLogOfValues' flag
       for an annotation type given the ID.
+      An HQL query that loads the 'name', 'valueType', 'disableLogOfValues' and
+      the 'projectAnnotations' flag for an annotation type given the ID.
     </description>
   </query>

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

-                      r7643
+                      r8083
     Annotation a = dc.loadItem(Annotation.class, id);
     if (a == null) throw new ItemNotFoundException("Annotation[id="+id+"]");
+    return a;
+  }
+  /**
+    Get an <code>Annotation</code> item when you know the id
+    and ignore the rules for project-specific annotations when
+    modifying the values.
+    @see #setValuesIfDifferent(List, Unit)
+    @since 3.19.4
+  */
+  public static Annotation getById(DbControl dc, int id, boolean ignoreActiveProject)
+      throws ItemNotFoundException, PermissionDeniedException, BaseException
+  {
+    Annotation a = getById(dc, id);
+    a.ignoreActiveProject = ignoreActiveProject;
     return a;
+  }

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

-                      r7522
+                      r8083
     /**
+      Get the id of the project this annotation belong to.
+      Only relevant if the annotation type is using project-specific
+      annotations.
+      @since 3.19.4
+    */
+    public int getProjectId()
+    {
+      return projectId;
+    }
+    /**
       Get the ID of the unit this annotation is using.
     */

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

-                      r7982
+                      r8083
   private Set<Integer> selected;
   private boolean noPaging = false;
   private int rowsPerPage;
+  private int rowsPerPage = 30;
   private int page;
   private int numFilterRows = 1;
   private String sortProperty = null;
   private String message;
+  private Throwable exception;
   private SortDirection sortDirection = SortDirection.ASC;
   private Set<Include> include;
 …
     this.noPaging = true;
     copyFromSyncFilter(syncFilter);
+  }
+  /**
+    Initialize the context with the special purpose of configuring
+    a query with the given filters. It should not be used for
+    representing context in a GUI.
+    @since 3.19.4
+  */
+  ItemContext(Item itemType, PropertyFilter... filters)
+  {
+    this.itemType = itemType;
+    this.subContext = null;
+    this.name = null;
+    this.noPaging = true;
+    for (PropertyFilter filter : filters)
+    {
+      setPropertyFilter(filter);
+    }
+  }
 …
+  {
     this.message = message;
+  }
+  /**
+    Get the exception that is the cause for the error in
+    {@link #configureQuery(DbControl, EntityQuery, boolean)}.
+    @since 3.19.14
+  */
+  public Throwable getException()
+  {
+    return exception;
+  }
+  /**
+    Set the exception that is the cause for the error in
+    {@link #configureQuery(DbControl, EntityQuery, boolean)}.
+    @since 3.19.14
+  */
+  public void setException(Throwable t)
+  {
+    this.exception = t;
+  }
 …
             // Get default restriction
             if (r == null) r = filter.getRestriction(dc, query);
+            if (r == null) r = filter.getRestriction(dc, query, context);
+          }
           catch (Throwable ex)
 …
             Application.getLogger().warn(msg, ex);
             setMessage(msg + ": " + ex.getMessage());
+            setException(ex);
+          }

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

-                      r8013
+                      r8083
 import net.sf.basedb.core.query.Hql;
 import net.sf.basedb.core.query.IdListRestriction;
+import net.sf.basedb.util.extensions.ClientContext;
 import net.sf.basedb.util.listable.ListableUtil;
 import net.sf.basedb.util.listable.SourceItemTransformerFactory;
 …
   */
   public Restriction getRestriction(DbControl dc, EntityQuery query)
+  {
+    return getRestriction(dc, query, null);
+  }
+  /**
+    Create a restriction from the filter. There are a few special cases:
+    <p>
+    If the property starts with a $ it is interpreted as a <code>alias.property</code>
+    value, ignoring the root alias of the query. The alias is removed from the
+    property before proceeding.
+    <p>
+    If the property starts with a # or ## it is a filter on annotations. The rest of
+    the property is the ID of the annotation type, and we use a
+    {@link AnnotationSimpleRestriction} object for the restriction. If there
+    is only one # in the prefix only direct annotations are searched, if there
+    are two ##, inherited annotations are also searched.
+    <p>
+    If the property starts with a £, the rest of the property is the path that
+    joins the {@link ReporterData#getReporterListScores()} collection. The filter
+    value is the ID of the reporter list.
+    <p>
+    If the property starts with a @ the property is a collection of values and
+    we always use an IN restriction, ignoring the specified operator.
+    <p>
+    If the property starts with &amp; it is a collection of entities. The property
+    must end with a property name from the entity in the collection within paranthesis.
+    Eg. &amp;experiments(name). The filter is applied as a subquery.
+    <p>
+    If the property starts with ! it is another special filter:
+    <ul>
+    <li>Since BASE 2.15: !sharedTo.name, which is used to filter
+      shareable items by the name of users/groups/projects it has been shared to.
+      The 'name' part can be replaced with any other property that is common for
+      users, groups and projects (eg. description or id).
+    <li>Since BASE 3.18: !x., which is intended to be handled by extensions. It
+      is ignored by the BASE core code. The rest of the property should be a unique
+      identifier for the extension that is handling the filter.
+    </ul>
+    <p>
+    The property may also start with $@.
+    @return The restriction
+    @since 3.19.4
+  */
+  public Restriction getRestriction(DbControl dc, EntityQuery query, ClientContext context)
+  {
 …
         PropertyFilter pp = new PropertyFilter(linkProperty, operator, getValue(), getValueType());
         subquery.restrict(pp.getRestriction(dc, subquery));
+        subquery.restrict(pp.getRestriction(dc, subquery, context));
         restriction = AnyToAnyRestriction.exists(null, linkName, linkType, subquery);
+      }
 …
+      }
       PropertyFilter pp = new PropertyFilter(targetProperty, operator, getValue(), getValueType());
+      subquery.restrict(pp.getRestriction(dc, subquery));
+      ClientContext subContext = new ClientContext(dc);
+      if (context != null) subContext.linkAttributes(context);
+      ItemContext targetItemContext = new ItemContext(targetType, pp);
+      targetItemContext.configureQuery(dc, subquery, subContext, true);
+      if (context != null && targetItemContext.getException() != null)
+      {
+        // Copy error messages
+        ItemContext cc = context.getCurrentItem();
+        cc.setMessage(targetItemContext.getMessage());
+        cc.setException(targetItemContext.getException());
+      }
       // We then transform the list if ID:s to a list of child item ID:s using ItemList functionality
 …
         PropertyFilter pp = new PropertyFilter("$" + thisAlias + "." + collectionFilter,
             actualOperator, actualValue, getValueType());
         subquery.restrict(pp.getRestriction(dc, query));
+        subquery.restrict(pp.getRestriction(dc, query, context));
         // Create the main restriction
 …
         PropertyFilter pp = new PropertyFilter("$" + thisAlias + "." + collectionFilter,
             actualOperator, actualValue, getValueType());
         subquery.restrict(pp.getRestriction(dc, query));
+        subquery.restrict(pp.getRestriction(dc, query, context));
         // Create the main restriction
 …
+        {
           users = new PropertyFilter("$usr." + filterProperty,
               filterOp, filterValue, valueType).getRestriction(dc, query);
+              filterOp, filterValue, valueType).getRestriction(dc, query, context);
           groups = new PropertyFilter("$grp." + filterProperty,
               filterOp, filterValue, valueType).getRestriction(dc, query);
+              filterOp, filterValue, valueType).getRestriction(dc, query, context);
           projects = new PropertyFilter("$prj." + filterProperty,
               filterOp, filterValue, valueType).getRestriction(dc, query);
+              filterOp, filterValue, valueType).getRestriction(dc, query, context);
+        }
         restriction = Hql.sharedTo(sharedTo, users, groups, projects);

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

-                      r7883
+                      r8083
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
 …
+    }
     context.copyFromSyncFilter(getData());
+    // Make sure that all filtered columns are visible
+    String columns = StringUtil.coalesce(context.getSetting("columns"), "");
+    Set<String> visible = new HashSet<>(Arrays.asList(columns.split(",")));
+    for (String filterProperty : getData().getPropertyFilters().keySet())
+    {
+      if (visible.contains(filterProperty)) continue;
+      // Try some other variants when the filter is on a related-item column
+      if (filterProperty.startsWith("/"))
+      {
+        if (filterProperty.endsWith("/name"))
+        {
+          // replace "name" with "." to use the entity instead
+          filterProperty = filterProperty.replace("/name", "/.");
+        }
+        else if (filterProperty.endsWith(".name"))
+        {
+          // replace ".name" with "" to use the entity instead
+          filterProperty = filterProperty.replace(".name", "");
+        }
+        else if (filterProperty.contains("/!x."))
+        {
+          // This is an extension filter convert to /!#
+          filterProperty = filterProperty.replace("/!x.", "/!#");
+        }
+      }
+      else if (filterProperty.startsWith("!x."))
+      {
+        filterProperty = filterProperty.substring(3);
+      }
+      if (!visible.contains(filterProperty))
+      {
+        columns+=","+filterProperty;
+      }
+    }
+    context.setSetting("columns", columns);
+  }

trunk/src/core/net/sf/basedb/core/log/TransactionDetails.java

-                      r7950
+                      r8083
 import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
 import org.hibernate.query.Query;
 …
   private String pluginName;
   private String jobName;
+  private Map<Integer, String> projectNames;
   /**
 …
   /**
+    Get the name of the project with the given id.
+    Special cases: 0 = default
+  */
+  public String getProjectName(int projectId)
+  {
+    String name = null;
+    if (projectId > 0)
+    {
+      if (projectNames == null)
+      {
+        projectNames = new HashMap<>();
+      }
+      else
+      {
+        name = projectNames.get(projectId);
+      }
+      if (name == null)
+      {
+        Query<String> query = logControl.createHqlQuery("select prj.name from ProjectData prj where prj.id = " + projectId, String.class);
+        name = query.uniqueResult();
+        projectNames.put(projectId, name);
+      }
+    }
+    else
+    {
+      name = "default";
+    }
+    return name;
+  }
+  /**
     Utility method for loading the name of the currently executing plugin.
     The first call to this method will lookup the name in the database

trunk/src/core/net/sf/basedb/core/log/db/AnnotationLogger.java

r7381	r8083
83	83	Integer parentId = null;
84	84	Integer parentType = null;
	85	Integer projectId = null;
85	86	Annotation.Source source = null;
86	87	List<?> newValues = null;
…	…
105	106	newValues = info.getNewValues();
106	107	}
	108	if (at.getProjectAnnotations()) projectId = info.getProjectId();
107	109	}
108	110	else if (entity instanceof AnnotationData)
…	…
120	122	valueType = Type.fromValue((Integer)tmp[1]);
121	123	if ((Boolean)tmp[2]) logOldPropertyValues = false;
	124	if ((Boolean)tmp[3]) projectId = annotation.getProjectId();
122	125	}
123	126	else
…	…
125	128	annotationType = at.getName();
126	129	valueType = Type.fromValue(at.getValueType());
	130	if (at.getProjectAnnotations()) projectId = annotation.getProjectId();
127	131	if (at.getDisableLogOfValues()) logOldPropertyValues = false;
128	132	}
…	…
190	194	change.setItemType(parentType);
191	195
	196	String projectInfo = "";
	197	if (projectId != null)
	198	{
	199	String projectName = logControl.getTransactionDetails().getProjectName(projectId);
	200	if (projectName != null) projectInfo = " ("+projectName+")";
	201	}
192	202	if (source == Annotation.Source.CLONED)
193	203	{
194		change.setChangeInfo("ClonedAnnotation["+annotationType+"]");
	204	change.setChangeInfo("ClonedAnnotation["+annotationType+projectInfo+"]");
195	205	}
196	206	else if (source == Annotation.Source.INHERITED)
197	207	{
198		change.setChangeInfo("InheritedAnnotation["+annotationType+"]");
	208	change.setChangeInfo("InheritedAnnotation["+annotationType+projectInfo+"]");
199	209	}
200	210	else
201	211	{
202		change.setChangeInfo("Annotation["+annotationType+"]");
	212	change.setChangeInfo("Annotation["+annotationType+projectInfo+"]");
203	213	}
204	214	if (logOldPropertyValues)

trunk/src/core/net/sf/basedb/core/query/AnyToAnyRestriction.java

r7813	r8083
7	7	import net.sf.basedb.core.Item;
8	8	import net.sf.basedb.core.Type;
9		~~import net.sf.basedb.core.query.Restriction;~~
10	9	import net.sf.basedb.util.EqualsHelper;
11	10

trunk/src/core/net/sf/basedb/core/query/ReporterListExpression.java

r7813	r8083
29	29	import net.sf.basedb.core.RealTable;
30	30	import net.sf.basedb.core.ReporterList;
31		~~import net.sf.basedb.core.query.Expression;~~
32	31	import net.sf.basedb.util.EqualsHelper;
33	32

trunk/src/core/net/sf/basedb/core/snapshot/AnnotationSnapshot.java

-                      r7703
+                      r8083
 import net.sf.basedb.core.DbControl;
 import net.sf.basedb.core.Item;
+import net.sf.basedb.core.ItemNotFoundException;
 import net.sf.basedb.core.Permission;
+import net.sf.basedb.core.PermissionDeniedException;
+import net.sf.basedb.core.Project;
 import net.sf.basedb.core.Type;
 import net.sf.basedb.core.Unit;
 import net.sf.basedb.core.data.AnnotationData;
+import net.sf.basedb.util.EqualsHelper;
 import net.sf.basedb.util.filter.Filter;
 import net.sf.basedb.util.units.UnitConverter;
 …
+  {
     return new AnnotationTypeComparator(dc);
+  }
+  /**
+    Create a comparator for sorting annotation snapshots by the name
+    of the project. Default values can be sorted first or last.
+    @since 3.19.4
+  */
+  public static Comparator<AnnotationSnapshot> sortByProject(DbControl dc, boolean defaultFirst)
+  {
+    return new ProjectComparator(dc, defaultFirst);
+  }
 …
   /**
+    Get the project that a project-specific annotation belongs to. Returns
+    null if the annotation is a default value or if the project no longer
+    exists.
+    @throws PermissionDeniedException If the logged in user doesn't have access to the project
+    @since 3.19.4
+  */
+  public Project getProject(DbControl dc)
+  {
+    try
+    {
+      return projectId == 0 ? null : Project.getById(dc, projectId);
+    }
+    catch (ItemNotFoundException ex)
+    {} // The project may have been deleted
+    return null;
+  }
+  /**
+    Get the name of project if the annotation is a project-specific value.
+  */
+  String getProjectName(DbControl dc)
+  {
+    try
+    {
+      return projectId == 0 ? null : Project.getById(dc, projectId).getName();
+    }
+    catch (RuntimeException ex)
+    {} // The project may have been deleted or the logged in user may not have permission
+    return null;
+  }
+  /**
     Get the id of the default annotation that this project-specific
     annotation is overriding.
 …
+    }
+  }
+  /**
+    Comparator implementation for sorting snapshots
+    by name of project. If the project names are equal the snapshots are
+    sorted by annotation type.
+  */
+  static class ProjectComparator
+    implements Comparator<AnnotationSnapshot>
+  {
+    private final DbControl dc;
+    private final boolean defaultFirst;
+    private final AnnotationTypeComparator atComp;
+    ProjectComparator(DbControl dc, boolean defaultFirst)
+    {
+      this.dc = dc;
+      this.defaultFirst = defaultFirst;
+      this.atComp = new AnnotationTypeComparator(dc);
+    }
+    @Override
+    public int compare(AnnotationSnapshot o1, AnnotationSnapshot o2)
+    {
+      String n1 = o1.getProjectName(dc);
+      String n2 = o2.getProjectName(dc);
+      if (EqualsHelper.equals(n1, n2))
+      {
+        return atComp.compare(o1, o2);
+      }
+      else if (n1 == null)
+      {
+        return defaultFirst ? -1 : 1;
+      }
+      else if (n2 == null)
+      {
+        return defaultFirst ? 1 : -1;
+      }
+      return n1.compareTo(n2);
+    }
+  }
+}

trunk/src/core/net/sf/basedb/core/snapshot/SnapshotManager.java

-                      r7767
+                      r8083
   private Integer projectId;
+  private boolean allProjects;
   /**
 …
     Calling this method with a null parameter IS NOT the same
     as calling {@link #setNoProject()}.
+    as calling {@link #setNoProject()} or {@link #setAllProjects()}.
     @param project The project or null to only search for default
 …
+  {
     this.projectId = project == null ? 0 : project.getId();
+    this.allProjects = false;
+  }
 …
+  {
     this.projectId = null;
+  }
+    this.allProjects = false;
+  }
+  /**
+    Search for project-specific annotations for all projects including the default
+    values.
+    @since 3.19.4
+  */
+  public void setAllProjects()
+  {
+    this.projectId = null;
+    this.allProjects = true;
+  }
   /**
 …
+    {
       int shotProjectId = shot.getProjectId();
+      // Ignore all annotations not belonging to the specified project
+      if (projectId != null && shotProjectId != projectId) continue;
+      // Ignore project-specfic annotations not belonging to the current project
+      if (shotProjectId != 0 && shotProjectId != activeProjectId) continue;
+      // Ignore default annotations that already have a project-specific value
+      // NOTE! Depends on correct sort order in snapshots
+      if (overridden.contains(shot.getThisAnnotationId())) continue;
+      if (!allProjects)
+      {
+        // Ignore all annotations not belonging to the specified project
+        if (projectId != null && shotProjectId != projectId) continue;
+        // Ignore project-specfic annotations not belonging to the current project
+        if (shotProjectId != 0 && shotProjectId != activeProjectId) continue;
+        // Ignore default annotations that already have a project-specific value
+        // NOTE! Depends on correct sort order in snapshots
+        if (overridden.contains(shot.getThisAnnotationId())) continue;
+      }
       if (shot.getSource() == Annotation.Source.PRIMARY)
 …
           result.add(shot);
           // This is a project-specific annotation overriding a default value
           if (shotProjectId != 0) overridden.add(shot.getOverrideId());
+          if (!allProjects && shotProjectId != 0) overridden.add(shot.getOverrideId());
+        }
+      }

trunk/src/core/net/sf/basedb/util/extensions/ClientContext.java

-                      r8045
+                      r8083
 import net.sf.basedb.core.DbControl;
+import net.sf.basedb.core.ItemContext;
 import net.sf.basedb.core.SessionControl;
 …
+  }
+  /**
+    Link this context to the other context with respect to attributes.
+    Existing attributes in this context will be copied to the other context.
+    After this method call they will share the same internal storage so
+    that updates to one context is reflected in the other.
+    @since 3.19.4
+  */
+  public void linkAttributes(ClientContext other)
+  {
+    if (other.attributes == null) other.attributes = new HashMap<>();
+    if (attributes != null) other.attributes.putAll(attributes);
+    attributes = other.attributes;
+  }
+  /**
+    Store all attributes that has been set on this context to
+    the given ItemContext instance. Since the ItemContext is
+    persistant for session it is possible to load the same
+    attributes into another context later with {@link
+    #loadAttributes(ItemContext, String)}
+    @since 3.19.4
+  */
+  public void storeAttributes(ItemContext cc, String key)
+  {
+    if (attributes != null && attributes.size() > 0)
+    {
+      cc.setObject(key, attributes);
+    }
+  }
+  /**
+    Load attributes to this context from the given ItemContext
+    instance.
+    @since 3.19.4
+  */
+  public void loadAttributes(ItemContext cc, String key)
+  {
+    Map<String, Object> tmp = cc.getObject(key);
+    if (tmp != null && tmp.size() > 0)
+    {
+      if (attributes != null)
+      {
+        attributes.putAll(tmp);
+      }
+      else
+      {
+        attributes = tmp;
+      }
+    }
+  }
+}

trunk/src/core/net/sf/basedb/util/extensions/ExtensionsInvoker.java

-                      r7275
+                      r8083
+{
+  private final ClientContext clientContext;
   private final Collection<ExtensionContext<A>> contexts;
   private boolean clearErrors;
 …
     Creates a new invoker object.
   */
+  ExtensionsInvoker(Collection<ExtensionContext<A>> contexts)
+  {
+  ExtensionsInvoker(ClientContext clientContext, Collection<ExtensionContext<A>> contexts)
+  {
+    this.clientContext = clientContext;
     this.contexts = contexts;
+  }
+  /**
+    Get the client context that is used by this invoker.
+    @since 3.19.4
+  */
+  public ClientContext getClientContext()
+  {
+    return clientContext;
+  }

trunk/src/core/net/sf/basedb/util/extensions/Registry.java

r8045	r8083
715	715	// Sort the extensions
716	716	filter.sort(contexts);
717		return new ExtensionsInvoker<A>(contexts);
	717	return new ExtensionsInvoker<A>(clientContext, contexts);
718	718	}
719	719

trunk/src/core/net/sf/basedb/util/formatter/PropertyFilterFormatter.java

-                      r7889
+                      r8083
     StringBuilder sb = new StringBuilder();
+    if (property.startsWith("/"))
+    int numHops = 0;
+    while (property.startsWith("/") && numHops < 2)
+    {
       // Parent or child item filter
+      numHops++;
       String[] tmp = property.split("/", 5);
       int baseIndex = 0;
 …
       if (!property.startsWith("#")) sb.append(".");
+    }
     else if (property.startsWith("|"))
+    if (property.startsWith("|"))
+    {
       // Linked item filter
 …
       else
+      {
         if (property.startsWith("&") || property.startsWith("@") || property.startsWith("!"))
+        if (property.startsWith("&") || property.startsWith("@"))
+        {
           property = property.substring(1);
+        }
+        else if (property.startsWith("!x."))
+        {
+          property = property.substring(3);
+        }
         sb.append(name(property)).append(" ").append(operator(operator.toString())).append(" ");

trunk/src/core/net/sf/basedb/util/jep/LeftFunction.java

r6875	r8083
26	26	import org.nfunk.jep.ParseException;
27	27
28		~~import net.sf.basedb.util.jep.JepFunction;~~
29	28
30	29	/**

trunk/src/test/TestFile.java

-                      r7982
+                      r8083
     int baseTracServer = TestFileServer.test_create("base.thep.lu.se", "BASE trac site",
         "base", "base", "data/base.thep.lu.se.crt", null, null);
-    int base2DemoServer = TestFileServer.test_create("base.onk.lu.se", "BASE demo site", null, null,
-        "data/base.onk.lu.se.crt", null, null);
     int extId1 = test_create("https://base.thep.lu.se/robots.txt", false, false);
-    int extId2 = test_create("https://base.onk.lu.se/onk/images/baselogo.png", false, false);
     int extId3 = test_create("https://base.thep.lu.se/login", false, false);
     test_load(id1);
 …
     test_download(id1, "data/test.upload.txt");
     test_download(extId1, "data/test.download.robots.txt");
-    test_download(extId2, "data/test.download.baselogo.png");
     test_download(extId3, null);
 …
     test_delete(id2);
     test_delete(extId1);
-    test_delete(extId2);
     test_delete(extId3);
     TestFileServer.test_delete(baseTracServer);
-    TestFileServer.test_delete(base2DemoServer);
     write("++Testing file "+(ok ? "OK" : "Failed")+"\n");

trunk/src/test/TestFileServer.java

-                      r7982
+                      r8083
     // Standard tests: create, load, list
     int id = test_create("base.thep.lu.se", "BASE trac site", "base", "base", "data/base.thep.lu.se.crt", null, null);
-    int id2 = test_create("base.onk.lu.se", "BASE demo site", null, null, "data/base.onk.lu.se.crt", null, null);
     test_load(id);
     test_list(-1);
 …
     // Standard test: Delete
     test_delete(id);
-    test_delete(id2);
     write("++Testing file servers "+(ok ? "OK" : "Failed")+"\n");
     return ok;

trunk/src/test/TestItemImporter.java

-                      r7166
+                      r8083
     int childScanId = TestItemSubtype.test_create(Item.DERIVEDBIOASSAY, "ChildScan", SystemItems.getId(DerivedBioAssay.SCAN));
     int allSamplesSubtypeId = TestItemSubtype.test_create(Item.SAMPLE, "All samples");
-    int base2DemoServer = TestFileServer.test_create("base.onk.lu.se", "BASE demo site", null, null,
-        "data/base.onk.lu.se.crt", null, null);
     TestProject.test_defaultItem(projectId, Item.PROTOCOL, defaultSamplingProtocolId);
 …
     ok = ok & TestFile.test_list("/file-import", 1);  // 'reporters.txt'
     ok = ok & TestFile.test_list("/file-import/raw", 2);  // 'file1.txt' and 'file2.txt'
     ok = ok & TestFile.test_list("/file-import/ext", 2);  // 'robots.txt' and 'baselogo.png'
+    ok = ok & TestFile.test_list("/file-import/ext", 1);  // 'robots.txt'
     // Import annotation types
 …
     TestItemSubtype.test_delete(childScanId);
     TestItemSubtype.test_delete(allSamplesSubtypeId);
-    TestFileServer.test_delete(base2DemoServer);
     TestProject.test_delete(projectId);

trunk/src/test/data/test.batchimport.files.txt

r6576	r8083
3	3	raw/file1.txt Raw data Raw data #1
4	4	raw/file2.txt Raw data Raw data #2
5		/file-import/ext/robots.txt http://base.thep.lu.se/robots.txt text/plain Robots file for BASE
6		/file-import/ext/baselogo.png https://base.onk.lu.se/onk/images/baselogo.png base.onk.lu.se
	5	/file-import/ext/robots.txt https://base.thep.lu.se/robots.txt text/plain Robots file for BASE

trunk/www/admin/hardware/list_hardware.jsp

r8026	r8083
514	514	list="<%=loader.getValues()%>"
515	515	suffix="<%=loader.getUnitSymbol()%>"
516		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	516	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
517	517	/><%
518	518	}

trunk/www/admin/protocols/list_protocol.jsp

r8026	r8083
530	530	list="<%=loader.getValues()%>"
531	531	suffix="<%=loader.getUnitSymbol()%>"
532		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	532	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
533	533	/><%
534	534	}

trunk/www/admin/software/list_software.jsp

r8026	r8083
514	514	list="<%=loader.getValues()%>"
515	515	suffix="<%=loader.getUnitSymbol()%>"
516		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	516	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
517	517	/><%
518	518	}

trunk/www/biomaterials/bioplates/list_bioplates.jsp

r7982	r8083
668	668	list="<%=loader.getValues()%>"
669	669	suffix="<%=loader.getUnitSymbol()%>"
670		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	670	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
671	671	/><%
672	672	}

trunk/www/biomaterials/bioplates/wells/list_biowells.jsp

r7982	r8083
650	650	list="<%=loader.getValues()%>"
651	651	suffix="<%=loader.getUnitSymbol()%>"
652		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	652	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
653	653	/><%
654	654	}

trunk/www/biomaterials/biosources/list_biosources.jsp

r7982	r8083
581	581	list="<%=loader.getValues()%>"
582	582	suffix="<%=loader.getUnitSymbol()%>"
583		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	583	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
584	584	/><%
585	585	}

trunk/www/biomaterials/extracts/list_extracts.jsp

-                      r7982
+                      r8083
                           list="<%=loader.getValues()%>"
                           suffix="<%=loader.getUnitSymbol()%>"
                           clazz="<%=psInfo.overridesDefaultAnnotation() ? "ps-annotation" : null%>"
+                          clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
                         /><%
+                      }
 …
                           list="<%=loader.getValues()%>"
                           suffix="<%=loader.getUnitSymbol()%>"
                           clazz="<%=psInfo.overridesDefaultAnnotation() ? "ps-annotation" : null%>"
+                          clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
                         /><%
+                      }

trunk/www/biomaterials/kits/list_kits.jsp

r7982	r8083
515	515	list="<%=loader.getValues()%>"
516	516	suffix="<%=loader.getUnitSymbol()%>"
517		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	517	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
518	518	/><%
519	519	}

trunk/www/biomaterials/samples/list_samples.jsp

r7982	r8083
908	908	list="<%=loader.getValues()%>"
909	909	suffix="<%=loader.getUnitSymbol()%>"
910		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	910	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
911	911	/><%
912	912	}

trunk/www/biomaterials/tags/list_tags.jsp

r7982	r8083
507	507	list="<%=loader.getValues()%>"
508	508	suffix="<%=loader.getUnitSymbol()%>"
509		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	509	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
510	510	/><%
511	511	}

trunk/www/common/annotations/annotate.js

-                      r7926
+                      r8083
         var msg = '';
         var defaultValues = '';
+        var projectId = Data.int('page-data', 'project-id');
+        var activeProjectId = Data.int('page-data', 'active-project-id');
         if (ann.projectId != 0)
+        {
 …
         else
+        {
+          msg = 'This is the default value for a project annotation.<br>Changing it will create a project-specific value.';
+          msg = 'This is the default value for a project annotation.';
+          if (projectId < 0 && activeProjectId > 0) msg += '<br>Changing it will create a project-specific value.';
+        }
         Doc.element('project-annotations-message').innerHTML = msg;

trunk/www/common/annotations/annotate.jsp

-                      r7954
+                      r8083
   import="net.sf.basedb.core.Nameable"
   import="net.sf.basedb.core.Protocol"
+  import="net.sf.basedb.core.Project"
   import="net.sf.basedb.core.Subtypable"
   import="net.sf.basedb.core.ItemSubtype"
 …
 final Item itemType = Item.valueOf(request.getParameter("item_type"));
 final int itemId = Values.getInt(request.getParameter("item_id"));
+final int projectId = Values.getInt(request.getParameter("project_id"), -1);
 final int protocolId = Values.getInt(request.getParameter("protocol_id"), -1);
 final int subtypeId = Values.getInt(request.getParameter("subtype_id"), -1);
 …
+  }
+  // Load a project if it has been specified
+  Project project = null;
+  boolean readProject = true;
+  try
+  {
+    if (projectId > 0) project = Project.getById(dc, projectId);
+  }
+  catch (PermissionDeniedException ex)
+  {
+    readProject = false;
+  }
   // Load the current subtype
   // NOTE! User may have selected a different subtype in the form than what is
 …
   final ItemQuery<AnnotationType> parameterQuery = Base.getProtocolParametersQuery(protocol);
+  if (projectId >= 0)
+  {
+    title += " (" + (project != null ? "for project: "+HTML.encodeTags(project.getName()) : "default values") + ")";
+    annotationTypeQuery.restrict(Restrictions.eq(Hql.property("projectAnnotations"), Expressions.bool(true)));
+    if (parameterQuery != null)
+    {
+      parameterQuery.restrict(Restrictions.eq(Hql.property("projectAnnotations"), Expressions.bool(true)));
+    }
+  }
   // Holds all categories that we have found
   final Set<AnnotationTypeCategory> allCategories =
 …
     // Load the existing annotations
     as = item.getAnnotationSet();
     ItemQuery<Annotation> aQuery = as.getAnnotations(null);
+    ItemQuery<Annotation> aQuery = projectId < 0 ? as.getAnnotations(null) : as.getProjectAnnotations(null, project);
     aQuery.order(Orders.asc(Hql.property("annotationType.name")));
     List<Annotation> annotations = aQuery.list(dc);
 …
       data-annotation-type-id="<%=annotationTypeId%>"
       data-annotation-id="<%=annotationId %>"
+      data-project-id="<%=projectId%>"
+      data-active-project-id="<%=sc.getActiveProjectId()%>"
       data-date-format="<%=htmlDateFormat%>"
       data-datetime-format="<%=htmlDateTimeFormat%>"
 …
         <input type="hidden" name="item_type" value="<%=itemType.name()%>">
         <input type="hidden" name="item_id" value="<%=itemId%>">
+        <%
+        if (projectId >= 0)
+        {
+          %>
+          <input type="hidden" name="project_id" value="<%=projectId%>">
+          <%
+        }
+        %>
       </form>
       <%

trunk/www/common/annotations/list.js

-                      r7604
+                      r8083
+  {
     var target = event.currentTarget;
-    var annotationId = Data.int(target, 'annotation');
     var url =  App.getRoot() + 'common/annotations/annotate.jsp?ID='+App.getSessionId();
     url += '&annotation_id='+Data.int(target, 'annotation');;
+    url += '&annotation_id='+Data.int(target, 'annotation');
     url += '&item_type='+Data.get(target, 'item-type');
     url += '&item_id='+Data.get(target, 'item-id');
     url += '&annotationtype_id='+Data.get(target, 'annotation-type');
+    var projectId = Data.get(target, 'project');
+    if (projectId) url += '&project_id='+projectId;
     url += '&standalone=1';
     Dialogs.openPopup(url, 'EditAnnotation', 750, 500);

trunk/www/common/annotations/list_annotations.jsp

-                      r7954
+                      r8083
   import="net.sf.basedb.core.AnnotationType"
   import="net.sf.basedb.core.Protocol"
+  import="net.sf.basedb.core.Project"
   import="net.sf.basedb.core.AnnotationSet"
   import="net.sf.basedb.core.Annotation"
 …
   import="net.sf.basedb.core.snapshot.AnnotationSnapshot"
   import="net.sf.basedb.core.snapshot.SnapshotManager"
+  import="net.sf.basedb.core.snapshot.ProjectFilter"
+  import="net.sf.basedb.core.snapshot.AnnotationTypeFilter"
   import="net.sf.basedb.clients.web.Base"
   import="net.sf.basedb.clients.web.util.HTML"
 …
   import="net.sf.basedb.clients.web.formatter.FormatterFactory"
   import="net.sf.basedb.util.Values"
+  import="net.sf.basedb.util.filter.Filter"
+  import="net.sf.basedb.util.filter.AllOfFilter"
+  import="java.util.Arrays"
   import="java.util.Collections"
   import="java.util.ArrayList"
 …
 Set<AnnotationType> protocolParameters = null;
 Map<AnnotationType, AnnotationSnapshot> existing = null;
+boolean hasProjectSpecificAnnotationType = false;
+AnnotationTypeFilter annotationTypeFilter = null;
+Filter<AnnotationSnapshot> projectFilter = null;
 try
 …
+      {
         existing.put(a.getAnnotationType(dc), a);
+        hasProjectSpecificAnnotationType |= at.getProjectAnnotations();
+      }
       else
 …
     Collections.sort(inheritedAnnotations, AnnotationSnapshot.sortByAnnotationType(dc));
     annotationTypes.addAll(existing.keySet());
+  }
+  if (hasProjectSpecificAnnotationType)
+  {
+    manager.setAllProjects();
+    annotationTypeFilter = new AnnotationTypeFilter();
+    projectFilter = new AllOfFilter<>(Arrays.asList(annotationTypeFilter, new ProjectFilter(dc)));
+  }
 …
     annotationTypes.removeAll(protocolParameters);
+  }
   // Load the current subtype
   // NOTE! User may have selected a different subtype in the form than what is
 …
+  }
   Formatter<Date> dateTimeFormatter = FormatterFactory.getDateTimeFormatter(sc);
+  String projectValuesTitle = "<div class=\"project-values\"><div>Project values</div><div></div><div></div><div class=\"last-modified\">Last modified</div></div>";
   %>
   <base:page type="iframe" id="list-annotations">
 …
+    {
       float: right;
+    }
+    .project-values
+    {
+      display: grid;
+      grid-template-columns: 1fr 1fr 18px 12em;
+    }
+    .project-values div
+    {
+      padding: 1px 2px;
+      border-bottom-width: 1px;
+      border-bottom-style: dotted;
+    }
+    /* Remove borders on last row */
+    .project-values div:nth-last-child(-n+4)
+    {
+      border-bottom-width: 0;
+    }
+    .project-values .default-value
+    {
+      font-style: italic;
+    }
+    .project-values .current-value::before
+    {
+      font-weight: bold;
+      content: '›';
+      margin-right: 2px;
+    }
+    .project-values .other-value::before
+    {
+      font-weight: bold;
+      content: '›';
+      color: transparent;
+      margin-right: 2px;
+    }
+    /* Span accross first 2 columns */
+    .project-values .no-default
+    {
+      font-style: italic;
+      grid-column-start: 1;
+      grid-column-end: 3;
+    }
+    .last-modified
+    {
+      white-space: nowrap;
+      border-left-width: 1px;
+      border-left-style: dotted;
+    }
   </style>
 …
           <tbl:columndef
             id="values"
             title="Values"
+            title="<%=hasProjectSpecificAnnotationType ? "Current values" : "Values" %>"
           />
           <tbl:columndef
+            id="note"
+            title="Note"
+            id="projectValues"
+            title="<%=projectValuesTitle%>"
+            tooltip="Project values"
+            show="<%=hasProjectSpecificAnnotationType ? "always" : "never" %>"
+            style="padding: 0;"
           />
           <tbl:columndef
 …
             title="Last modified"
             formatter="<%=dateTimeFormatter%>"
+            show="<%=hasProjectSpecificAnnotationType ? "never" : "always" %>"
           />
           <tbl:columndef
 …
               AnnotationSnapshot a = existing != null ? existing.get(at) : null;
               List<?> values = null;
-              List<?> defaultValues = null;
               Formatter<Object> formatter = null;
               boolean projectSpecific = false;
 …
                 values = a.getActualValues(ann.getUnitConverter(null), ann.getValueType());
                 formatter = FormatterFactory.getAnnotationFormatter(sc, ann, null);
                 projectSpecific = a.getProjectId() != 0;
-                if (ann.isOverridingDefault())
+                {
-                  Annotation defAnn = ann.getDefaultAnnotation();
-                  defaultValues = defAnn.getValues();
+                }
+              }
               if (values != null || !at.isRemoved())
 …
                     visible="<%=at.isRemoved()%>"
                     /><%=Base.getLinkedName(ID, at, false, true)%></tbl:cell>
                   <tbl:cell column="values" clazz="<%=projectSpecific && defaultValues != null ? "cell ps-annotation" : "cell" %>">
+                  <tbl:cell column="values" clazz="<%=projectSpecific ? "cell ps-annotation" : "cell" %>" disableOverflowCheck="true">
                     <%=values == null || values.size() == 0 ? "<i>- no values -</i>" : Values.getString(values, ", ", true, formatter)%>
                     <base:icon image="edit.png" subclass="edit-annotation auto-init link"
+                    <base:icon image="<%=a==null?"edit_create.png":"edit.png" %>" subclass="edit-annotation auto-init link"
                       data-auto-init="edit-annotation"
                       data-annotation="<%=a!=null ? a.getThisAnnotationId() : 0 %>"
 …
                       data-item-type="<%=itemType.name()%>"
                       data-item-id="<%=itemId %>"
                       tooltip="Modify the values of this annotation"
+                      tooltip="<%=a==null?"Create this annotation":"Modify the values of this annotation"%>"
                       visible="<%=annotatePermission %>"
                     />
                   </tbl:cell>
+                  <tbl:cell column="note">
+                  <tbl:cell column="projectValues" disableOverflowCheck="true" style="padding:0;">
+                    <div class="project-values">
                     <%
+                    if (projectSpecific)
+                    if (at.getProjectAnnotations())
+                    {
+                      annotationTypeFilter.setAnnotationType(at);
+                      List<AnnotationSnapshot> projectValues = manager.findAnnotations(dc, snapshot, projectFilter, false);
+                      projectValues.sort(AnnotationSnapshot.sortByProject(dc, true));
+                      int numValues = projectValues.size();
+                      if (numValues == 0 || projectValues.get(0).getProjectId() != 0)
+                      {
+                        %>
+                        <div class="no-default"><%=numValues > 0 ? "No default value":""%></div>
+                        <div><base:icon image="edit_create.png" subclass="edit-annotation auto-init link"
+                            data-auto-init="edit-annotation"
+                            data-annotation="0"
+                            data-annotation-type="<%=at.getId()%>"
+                            data-project="0"
+                            data-item-type="<%=itemType.name()%>"
+                            data-item-id="<%=itemId %>"
+                            tooltip="Create a default value"
+                            visible="<%=annotatePermission %>"
+                          /></div>
+                        <div class="last-modified"></div>
+                        <%
+                      }
+                      if (numValues > 0)
+                      {
+                        for (AnnotationSnapshot pv : projectValues)
+                        {
+                          boolean isDefault = pv.getProjectId() == 0;
+                          boolean isCurrent = pv == a;
+                          Annotation ann = pv.getThisAnnotation(dc);
+                          values = pv.getActualValues(ann.getUnitConverter(null), ann.getValueType());
+                          formatter = FormatterFactory.getAnnotationFormatter(sc, ann, null);
+                          if (numValues > 1)
+                          {
+                            %>
+                            <div class="<%=isCurrent?"current-value":"other-value"%><%=isDefault ? " default-value":""%>"><%=isDefault ? "Default" : pv.getProject(dc).getName() %></div>
+                            <div><%=Values.getString(values, ", ", true, formatter) %></div>
+                            <%
+                          }
+                          else
+                          {
+                            %>
+                            <div></div><div></div>
+                            <%
+                          }
+                          %>
+                          <div><base:icon image="edit.png" subclass="edit-annotation auto-init link"
+                              data-auto-init="edit-annotation"
+                              data-annotation="<%=pv.getThisAnnotationId()%>"
+                              data-annotation-type="<%=at.getId()%>"
+                              data-project="<%=pv.getProjectId()%>"
+                              data-item-type="<%=itemType.name()%>"
+                              data-item-id="<%=itemId %>"
+                              tooltip="<%=isDefault ? "Modify the default value" : "Modify the value in this project"%>"
+                              visible="<%=annotatePermission %>"
+                            /></div>
+                          <div class="last-modified"><%=dateTimeFormatter.format(pv.getThisLastUpdate())%></div>
+                          <%
+                        }
+                      }
+                    }
+                    else if (a != null)
+                    {
                       %>
+                      <%=defaultValues == null || defaultValues.size() == 0 ? "No default value" : "Default value: " + Values.getString(defaultValues, ", ", true, formatter)%>
+                      <div></div><div></div><div></div>
+                      <div class="last-modified"><%=dateTimeFormatter.format(a.getThisLastUpdate())%></div>
                       <%
+                    }
                     %>
+                    </div>
                   </tbl:cell>
                   <tbl:cell column="lastModified" value="<%=a == null ? null : a.getThisLastUpdate() %>" />
 …
             <tbl:columndef
               id="values"
               title="Values"
+              title="<%=hasProjectSpecificAnnotationType ? "Current values" : "Values" %>"
             />
             <tbl:columndef
+              id="note"
+              title="Note"
+              id="projectValues"
+              title="<%=projectValuesTitle%>"
+              tooltip="Project values"
+              show="<%=hasProjectSpecificAnnotationType ? "always" : "never" %>"
+              style="padding: 0;"
             />
             <tbl:columndef
 …
               title="Last modified"
               formatter="<%=dateTimeFormatter%>"
+              show="<%=hasProjectSpecificAnnotationType ? "never" : "always" %>"
             />
             <tbl:columndef
 …
                 boolean annotatePermission = writePermission & at.hasPermission(Permission.USE);
                 AnnotationSnapshot a = existing != null ? existing.get(at) : null;
+                List<?> values = null;
                 Formatter<Object> formatter = null;
-                List<?> values = null;
-                List<?> defaultValues = null;
                 boolean projectSpecific = false;
                 if (a != null)
 …
                   values = a.getActualValues(ann.getUnitConverter(null), ann.getValueType());
                   formatter = FormatterFactory.getAnnotationFormatter(sc, ann, null);
                   projectSpecific = a.getProjectId() != 0;
-                  if (ann.isOverridingDefault())
+                  {
-                    Annotation defAnn = ann.getDefaultAnnotation();
-                    defaultValues = defAnn.getValues();
+                  }
+                }
                 if (values != null || !at.isRemoved())
 …
                       visible="<%=at.isRemoved()%>"
                     /><%=Base.getLinkedName(ID, at, false, true)%></tbl:cell>
                     <tbl:cell column="values" clazz="<%=projectSpecific && defaultValues != null ? "cell ps-annotation" : "cell" %>">
+                    <tbl:cell column="values" clazz="<%=projectSpecific ? "cell ps-annotation" : "cell" %>" disableOverflowCheck="true">
                       <%=values == null || values.size() == 0 ? "<i>- no values -</i>" : Values.getString(values, ", ", true, formatter)%>
                       <base:icon image="edit.png" subclass="edit-annotation auto-init link"
+                      <base:icon image="<%=a==null?"edit_create.png":"edit.png" %>" subclass="edit-annotation auto-init link"
                         data-auto-init="edit-annotation"
                         data-annotation="<%=a!=null ? a.getThisAnnotationId() : 0 %>"
 …
                         data-item-type="<%=itemType.name()%>"
                         data-item-id="<%=itemId %>"
                         tooltip="Modify the values of this protocol parameter"
+                        tooltip="<%=a==null?"Create this protocol parameter":"Modify the values of this protocol parameter"%>"
                         visible="<%=annotatePermission %>"
                       />
                     </tbl:cell>
+                    <tbl:cell column="note">
+                    <tbl:cell column="projectValues" disableOverflowCheck="true" style="padding:0;">
+                      <div class="project-values">
                       <%
+                      if (projectSpecific)
+                      if (at.getProjectAnnotations())
+                      {
+                        annotationTypeFilter.setAnnotationType(at);
+                        List<AnnotationSnapshot> projectValues = manager.findAnnotations(dc, snapshot, projectFilter, false);
+                        projectValues.sort(AnnotationSnapshot.sortByProject(dc, true));
+                        int numValues = projectValues.size();
+                        if (numValues == 0 || projectValues.get(0).getProjectId() != 0)
+                        {
+                          %>
+                          <div class="no-default"><%=numValues > 0 ? "No default value":""%></div>
+                          <div><base:icon image="edit_create.png" subclass="edit-annotation auto-init link"
+                              data-auto-init="edit-annotation"
+                              data-annotation="0"
+                              data-annotation-type="<%=at.getId()%>"
+                              data-project="0"
+                              data-item-type="<%=itemType.name()%>"
+                              data-item-id="<%=itemId %>"
+                              tooltip="Create a default value"
+                              visible="<%=annotatePermission %>"
+                            /></div>
+                          <div class="last-modified"></div>
+                          <%
+                        }
+                        if (numValues > 0)
+                        {
+                          for (AnnotationSnapshot pv : projectValues)
+                          {
+                            boolean isDefault = pv.getProjectId() == 0;
+                            boolean isCurrent = pv == a;
+                            Annotation ann = pv.getThisAnnotation(dc);
+                            values = pv.getActualValues(ann.getUnitConverter(null), ann.getValueType());
+                            formatter = FormatterFactory.getAnnotationFormatter(sc, ann, null);
+                            if (numValues > 1)
+                            {
+                              %>
+                              <div class="<%=isCurrent?"current-value":"other-value"%><%=isDefault ? " default-value":""%>"><%=isDefault ? "Default" : pv.getProject(dc).getName() %></div>
+                              <div><%=Values.getString(values, ", ", true, formatter) %></div>
+                              <%
+                            }
+                            else
+                            {
+                              %>
+                              <div></div><div></div>
+                              <%
+                            }
+                            %>
+                            <div><base:icon image="edit.png" subclass="edit-annotation auto-init link"
+                                data-auto-init="edit-annotation"
+                                data-annotation="<%=pv.getThisAnnotationId()%>"
+                                data-annotation-type="<%=at.getId()%>"
+                                data-project="<%=pv.getProjectId()%>"
+                                data-item-type="<%=itemType.name()%>"
+                                data-item-id="<%=itemId %>"
+                                tooltip="Modify the values of this protocol parameter"
+                                visible="<%=annotatePermission %>"
+                            /></div>
+                            <div class="last-modified"><%=dateTimeFormatter.format(pv.getThisLastUpdate())%></div>
+                            <%
+                          }
+                        }
+                      }
+                      else if (a != null)
+                      {
                         %>
+                        <%=defaultValues == null || defaultValues.size() == 0 ? "No default value" : "Default value: " + Values.getString(defaultValues, ", ", true, formatter)%>
+                        <div></div><div></div><div></div>
+                        <div class="last-modified"><%=dateTimeFormatter.format(a.getThisLastUpdate())%></div>
                         <%
+                      }
                       %>
+                      </div>
                     </tbl:cell>
                     <tbl:cell column="lastModified" value="<%=a == null ? null : a.getThisLastUpdate() %>" />
 …
               <tbl:row>
                 <tbl:cell column="annotation"><%=Base.getLinkedName(ID, at, at == null, true)%></tbl:cell>
                 <tbl:cell column="values" clazz="<%=projectSpecific && defaultValues != null ? "cell ps-annotation" : "cell" %>">
+                <tbl:cell column="values" clazz="<%=projectSpecific ? "cell ps-annotation" : "cell" %>" disableOverflowCheck="true">
                   <%=values == null || values.size() == 0 ?
                     "<i>- no values -</i>" : Values.getString(values, ", ", true, formatter)%>

trunk/www/common/columns/add_relateditem_column.js

-                      r7885
+                      r8083
   var configure = {};
+  var currentSubtypes;
+  var currentAnnotationTypesAll;
+  var currentAnnotationTypesCategory;
+  var currentTargetSubtypes;
+  var currentTargetAnnotationTypesAll;
+  var currentTargetAnnotationTypesCategory;
+  var currentTargetExtensionColumns;
+  var currentChildItemTypes;
+  var currentChildSubtypes;
+  var currentChildAnnotationTypesAll;
+  var currentChildAnnotationTypesCategory;
+  var currentChildExtensionColumns;
   // See also net.sf.basedb.clients.web.extensions.list.RelatedItemColumn.pathTitles
   var nameCol = {'id': '.', 'text': 'Name'};
   var externalIdCol = {'id': 'externalId', 'text': 'External ID'};
 …
+  {
     Events.addEventHandler('targetItemType', 'change', configure.targetItemTypeOnChange);
+    Events.addEventHandler('subtype', 'change', configure.subtypeOnChange);
+    Events.addEventHandler('targetSubtype', 'change', configure.targetSubtypeOnChange);
+    Events.addEventHandler('childItemType', 'change', configure.childItemTypeOnChange);
+    Events.addEventHandler('childSubtype', 'change', configure.childSubtypeOnChange);
     Events.addEventHandler('showAllAnnotationTypes', 'change', configure.updateColumnsList);
-    Events.addEventHandler('column', 'dblclick', configure.addColumn);
     Events.addEventHandler(document.body, 'click', configure.hideMessage);
 …
+  }
+  configure.subtypeOnChange = function(event)
+  {
+    var frm = document.forms['relatedItems'];
+  // Clear existing columns
+  configure.clearColumns = function()
+  {
+    Doc.element('columns').innerHTML = '';
+    Doc.element('annotations').innerHTML = '';
+    Doc.element('extensions').innerHTML = '';
+    Doc.hide('targetPath');
+    Doc.hide('childPath');
+  }
+  // Clear the list and disable it
+  configure.clearList = function(listOrId)
+  {
+    var list = Doc.element(listOrId);
+    list.disabled = true;
+    list.length = 1;
+  }
+  configure.targetItemTypeOnChange = function(event)
+  {
+    // Reset everything that depends on the target item type
+    configure.clearColumns();
+    configure.clearList('targetSubtype');
+    configure.clearList('childItemType');
+    configure.clearList('childSubtype');
+    var frm = document.forms['relatedItems'];
+    var sourceItemType = frm.item_type.value;
     var targetItemType = frm.targetItemType.value;
+    var category = frm.subtype[frm.subtype.selectedIndex].text;
+    var direction = Data.get(frm.targetItemType[frm.targetItemType.selectedIndex], 'direction');
+    if (targetItemType)
+    {
+      var url = 'ajax.jsp?ID='+App.getSessionId();
+      url += '&cmd=GetSubtypesAndAnnotationTypes&itemType='+encodeURIComponent(targetItemType);
+      url += '&sourceItemType='+encodeURIComponent(sourceItemType);
+      url += '&direction='+encodeURIComponent(direction);
+      var request = Ajax.getXmlHttpRequest();
+      request.open("GET", url, true);
+      request.send(null);
+      Ajax.setReadyStateHandler(request, configure.targetTypeInfoLoaded, configure.targetTypeInfoLoaded);
+    }
+  }
+  configure.targetSubtypeOnChange = function(event)
+  {
+    // Reset everything that depends on the target subtype
+    configure.clearColumns();
+    var frm = document.forms['relatedItems'];
+    var targetItemType = frm.targetItemType.value;
+    var sourceItemType = frm.item_type.value;
+    var category = frm.targetSubtype.selectedIndex > 0 ? frm.targetSubtype[frm.targetSubtype.selectedIndex].text : null;
     if (targetItemType && category)
+    {
       var url = 'ajax.jsp?ID='+App.getSessionId();
       url += '&cmd=GetAnnotationTypesForCategory&itemType='+encodeURIComponent(targetItemType);
+      url += '&sourceItemType='+encodeURIComponent(sourceItemType);
       url += '&category='+encodeURIComponent(category);
 …
       request.open("GET", url, true);
       request.send(null);
+      Ajax.setReadyStateHandler(request, configure.typeInfoLoaded, configure.typeInfoLoaded);
+    }
+  }
+  configure.targetItemTypeOnChange = function(event)
+  {
+    var targetItemType = event.currentTarget.value;
+    if (targetItemType)
+      Ajax.setReadyStateHandler(request, configure.targetTypeInfoLoaded, configure.targetTypeInfoLoaded);
+    }
+  }
+  configure.targetTypeInfoLoaded = function(request)
+  {
+    var response = JSON.parse(request.responseText);
+    if (response.status != 'ok')
+    {
+      App.debug(request.responseText);
+      return;
+    }
+    var frm = document.forms['relatedItems'];
+    if (response.childTypes)
+    {
+      frm.childItemType.length = 1;
+      currentChildItemTypes = response.childTypes;
+      for (var i = 0; i < currentChildItemTypes.length; i++)
+      {
+        var st = currentChildItemTypes[i];
+        frm.childItemType[frm.childItemType.length] = new Option('Child: '+st.name, st.id);
+      }
+      frm.childItemType.selectedIndex = 0;
+      frm.childItemType.disabled = currentChildItemTypes.length == 0;
+    }
+    if (response.subtypes)
+    {
+      currentTargetSubtypes = response.subtypes;
+      frm.targetSubtype.length = 1;
+      for (var i = 0; i < currentTargetSubtypes.length; i++)
+      {
+        var st = currentTargetSubtypes[i];
+        frm.targetSubtype[frm.targetSubtype.length] = new Option(st.name, st.id);
+      }
+      frm.targetSubtype.selectedIndex = 0;
+      frm.targetSubtype.disabled = currentTargetSubtypes.length == 0;
+    }
+    if (response.annotationTypes) currentTargetAnnotationTypesAll = response.annotationTypes;
+    if (response.annotationTypesCategory) currentTargetAnnotationTypesCategory = response.annotationTypesCategory;
+    if (response.extensionColumns) currentTargetExtensionColumns = response.extensionColumns;
+    configure.updateColumnsList();
+  }
+  configure.childItemTypeOnChange = function(event)
+  {
+    // Reset everything that depends on the child item type
+    configure.clearColumns();
+    configure.clearList('childSubtype');
+    var frm = document.forms['relatedItems'];
+    var targetItemType = frm.targetItemType.value;
+    var childItemType = frm.childItemType.value;
+    if (targetItemType && childItemType)
+    {
       var url = 'ajax.jsp?ID='+App.getSessionId();
+      url += '&cmd=GetSubtypesAndAnnotationTypes&itemType='+encodeURIComponent(targetItemType);
+      url += '&cmd=GetSubtypesAndAnnotationTypes&itemType='+encodeURIComponent(childItemType);
+      url += '&sourceItemType='+encodeURIComponent(targetItemType);
+      url += '&direction=CHILD';
       var request = Ajax.getXmlHttpRequest();
       request.open("GET", url, true);
       request.send(null);
+      Ajax.setReadyStateHandler(request, configure.typeInfoLoaded, configure.typeInfoLoaded);
+    }
+  }
+  configure.typeInfoLoaded = function(request)
+      Ajax.setReadyStateHandler(request, configure.childTypeInfoLoaded, configure.childTypeInfoLoaded);
+    }
+    else
+    {
+      configure.updateColumnsList();
+    }
+  }
+  configure.childSubtypeOnChange = function(event)
+  {
+    // Reset everything that depends on the child subtype
+    configure.clearColumns();
+    var frm = document.forms['relatedItems'];
+    var targetItemType = frm.targetItemType.value;
+    var childItemType = frm.childItemType.value;
+    var category = frm.childSubtype.selectedIndex > 0 ? frm.childSubtype[frm.childSubtype.selectedIndex].text : null;
+    if (targetItemType && childItemType && category)
+    {
+      var url = 'ajax.jsp?ID='+App.getSessionId();
+      url += '&cmd=GetAnnotationTypesForCategory&itemType='+encodeURIComponent(childItemType);
+      url += '&sourceItemType='+encodeURIComponent(targetItemType);
+      url += '&category='+encodeURIComponent(category);
+      var request = Ajax.getXmlHttpRequest();
+      request.open("GET", url, true);
+      request.send(null);
+      Ajax.setReadyStateHandler(request, configure.childTypeInfoLoaded, configure.childTypeInfoLoaded);
+    }
+  }
+  configure.childTypeInfoLoaded = function(request)
+  {
     var response = JSON.parse(request.responseText);
 …
       return;
+    }
+    var frm = document.forms['relatedItems'];
+    var frm = document.forms['relatedItems'];
     if (response.subtypes)
+    {
       currentSubtypes = response.subtypes;
       frm.subtype.length = 1;
       for (var i = 0; i < currentSubtypes.length; i++)
+      currentChildSubtypes = response.subtypes;
+      frm.childSubtype.length = 1;
+      for (var i = 0; i < currentChildSubtypes.length; i++)
+      {
         var st = currentSubtypes[i];
         frm.subtype[frm.subtype.length] = new Option(st.name, st.id);
+        var st = currentChildSubtypes[i];
+        frm.childSubtype[frm.childSubtype.length] = new Option(st.name, st.id);
+      }
+      frm.subtype.selectedIndex = 0;
+    }
+    if (response.annotationTypes) currentAnnotationTypesAll = response.annotationTypes;
+    if (response.annotationTypesCategory) currentAnnotationTypesCategory = response.annotationTypesCategory;
+      frm.childSubtype.selectedIndex = 0;
+      frm.childSubtype.disabled = currentChildSubtypes.length == 0;
+    }
+    if (response.annotationTypes) currentChildAnnotationTypesAll = response.annotationTypes;
+    if (response.annotationTypesCategory) currentChildAnnotationTypesCategory = response.annotationTypesCategory;
+    if (response.extensionColumns) currentChildExtensionColumns = response.extensionColumns;
     configure.updateColumnsList();
+  }
   configure.updateColumnsList = function()
 …
     var targetItemType = frm.targetItemType.value;
+    var subtype = frm.subtype.value;
+    if (!targetItemType || !subtype)
+    {
+      frm.column.length = 0;
+      return;
+    }
+    var annotationTypes = frm.showAllAnnotationTypes.checked ? currentAnnotationTypesAll : currentAnnotationTypesCategory;
+    frm.column.length = 0;
+    var targetSubtype = frm.targetSubtype.value;
+    var childItemType = frm.childItemType.value;
+    var childSubtype = frm.childSubtype.value;
+    // At least a target item type and a subtype must be selected
+    if (!targetItemType || !targetSubtype) return;
+    // If a child item type is selected, so must a child subtype
+    if (childItemType && !childSubtype) return;
+    var targetDirection = Data.get(frm.targetItemType[frm.targetItemType.selectedIndex], 'direction');
+    var targetText = frm.targetSubtype[frm.targetSubtype.selectedIndex].text;
+    if (targetDirection == 'PARENT')
+    {
+      Doc.element('targetPath').innerHTML = 'Parent('+targetText+')';
+      Doc.element('targetPath').className = 'parentitem';
+    }
+    else
+    {
+      Doc.element('targetPath').innerHTML = 'Child('+targetText+')';
+      Doc.element('targetPath').className = 'childitem';
+    }
+    Doc.show('targetPath', 'inline');
+    var staticCols = staticColumns[targetItemType] || [];
+    var annotationCols = frm.showAllAnnotationTypes.checked ? currentTargetAnnotationTypesAll : currentTargetAnnotationTypesCategory;
+    var xtCols = currentTargetExtensionColumns;
+    if (childItemType && childSubtype)
+    {
+      staticCols = staticColumns[childItemType] || [];
+      annotationCols = frm.showAllAnnotationTypes.checked ? currentChildAnnotationTypesAll : currentChildAnnotationTypesCategory;
+      xtCols = currentChildExtensionColumns;
+      var childText = frm.childSubtype[frm.childSubtype.selectedIndex].text;
+      Doc.element('childPath').innerHTML = 'Child: '+childText;
+      Doc.show('childPath', 'inline');
+    }
+    var html = '';
     // Add static property columns depending on itemtype
+    var cols = staticColumns[targetItemType] || [];
+    for (var i = 0; i < cols.length; i++)
+    {
+      var c = cols[i];
+      frm.column[frm.column.length] = new Option(c.text, c.id);
+    }
+    for (var i = 0; i < staticCols.length; i++)
+    {
+      var c = staticCols[i];
+      var text = Strings.encodeTags(c.text);
+      html += '<div><label><input type="checkbox" data-column-id="'+c.id+'" data-column-title="'+text+'">';
+      html += text + '</label></div>';
+    }
+    Doc.element('columns').innerHTML = html;
     // Add annotation columns
+    for (var i = 0; i < annotationTypes.length; i++)
+    {
+      var at = annotationTypes[i];
+      frm.column[frm.column.length] = new Option(at.name+" [A]", "#"+at.id);
+    }
+    frm.column.selectedIndex = -1;
+  }
+    html = '';
+    for (var i = 0; i < annotationCols.length; i++)
+    {
+      var at = annotationCols[i];
+      var text = Strings.encodeTags(at.name);
+      html += '<div><label><input type="checkbox" data-column-id="#+'+at.id+'" data-column-title="'+text+'">';
+      html += text + '</label></div>';
+    }
+    Doc.element('annotations').innerHTML = html;
+    // Extension columns
+    html = '';
+    for (var i = 0; i < xtCols.length; i++)
+    {
+      var xtCol = xtCols[i];
+      var id = "!"+xtCol.id+"#"+xtCol.columnId;
+      var text = Strings.encodeTags(xtCol.name);
+      if (xtCol.id.indexOf('net.sf.basedb.clients.web.related-item-columns') == 0)
+      {
+        // Special case when the extension is the related-item extionsion
+        // It has built-in support for two hops and doen't have to use the
+        // extension mechanism recursively
+        id = xtCol.columnId;
+      }
+      html += '<div title="'+Strings.encodeTags(xtCol.tooltip)+'">';
+      html += '<label><input type="checkbox" data-column-id="'+id+'" data-column-title="'+text+'">';
+      html += (xtCol.nameHTML || text) + '</label></div>';
+    }
+    Doc.element('extensions').innerHTML = html;
+  }
   configure.addColumn = function(event)
 …
     var data = {};
     data.targetItemType = frm.targetItemType.value;
+    data.subtype = frm.subtype.value;
+    data.targetSubtype = frm.targetSubtype.value;
+    data.childItemType = frm.childItemType.value;
+    data.childSubtype = frm.childSubtype.value;
     if (!data.targetItemType)
 …
       return;
+    }
+    if (!data.subtype)
+    {
+      Forms.showNotification('subtype', 'Please select a subtype!');
+      return;
+    }
+    data.subtypeName = frm.subtype[frm.subtype.selectedIndex].text;
+    if (!data.targetSubtype)
+    {
+      Forms.showNotification('targetSubtype', 'Please select a subtype!');
+      return;
+    }
+    if (data.childItemType && !data.childSubtype)
+    {
+      Forms.showNotification('childSubtype', 'Please select a subtype!');
+      return;
+    }
+    data.targetSubtypeName = frm.targetSubtype[frm.targetSubtype.selectedIndex].text;
     data.direction = Data.get(frm.targetItemType[frm.targetItemType.selectedIndex], 'direction');
+    var propertyPrefix = '/'+data.direction+'/'+data.targetItemType+'/'+data.targetSubtype+'/';
+    var titlePrefix = data.targetSubtypeName;
+    if (data.childItemType)
+    {
+      data.childSubtypeName = frm.childSubtype[frm.childSubtype.selectedIndex].text;
+      propertyPrefix += '/CHILD/'+data.childItemType+'/'+data.childSubtype+'/';
+      titlePrefix += '.'+data.childSubtypeName;
+    }
     var numSelected = 0;
+    for (var i = 0; i < frm.column.length; i++)
+    {
+      if (frm.column[i].selected)
+    var allColumns = document.querySelectorAll("input[data-column-id]");
+    for (var i = 0; i < allColumns.length; i++)
+    {
+      if (allColumns[i].checked)
+      {
         var col = frm.column[i];
         data.column = col.value;
         data.property = '/'+data.direction+'/'+data.targetItemType+'/'+data.subtype+'/'+data.column;
         data.title = data.subtypeName + (col.value == '.' ? '' : '.'+col.text);
+        var col = allColumns[i];
+        data.column = Data.get(col, 'column-id');
+        data.property = propertyPrefix+data.column;
+        data.title = titlePrefix + (data.column == '.' ? '' : '.'+Data.get(col, 'column-title'));
         Events.sendCustomEvent(window.opener.Doc.element('selectRelatedItemColumn'), 'base-selected', data);
         numSelected++;
+        // Remove the column from the list
+        var div = col.parentNode.parentNode;
+        div.parentNode.removeChild(div);
+      }
+    }
 …
     if (numSelected == 0)
+    {
+      Forms.showNotification('column', 'Please select a column!');
+      return;
+    }
+    for (var i = frm.column.length-1; i >= 0; i--)
+    {
+      if (frm.column[i].selected) frm.column[i] = null;
+      Forms.showNotification('columnstable', 'Please select at least one column!', null, 'pointer-below');
+      return;
+    }
     Doc.element('added-column-msg').innerHTML = numSelected == 1 ?
       '1 column has been added to the table.' : numSelected + ' columns have been added to the table.';
     Doc.show('added-column-msg');
+    Doc.show('added-column-msg', 'table');
     event.stopPropagation(); // To prevent the hideMessage() method from executing
+    setTimeout(configure.hideMessage, 2000);
+  }

trunk/www/common/columns/add_relateditem_column.jsp

-                      r7842
+                      r8083
 %>
 <base:page type="popup" title="Add parent or child item column">
+<base:head scripts="~add_relateditem_column.js" />
+<base:head scripts="~add_relateditem_column.js">
+<style>
+th
+{
+  min-width: 10em;
+}
+select
+{
+  width: calc(100% - 1em);
+  min-width: 15em;
+}
+.columnstable
+{
+  width: 100%;
+}
+.columnstable tr
+{
+  vertical-align: top;
+}
+.columnstable th
+{
+  text-align: left;
+  padding: 2px 4px;
+}
+.columnstable td
+{
+  text-align: left;
+  padding: 4px 1px;
+}
+.columnstable td > div
+{
+  margin-bottom: 4px;
+  white-space: nowrap;
+}
+#added-column-msg
+{
+  position: absolute;
+  bottom: 1em;
+  left: 0;
+  right: 0;
+  display: table;
+  margin-left: auto;
+  margin-right: auto;
+}
+.parentitem::before
+{
+  content: url('../../images/parent-item.png');
+  margin: 0 2px;
+  vertical-align: -2px;
+}
+.childitem::before
+{
+  content: url('../../images/child-item.png');
+  margin: 0 2px;
+  vertical-align: -2px;
+}
+.columnsFrom
+{
+  font-weight: bold;
+}
+.columnsFrom > span
+{}
+</style>
+</base:head>
 <base:body>
   <h1>Add parent or child item column <base:help helpid="columns.configure.add_relateditem_column" /></h1>
 …
   <div class="content">
+    <table class="fullform input100 smaller bottomborder">
+    <div class="absolutefull" >
+    <table class="fullform input100 bottomborder">
     <tr>
       <th>Item type</th>
       <td>
         <select name="targetItemType" id="targetItemType" style="min-width: 15em;">
+      <th>Parent/child</th>
+      <td>
+        <select name="targetItemType" id="targetItemType" class="required">
           <option value="">- select -
           <%
 …
         </select>
       </td>
+      <td style="white-space: nowrap;">with link to</td>
+      <td>
+        <select name="childItemType" id="childItemType" disabled>
+          <option value="">- optional -
+        </select>
+      </td>
+      <td>
+      </td>
     </tr>
     <tr>
       <th>Subtype</th>
       <td>
         <select name="subtype" id="subtype" style="min-width: 15em;">
+        <select name="targetSubtype" id="targetSubtype" class="required" disabled>
           <option value="">- select -
         </select>
+        <label><input type="checkbox" id="showAllAnnotationTypes" name="showAllAnnotationTypes">Show annotation types for all subtypes</label>
+      </td>
+      <td>subtype</td>
+      <td>
+        <select name="childSubtype" id="childSubtype" disabled>
+          <option value="">- select -
+        </select>
       </td>
     </tr>
     <tr class="dynamic">
+      <th>Column</th>
+      <td>
+        <select name="column" id="column" style="min-width: 25em; height: calc(100% - 4em);" multiple></select>
+        <div id="added-column-msg" class="messagecontainer note" style="display:none; margin: 0.5em 0;"></div>
+      </td>
+      <th></th>
+      <td></td>
+      <td></td>
+      <td></td>
     </tr>
     </table>
+    </div>
+    <div class="absolutefull" style="top: 4em; left: 10em;">
+      <div class="columnsFrom" style="height: 1.5em; white-space: nowrap; overflow: hidden;">
+        <span id="targetPath"></span><span id="childPath" class="childitem" style="display: none;"></span>
+        <label style="font-weight: normal;"><input type="checkbox" id="showAllAnnotationTypes"
+          name="showAllAnnotationTypes">Show annotations for all subtypes</label>
+      </div>
+      <table id="columnstable" class="columnstable" style="width: 100%;">
+      <thead class="bg-filled-100 topborder bottomborder">
+        <tr>
+          <th style="width: 33%;">Columns</th>
+          <th style="width: 33%;">Annotations</th>
+          <th style="width: 34%;">Extensions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td id="columns"></td>
+          <td id="annotations"></td>
+          <td id="extensions"></td>
+        </tr>
+      </tbody>
+      </table>
+    </div>
+    <div id="added-column-msg" class="messagecontainer note" style="display:none;">message</div>
   </div>
   </form>

trunk/www/common/columns/ajax.jsp

-                      r7954
+                      r8083
   import="net.sf.basedb.core.RawDataType"
   import="net.sf.basedb.core.plugin.GuiContext"
+  import="net.sf.basedb.core.SyncFilter.SourceItemTransform"
   import="net.sf.basedb.util.Values"
   import="net.sf.basedb.util.formatter.Formatter"
+  import="net.sf.basedb.util.formatter.ToStringFormatter"
   import="net.sf.basedb.util.error.ThrowableUtil"
+  import="net.sf.basedb.util.extensions.ActionIterator"
   import="net.sf.basedb.util.extensions.ExtensionsInvoker"
+  import="net.sf.basedb.util.listable.ListableUtil"
+  import="net.sf.basedb.util.listable.SourceItemTransformerFactory"
   import="net.sf.basedb.core.query.Restrictions"
   import="net.sf.basedb.core.query.Expressions"
 …
   import="net.sf.basedb.clients.web.Base"
   import="net.sf.basedb.clients.web.WebException"
+  import="net.sf.basedb.clients.web.util.HTML"
   import="net.sf.basedb.clients.web.extensions.JspContext"
   import="net.sf.basedb.clients.web.extensions.ExtensionsControl"
   import="net.sf.basedb.clients.web.extensions.list.ListColumnAction"
   import="net.sf.basedb.clients.web.extensions.list.ListColumnUtil"
+  import="net.sf.basedb.clients.web.extensions.list.RelatedItemExtensionColumn"
+  import="net.sf.basedb.clients.web.extensions.list.RelatedItemColumn.Specification"
   import="org.json.simple.JSONObject"
   import="org.json.simple.JSONArray"
 …
+  {
     dc = sc.newDbControl(":Get subtypes and annotation types");
+    Item sourceItemType = Item.valueOf(request.getParameter("sourceItemType"));
+    String direction = Values.getString(request.getParameter("direction"), "PARENT");
+    JSONArray jsonAllowedChildTypes = new JSONArray();
+    json.put("childTypes", jsonAllowedChildTypes);
+    if ("PARENT".equals(direction))
+    {
+      SourceItemTransformerFactory factory = ListableUtil.getTransformerFactory(itemType);
+      List<Item> allowedChildItems = factory.getSupportedSourceItems(SourceItemTransform.CHILD_TO_PARENT);
+      for (Item childType : allowedChildItems)
+      {
+        JSONObject jsonCt = new JSONObject();
+        jsonCt.put("id", childType.name());
+        jsonCt.put("name", childType.toString());
+        jsonAllowedChildTypes.add(jsonCt);
+      }
+    }
     JSONArray jsonSubtypes = new JSONArray();
     json.put("subtypes", jsonSubtypes);
 …
     json.put("annotationTypes", jsonAnnotationTypes);
+    Specification spec = Specification.parse(sourceItemType, "/"+direction+"/"+itemType.name()+"/*/*");
+    GuiContext guiContext = GuiContext.list(itemType, RelatedItemExtensionColumn.SUBCONTEXT);
+    JspContext jspContext = ExtensionsControl.createContext(dc, pageContext, guiContext, spec);
+    ExtensionsInvoker<ListColumnAction<BasicItem,?>> columnsInvoker = ListColumnUtil.useExtensions(jspContext);
+    ActionIterator<ListColumnAction<BasicItem,?>> it = columnsInvoker.iterate();
+    JSONArray jsonExtensions = new JSONArray();
+    while (it.hasNext())
+    {
+      ListColumnAction<BasicItem,?> col = it.next();
+      JSONObject jsonXt = new JSONObject();
+      jsonXt.put("id", it.getExtension().getId());
+      jsonXt.put("columnId", col.getId());
+      jsonXt.put("name", HTML.stripMarkup(col.getTitle()));
+      jsonXt.put("nameHTML", col.getTitle());
+      jsonXt.put("tooltip", col.getTooltip());
+      jsonExtensions.add(jsonXt);
+    }
+    json.put("extensionColumns", jsonExtensions);
+  }
   else if ("GetAnnotationTypesForCategory".equals(cmd))
 …
+      }
+    }
     json.put("annotationTypesCategory", jsonAnnotationTypes);
+  }
   else if ("GetLazyItemColumns".equals(cmd))
+  {
     String subContext = Values.getStringOrNull(request.getParameter("subcontext"));
+    String subContext = Values.getString(request.getParameter("subcontext"));
     GuiContext guiContext = GuiContext.list(itemType, subContext);
+    ItemContext cc = sc.getCurrentContext(itemType, subContext);
     Integer[] items = Values.getInt(request.getParameter("items").split(","));
+    int remaining = Values.getInt(request.getParameter("remaining"), -1);
     dc = sc.newDbControl(":Get lazy columns");
     JspContext jspContext = ExtensionsControl.createContext(dc, pageContext, guiContext, null);
+    jspContext.loadAttributes(cc, "lazy-related-items-attributes");
+    if (remaining == 0) cc.removeObject("lazy-related-items-attributes");
     jspContext.setAttribute("lazy-loading", false);
     ExtensionsInvoker<ListColumnAction<BasicItem, ?>> columnsInvoker = ListColumnUtil.useExtensions(jspContext);
 …
           @SuppressWarnings("unchecked")
           Formatter<Object> f = (Formatter<Object>)col.getFormatter();
+          if (f == null) f = new ToStringFormatter<>();
           jsonCols.add(f.format(col.getValue(dc, item)));
+        }

trunk/www/common/columns/configure.js

r7982	r8083
257	257	var url = 'add_relateditem_column.jsp?ID='+App.getSessionId();
258	258	url += '&item_type='+Data.get('page-data', 'item-type');
259		Dialogs.openPopup(url, 'SelectRelatedItemColumn', ~~600, 4~~00);
	259	Dialogs.openPopup(url, 'SelectRelatedItemColumn', 750, 500);
260	260	}
261	261

trunk/www/filemanager/files/list_files.jsp

r7983	r8083
1084	1084	list="<%=loader.getValues()%>"
1085	1085	suffix="<%=loader.getUnitSymbol()%>"
1086		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	1086	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
1087	1087	/><%
1088	1088	}

trunk/www/include/scripts/lazy-items.js

-                      r7982
+                      r8083
   lazy.initLazyItems = function()
+  {
     lazyElements = document.getElementsByClassName('lazy-item');
+    lazyElements = document.querySelectorAll('.lazy-item');
     if (lazyElements.length > 0)
+    {
 …
       if (subContext) url += '&subcontext='+encodeURIComponent(subContext);
       url += '&items='+lazyItems.join(',');
+      url += '&remaining='+(lazyElements.length-lazyNo);
       request.open("GET", url, true);
       request.send(null);
 …
       for (var col = 0; col < item.data.length; col++)
+      {
         var e = Doc.element('lazy-item-'+col+'-'+itemId);
+        var e = Doc.element('lazy-item-'+col+'-'+itemId).parentNode;
         if (e)
+        {
           e.innerHTML = item.data[col];
-          Doc.removeClass(e, 'loading');
-          Doc.removeClass(e, 'loaded');
           Doc.autoInitElements(e);
+        }

trunk/www/include/styles/main.css

-                      r7993
+                      r8083
 /* Generic button, standalone or in a toolbar, define colors only */
 .button, .tab
+.button, .tab, ::file-selector-button
+{
   background-color: #E8E8E8;
 …
 .interactable:hover, .interactable:focus, .interactable.active,
 input:hover, textarea:hover, select:hover, input:focus, textarea:focus, select:focus
+input:hover, textarea:hover, select:hover, input:focus, textarea:focus, select:focus, ::file-selector-button:hover
+{
   border-color: #2288AA;
 …
 /* A single standalone button */
 .basicbutton
+.basicbutton, ::file-selector-button
+{
   display: inline-block;
 …
+}
+/* We need some additional styling for resetting */
+::file-selector-button
+{
+  border-style: solid;
+  border-color: inherit;
+  margin-right: 4px;
+  padding-top: 2px;
+}
 .buttongroup .basicbutton
+{
 …
 /* Highlight the button when the mouse is over it */
 .basicbutton:hover, .basicbutton:focus
+.basicbutton:hover, .basicbutton:focus, ::file-selector-button:hover
+{
   /* 1+1=0+2 so that the button is not moving */
 …
   cursor: pointer;
+}
+::file-selector-button:hover
+{
+  /* Since we have 4px without hover */
+  margin-right: 3px;
+}
 .basicbutton.square
 …
+{
   background-color: #F8F8E8 !important;
+  color: inherit !important;
   border-top: 1px solid #2288AA !important;
   border-bottom: 1px solid #2288AA !important;
 …
+{
   background-color: #F8F8E8 !important;
+  color: inherit !important;
   border-top: 1px solid #2288AA !important;
   border-bottom: 1px solid #2288AA !important;

trunk/www/include/styles/table.css

r8026	r8083
260	260	}
261	261
262		.itemlist div.data th.relateditemcol.parentitem::before
	262	.itemlist div.data th.relateditemcol span.parentitem::before
263	263	{
264	264	content: url('../../images/parent-item.png');
265		}
266
267		.itemlist div.data th.relateditemcol.childitem::before
	265	margin: 0 1px;
	266	vertical-align: -1px;
	267	}
	268
	269	.itemlist div.data th.relateditemcol span.childitem::before
268	270	{
269	271	content: url('../../images/child-item.png');
	272	margin: 0 1px;
	273	vertical-align: -1px;
270	274	}
271	275

trunk/www/lims/arraybatches/list_batches.jsp

r7982	r8083
591	591	list="<%=loader.getValues()%>"
592	592	suffix="<%=loader.getUnitSymbol()%>"
593		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	593	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
594	594	/><%
595	595	}

trunk/www/lims/arraydesigns/list_designs.jsp

r8026	r8083
759	759	list="<%=loader.getValues()%>"
760	760	suffix="<%=loader.getUnitSymbol()%>"
761		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	761	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
762	762	/><%
763	763	}

trunk/www/lims/arrayslides/list_slides.jsp

r7982	r8083
576	576	list="<%=loader.getValues()%>"
577	577	suffix="<%=loader.getUnitSymbol()%>"
578		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	578	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
579	579	/><%
580	580	}

trunk/www/lims/plates/list_plates.jsp

r7982	r8083
651	651	list="<%=loader.getValues()%>"
652	652	suffix="<%=loader.getUnitSymbol()%>"
653		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	653	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
654	654	/><%
655	655	}

trunk/www/lims/plates/wells/list_wells.jsp

r7982	r8083
652	652	list="<%=loader.getValues()%>"
653	653	suffix="<%=loader.getUnitSymbol()%>"
654		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	654	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
655	655	/><%
656	656	}

trunk/www/my_base/projects/list_projects.jsp

r7982	r8083
472	472	list="<%=loader.getValues()%>"
473	473	suffix="<%=loader.getUnitSymbol()%>"
474		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	474	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
475	475	/><%
476	476	}

trunk/www/views/derivedbioassays/list_bioassays.jsp

r7982	r8083
818	818	list="<%=loader.getValues()%>"
819	819	suffix="<%=loader.getUnitSymbol()%>"
820		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	820	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
821	821	/><%
822	822	}

trunk/www/views/experiments/bioassays/list_bioassays.jsp

r7982	r8083
565	565	list="<%=loader.getValues()%>"
566	566	suffix="<%=loader.getUnitSymbol()%>"
567		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	567	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
568	568	/><%
569	569	}

trunk/www/views/experiments/bioassaysets/analysis_tree.jsp

r7982	r8083
846	846	list="<%=loader.getValues()%>"
847	847	suffix="<%=loader.getUnitSymbol()%>"
848		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	848	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
849	849	/><%
850	850	}

trunk/www/views/experiments/list_experiments.jsp

r7982	r8083
637	637	list="<%=loader.getValues()%>"
638	638	suffix="<%=loader.getUnitSymbol()%>"
639		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	639	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
640	640	/><%
641	641	}

trunk/www/views/itemlists/list_lists.jsp

r7982	r8083
617	617	list="<%=loader.getValues()%>"
618	618	suffix="<%=loader.getUnitSymbol()%>"
619		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	619	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
620	620	/><%
621	621	}

trunk/www/views/itemlists/members/list_members.jsp

r7982	r8083
607	607	list="<%=loader.getValues()%>"
608	608	suffix="<%=loader.getUnitSymbol()%>"
609		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	609	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
610	610	/><%
611	611	}

trunk/www/views/physicalbioassays/list_bioassays.jsp

r7982	r8083
766	766	list="<%=loader.getValues()%>"
767	767	suffix="<%=loader.getUnitSymbol()%>"
768		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	768	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
769	769	/><%
770	770	}

trunk/www/views/rawbioassays/list_rawbioassays.jsp

r7982	r8083
875	875	list="<%=loader.getValues()%>"
876	876	suffix="<%=loader.getUnitSymbol()%>"
877		clazz="<%=psInfo.~~overridesDefault~~Annotation() ? "ps-annotation" : null%>"
	877	clazz="<%=psInfo.hasProjectSpecificAnnotation() ? "ps-annotation" : null%>"
878	878	/><%
879	879	}

/branches/3.19-stable	merged: 8044,8046-8080
/tags/3.19.4 (added)	merged: 8081

Context Navigation

Legend:

Download in other formats: