X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FFeatureRenderer.java;h=5e654093f98d42efcc0681479cb7928307be7566;hb=952ae154954fe87b94cccb765d32718689b9e9a0;hp=c9cea86acacdad03d30f2ce12c3ea4b5d98d4f61;hpb=e0e8a9222165bd8e64119a5cda570eb6a7a91205;p=jalview.git

diff --git a/src/jalview/appletgui/FeatureRenderer.java b/src/jalview/appletgui/FeatureRenderer.java
index c9cea86..5e65409 100755
--- a/src/jalview/appletgui/FeatureRenderer.java
+++ b/src/jalview/appletgui/FeatureRenderer.java
@@ -22,6 +22,10 @@ import java.util.*;
 
 import java.awt.*;
 
+import java.awt.event.*;
+
+
+import jalview.appletgui.FeatureSettings.MyCheckbox;
 import jalview.datamodel.*;
 
 /**
@@ -80,85 +84,361 @@ public class FeatureRenderer
     transparency = fr.transparency;
   }
 
-  public Color findFeatureColour(Color initialCol, SequenceI seq, int i)
+
+  static String lastFeatureAdded;
+  static String lastFeatureGroupAdded;
+  static String lastDescriptionAdded;
+
+  int featureIndex = 0;
+  boolean deleteFeature = false;
+  Panel colourPanel;
+  boolean amendFeatures(final SequenceI[] sequences,
+                        final SequenceFeature[] features,
+                        boolean newFeatures,
+                        final AlignmentPanel ap)
   {
-    overview = true;
-    if (!av.showSequenceFeatures)
+    Panel bigPanel = new Panel(new BorderLayout());
+    final TextField name = new TextField(16);
+    final TextField source = new TextField(16);
+    final TextArea description = new TextArea(3, 35);
+    final TextField start = new TextField(8);
+    final TextField end = new TextField(8);
+    final Choice overlaps;
+    Button deleteButton = new Button("Delete");
+    deleteFeature = false;
+
+    colourPanel = new Panel(null);
+    colourPanel.setSize(110,15);
+    final FeatureRenderer fr = this;
+
+    Panel panel = new Panel(new GridLayout(3, 1));
+
+    Panel tmp;
+
+    ///////////////////////////////////////
+    ///MULTIPLE FEATURES AT SELECTED RESIDUE
+    if(!newFeatures && features.length>1)
     {
-      return initialCol;
+     panel = new Panel(new GridLayout(4, 1));
+     tmp = new Panel();
+     tmp.add(new Label("Select Feature: "));
+     overlaps = new Choice();
+     for(int i=0; i<features.length; i++)
+     {
+       String item = features[i].getType()
+        +"/"+features[i].getBegin()+"-"+features[i].getEnd();
+
+       if(features[i].getFeatureGroup()!=null)
+         item += " ("+features[i].getFeatureGroup()+")";
+
+       overlaps.addItem(item);
+     }
+
+     tmp.add(overlaps);
+
+     overlaps.addItemListener(new java.awt.event.ItemListener()
+     {
+       public void itemStateChanged(java.awt.event.ItemEvent e)
+       {
+         int index = overlaps.getSelectedIndex();
+         if (index != -1)
+         {
+           featureIndex = index;
+           name.setText(features[index].getType());
+           description.setText(features[index].getDescription());
+           source.setText(features[index].getFeatureGroup());
+           start.setText(features[index].getBegin()+"");
+           end.setText(features[index].getEnd()+"");
+
+           SearchResults highlight = new SearchResults();
+           highlight.addResult(sequences[0],
+                               features[index].getBegin(),
+                               features[index].getEnd());
+
+           ap.seqPanel.seqCanvas.highlightSearchResults(highlight);
+
+         }
+         Color col = getColour(name.getText());
+         if (col == null)
+         {
+           col = new
+               jalview.schemes.UserColourScheme()
+               .createColourFromName(name.getText());
+         }
+
+         colourPanel.setBackground(col);
+       }
+     });
+
+
+     panel.add(tmp);
     }
+    //////////
+    //////////////////////////////////////
 
-    lastSequence = seq;
-    sequenceFeatures = lastSequence.getSequenceFeatures();
-    if (sequenceFeatures == null)
+
+    tmp = new Panel();
+    panel.add(tmp);
+    tmp.add(new Label("Name: ", Label.RIGHT));
+    tmp.add(name);
+
+    tmp = new Panel();
+    panel.add(tmp);
+    tmp.add(new Label("Group: ",Label.RIGHT));
+    tmp.add(source);
+
+    tmp = new Panel();
+    panel.add(tmp);
+    tmp.add(new Label("Colour: ", Label.RIGHT));
+    tmp.add(colourPanel);
+
+    bigPanel.add(panel, BorderLayout.NORTH);
+
+    panel = new Panel();
+    panel.add(new Label("Description: ", Label.RIGHT));
+    panel.add(new ScrollPane().add(description));
+
+    if (!newFeatures)
     {
-      return initialCol;
+      bigPanel.add(panel, BorderLayout.SOUTH);
+
+      panel = new Panel();
+      panel.add(new Label(" Start:", Label.RIGHT));
+      panel.add(start);
+      panel.add(new Label("  End:", Label.RIGHT));
+      panel.add(end);
+      bigPanel.add(panel, BorderLayout.CENTER);
+    }
+    else
+    {
+      bigPanel.add(panel, BorderLayout.CENTER);
     }
 
-    sfSize = sequenceFeatures.length;
+    if (lastFeatureAdded == null)
+    {
+      if (features[0].type != null)
+      {
+        lastFeatureAdded = features[0].type;
+      }
+      else
+      {
+        lastFeatureAdded = "feature_1";
+      }
+    }
 
-    if (jalview.util.Comparison.isGap(lastSequence.getCharAt(i)))
+    if (lastFeatureGroupAdded == null)
     {
-      return Color.white;
+      if (features[0].featureGroup != null)
+      {
+        lastFeatureGroupAdded = features[0].featureGroup;
+      }
+      else
+      {
+        lastFeatureAdded = "Jalview";
+      }
     }
 
-    currentColour = null;
 
-    drawSequence(null, lastSequence, lastSequence.findPosition(i), -1, -1);
+    String title = newFeatures ? "Create New Sequence Feature(s)" :
+        "Amend/Delete Features for "
+        + sequences[0].getName();
 
-    if (currentColour == null)
+    final JVDialog dialog = new JVDialog(ap.alignFrame,
+                               title,
+                               true,
+                               385,240);
+
+    dialog.setMainPanel(bigPanel);
+
+    if(newFeatures)
     {
-      return initialCol;
+      name.setText(lastFeatureAdded);
+      source.setText(lastFeatureGroupAdded);
+    }
+    else
+    {
+      dialog.ok.setLabel("Amend");
+      dialog.buttonPanel.add(deleteButton, 1);
+      deleteButton.addActionListener(new ActionListener()
+          {
+            public void actionPerformed(ActionEvent evt)
+            {
+              deleteFeature = true;
+              dialog.setVisible(false);
+            }
+          });
+      name.setText(features[0].getType());
+      source.setText(features[0].getFeatureGroup());
     }
 
-    return new Color( ( (Integer) currentColour).intValue());
+    start.setText(features[0].getBegin()+"");
+    end.setText(features[0].getEnd()+"");
+    description.setText(features[0].getDescription());
+
+    Color col = getColour(name.getText());
+    if (col == null)
+    {
+      col = new
+          jalview.schemes.UserColourScheme()
+          .createColourFromName(name.getText());
+    }
+
+    colourPanel.setBackground(col);
+
+    dialog.setResizable(true);
+
+
+    colourPanel.addMouseListener(new java.awt.event.MouseAdapter()
+    {
+      public void mousePressed(java.awt.event.MouseEvent evt)
+      {
+        new UserDefinedColours(fr, ap.alignFrame);
+      }
+    });
+
+    dialog.setVisible(true);
+
+    jalview.io.FeaturesFile ffile = new jalview.io.FeaturesFile();
+
+    if (dialog.accept)
+    {
+      //This ensures that the last sequence
+      //is refreshed and new features are rendered
+      lastSeq = null;
+      lastFeatureAdded = name.getText().trim();
+      lastFeatureGroupAdded = source.getText().trim();
+      lastDescriptionAdded = description.getText().replace('\n', ' ');
+    }
+
+    if(lastFeatureGroupAdded !=null && lastFeatureGroupAdded.length()<1)
+      lastFeatureGroupAdded = null;
+
+
+    if (!newFeatures)
+    {
+      SequenceFeature sf = features[featureIndex];
+
+      if (dialog.accept)
+      {
+        sf.type = lastFeatureAdded;
+        sf.featureGroup = lastFeatureGroupAdded;
+        sf.description = lastDescriptionAdded;
+        setColour(sf.type, colourPanel.getBackground());
+        try
+        {
+          sf.begin = Integer.parseInt(start.getText());
+          sf.end =  Integer.parseInt(end.getText());
+        }
+        catch (NumberFormatException ex)
+        {}
+
+        ffile.parseDescriptionHTML(sf, false);
+      }
+      if (deleteFeature)
+      {
+        sequences[0].deleteFeature(sf);
+      }
+
+    }
+    else
+    {
+      if (dialog.accept && name.getText().length()>0)
+      {
+        for (int i = 0; i < sequences.length; i++)
+        {
+          features[i].type = lastFeatureAdded;
+          features[i].featureGroup = lastFeatureGroupAdded;
+          features[i].description = lastDescriptionAdded;
+          sequences[i].addSequenceFeature(features[i]);
+          ffile.parseDescriptionHTML(features[i], false);
+        }
+
+        if (av.featuresDisplayed == null)
+        {
+          av.featuresDisplayed = new Hashtable();
+        }
+
+        if (featureGroups == null)
+        {
+          featureGroups = new Hashtable();
+        }
+
+        col = colourPanel.getBackground();
+        setColour(lastFeatureAdded, col);
+
+        if(lastFeatureGroupAdded!=null)
+        {
+          featureGroups.put(lastFeatureGroupAdded, new Boolean(true));
+          av.featuresDisplayed.put(lastFeatureGroupAdded,
+                                   new Integer(col.getRGB()));
+        }
+        findAllFeatures();
+
+        String [] tro = new String[renderOrder.length];
+        tro[0] = renderOrder[renderOrder.length-1];
+        System.arraycopy(renderOrder,0,tro,1,renderOrder.length-1);
+        renderOrder = tro;
+
+        ap.paintAlignment(true);
+
+        return true;
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    findAllFeatures();
+
+    ap.paintAlignment(true);
+
+    return true;
   }
 
-  /**
-   * This is used by the Molecule Viewer to get the accurate colour
-   * of the rendered sequence
-   */
-  boolean overview = false;
 
-  int white = Color.white.getRGB();
-  public int findFeatureColour(int initialCol, int seqIndex, int column)
+  public Color findFeatureColour(Color initialCol, SequenceI seq, int i)
   {
+    overview = true;
     if (!av.showSequenceFeatures)
     {
       return initialCol;
     }
 
-    if (seqIndex != lastSequenceIndex)
+    lastSeq = seq;
+    sequenceFeatures = lastSeq.getSequenceFeatures();
+    if (sequenceFeatures == null)
     {
-      lastSequence = av.alignment.getSequenceAt(seqIndex);
-      lastSequenceIndex = seqIndex;
-      sequenceFeatures = lastSequence.getSequenceFeatures();
-      if (sequenceFeatures == null)
-      {
-        return initialCol;
-      }
-
-      sfSize = sequenceFeatures.length;
+      return initialCol;
     }
 
-    if (jalview.util.Comparison.isGap(lastSequence.getCharAt(column)))
+    sfSize = sequenceFeatures.length;
+
+    if (jalview.util.Comparison.isGap(lastSeq.getCharAt(i)))
     {
-      return Color.white.getRGB();
+      return Color.white;
     }
 
     currentColour = null;
 
-    drawSequence(null, lastSequence, lastSequence.findPosition(column), -1, -1);
+    drawSequence(null, lastSeq, lastSeq.findPosition(i), -1, -1);
 
     if (currentColour == null)
     {
       return initialCol;
     }
 
-    return ( (Integer) currentColour).intValue();
+    return new Color( ( (Integer) currentColour).intValue());
   }
 
   /**
+   * This is used by the Molecule Viewer to get the accurate colour
+   * of the rendered sequence
+   */
+  boolean overview = false;
+
+
+  /**
    * DOCUMENT ME!
    *
    * @param g DOCUMENT ME!
@@ -173,12 +453,12 @@ public class FeatureRenderer
    */
   // String type;
   // SequenceFeature sf;
-  int lastSequenceIndex = -1;
-  SequenceI lastSequence;
+
+  SequenceI lastSeq;
   SequenceFeature[] sequenceFeatures;
   int sfSize, sfindex, spos, epos;
 
-  public void drawSequence(Graphics g, SequenceI seq,
+  synchronized public void drawSequence(Graphics g, SequenceI seq,
                            int start, int end, int y1)
   {
     if (seq.getSequenceFeatures() == null
@@ -191,10 +471,10 @@ public class FeatureRenderer
     {
       transparencySetter.setTransparency(g, transparency);
     }
-    
-    if (lastSequence == null || seq != lastSequence || sequenceFeatures!=seq.getSequenceFeatures())
+
+    if (lastSeq == null || seq != lastSeq || sequenceFeatures!=seq.getSequenceFeatures())
     {
-      lastSequence = seq;
+      lastSeq = seq;
       sequenceFeatures = seq.getSequenceFeatures();
       sfSize = sequenceFeatures.length;
     }
@@ -212,8 +492,8 @@ public class FeatureRenderer
     }
     if (!overview)
     {
-      spos = lastSequence.findPosition(start);
-      epos = lastSequence.findPosition(end);
+      spos = lastSeq.findPosition(start);
+      epos = lastSeq.findPosition(end);
       if (g != null)
       {
         fm = g.getFontMetrics();
@@ -351,7 +631,7 @@ public class FeatureRenderer
   {
     jalview.schemes.UserColourScheme ucs = new
         jalview.schemes.UserColourScheme();
-    
+
     av.featuresDisplayed = new Hashtable();
     Vector allfeatures = new Vector();
     for (int i = 0; i < av.alignment.getHeight(); i++)
@@ -397,21 +677,19 @@ public class FeatureRenderer
 
   public Color getColour(String featureType)
   {
-    return (Color) featureColours.get(featureType);
-  }
-
-  public void addNewFeature(String name, Color col)
-  {
-
-    setColour(name, col);
-    if (av.featuresDisplayed == null)
+    if (!featureColours.containsKey(featureType))
     {
-      av.featuresDisplayed = new Hashtable();
+      jalview.schemes.UserColourScheme ucs = new
+          jalview.schemes.UserColourScheme();
+      Color col = ucs.createColourFromName(featureType);
+      featureColours.put(featureType, col);
+      return col;
     }
-
-    av.featuresDisplayed.put(name, "NOGROUP");
+    else
+      return (Color) featureColours.get(featureType);
   }
 
+
   public void setColour(String featureType, Color col)
   {
     featureColours.put(featureType, col);
@@ -427,6 +705,23 @@ public class FeatureRenderer
       av.featuresDisplayed.clear();
     }
 
+   /* if (visibleNew)
+    {
+      if (av.featuresDisplayed != null)
+      {
+        av.featuresDisplayed.clear();
+      }
+      else
+      {
+        av.featuresDisplayed = new Hashtable();
+      }
+    }
+    if (data == null)
+    {
+      return;
+    }*/
+
+
     renderOrder = new String[data.length];
 
     if (data.length > 0)
@@ -444,6 +739,228 @@ public class FeatureRenderer
       }
     }
   }
+  /**
+   * @return a simple list of feature group names or null 
+   */
+  public String[] getGroups()
+  {
+    buildGroupHash();
+    if (featureGroups!=null)
+    {
+      String[] gps = new String[featureGroups.size()];
+      Enumeration gn = featureGroups.keys();
+      int i=0;
+      while (gn.hasMoreElements())
+      {
+        gps[i++]  = (String) gn.nextElement();
+      }
+      return gps;
+    }
+    return null;
+  }
+  /**
+   * get visible or invisible groups
+   * @param visible true to return visible groups, false to return hidden ones.
+   * @return list of groups
+   */
+  public String[] getGroups(boolean visible) 
+  {
+    buildGroupHash();
+    if (featureGroups!=null)
+    {
+      Vector gp = new Vector();
+      
+      Enumeration gn = featureGroups.keys();
+      while (gn.hasMoreElements())
+      {
+        String nm = (String) gn.nextElement();
+        Boolean state = (Boolean) featureGroups.get(nm);
+        if (state.booleanValue()==visible)
+        {
+          gp.addElement(nm);
+        }
+      }
+      String[] gps = new String[gp.size()];
+      gp.copyInto(gps);
+      
+      int i=0;
+      while (gn.hasMoreElements())
+      {
+        gps[i++]  = (String) gn.nextElement();
+      }
+      return gps;
+    }
+    return null;
+  }
+  /**
+   * set all feature groups in toset to be visible or invisible
+   * @param toset group names
+   * @param visible the state of the named groups to set
+   */
+  public void setGroupState(String[] toset, boolean visible)
+  {
+    buildGroupHash();
+    if (toset!=null && toset.length>0 && featureGroups!=null)
+    {
+      boolean rdrw = false;
+      for (int i=0;i<toset.length; i++)
+      {
+        Object st = featureGroups.get(toset[i]);
+        if (st!=null)
+        {
+          featureGroups.put(toset[i], new Boolean(visible));
+          rdrw = rdrw || (visible!=((Boolean) st).booleanValue());
+        }
+      }
+      if (rdrw)
+      {
+        if (this.av!=null)
+          if (this.av.featureSettings!=null)
+          {
+            av.featureSettings.rebuildGroups();
+            this.av.featureSettings.resetTable(true);
+          } else {
+            buildFeatureHash();
+          }
+          if (av!=null)
+          {
+            av.alignmentChanged(null);
+          }
+      }
+    }
+  }
+  /**
+   * analyse alignment for groups and hash tables
+   * (used to be embedded in FeatureSettings.setTableData)
+   * @return true if features are on the alignment
+   */
+  public boolean buildGroupHash()
+  {
+    boolean alignmentHasFeatures=false;
+    if (featureGroups == null)
+    {
+      featureGroups = new Hashtable();
+    }
+    Vector allFeatures = new Vector();
+    Vector allGroups = new Vector();
+    SequenceFeature[] tmpfeatures;
+    String group;
+    for (int i = 0; i < av.alignment.getHeight(); i++)
+    {
+      if (av.alignment.getSequenceAt(i).getSequenceFeatures() == null)
+      {
+        continue;
+      }
+
+      alignmentHasFeatures = true;
+
+      tmpfeatures = av.alignment.getSequenceAt(i).getSequenceFeatures();
+      int index = 0;
+      while (index < tmpfeatures.length)
+      {
+        if (tmpfeatures[index].getFeatureGroup() != null)
+        {
+          group = tmpfeatures[index].featureGroup;
+          if (!allGroups.contains(group))
+          {
+            allGroups.addElement(group);
+
+            boolean visible = true;
+            if (featureGroups.containsKey(group))
+            {
+              visible = ( (Boolean) featureGroups.get(group)).booleanValue();
+            } else {
+              featureGroups.put(group, new Boolean(visible));
+            }
+          }
+        }
+
+        if (!allFeatures.contains(tmpfeatures[index].getType()))
+        {
+          allFeatures.addElement(tmpfeatures[index].getType());
+        }
+        index++;
+      }
+    }
+    
+    return alignmentHasFeatures;
+  }
+  /**
+   * rebuild the featuresDisplayed and renderorder list based on the featureGroups hash and any existing display state
+   * and force a repaint if necessary
+   * @return true if alignment has visible features
+   */
+  public boolean buildFeatureHash() {
+    boolean alignmentHasFeatures=false;
+    if (featureGroups==null)
+    {
+      alignmentHasFeatures = buildGroupHash();
+    }
+    if (!alignmentHasFeatures)
+      return false;
+    Hashtable fdisp = av.featuresDisplayed;
+    Vector allFeatures = new Vector();
+    SequenceFeature[] tmpfeatures;
+    String group;
+    for (int i = 0; i < av.alignment.getHeight(); i++)
+    {
+      if (av.alignment.getSequenceAt(i).getSequenceFeatures() == null)
+      {
+        continue;
+      }
+
+      alignmentHasFeatures = true;
+
+      tmpfeatures = av.alignment.getSequenceAt(i).getSequenceFeatures();
+      int index = 0;
+      while (index < tmpfeatures.length)
+      {
+        boolean visible = true;
+        if (tmpfeatures[index].getFeatureGroup() != null)
+        {
+          group = tmpfeatures[index].featureGroup;
+          if (featureGroups.containsKey(group))
+          {
+            visible = ( (Boolean) featureGroups.get(group)).booleanValue();
+          }
+        }
+        
+        if (visible && !allFeatures.contains(tmpfeatures[index].getType()))
+        {
+          allFeatures.addElement(tmpfeatures[index].getType());
+        }
+        index++;
+      }
+    }
+    if (allFeatures.size()>0)
+    {
+      String[] neworder = new String[allFeatures.size()];
+      int p=neworder.length-1;
+      for (int i=renderOrder.length-1; i>=0; i--)
+      {
+        if (allFeatures.contains(renderOrder[i]))
+        {
+          neworder[p--] = renderOrder[i];
+          allFeatures.removeElement(renderOrder[i]);
+        } else {
+          av.featuresDisplayed.remove(renderOrder[i]);
+        }
+      }
+      for (int i=allFeatures.size()-1; i>0; i++)
+      {
+        Object e = allFeatures.elementAt(i);
+        if (e!=null)
+        {
+          neworder[p--] = (String) e;
+          av.featuresDisplayed.put(e, getColour((String)e));
+        }
+      }
+      renderOrder = neworder;
+      return true;
+    }
+    
+    return alignmentHasFeatures;
+  }
 }
 
 class TransparencySetter