src/jalview/controller/AlignViewController.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.controller;
  22
  23 import jalview.analysis.AlignmentSorter;
  24 import jalview.api.AlignViewControllerGuiI;
  25 import jalview.api.AlignViewControllerI;
  26 import jalview.api.AlignViewportI;
  27 import jalview.api.AlignmentViewPanel;
  28 import jalview.api.FeatureRenderer;
  29 import jalview.commands.OrderCommand;
  30 import jalview.datamodel.AlignmentI;
  31 import jalview.datamodel.ColumnSelection;
  32 import jalview.datamodel.SequenceCollectionI;
  33 import jalview.datamodel.SequenceFeature;
  34 import jalview.datamodel.SequenceGroup;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.io.DataSourceType;
  37 import jalview.io.FeaturesFile;
  38 import jalview.util.MessageManager;
  39 import jalview.viewmodel.seqfeatures.FeatureRendererModel;
  40
  41 import java.awt.Color;
  42 import java.util.BitSet;
  43 import java.util.List;
  44
  45 public class AlignViewController implements AlignViewControllerI
  46 {
  47   AlignViewportI viewport = null;
  48
  49   AlignmentViewPanel alignPanel = null;
  50
  51   /**
  52    * the GUI container that is handling interactions with the user
  53    */
  54   private AlignViewControllerGuiI avcg;
  55
  56   public AlignViewController(AlignViewControllerGuiI alignFrame,
  57           AlignViewportI viewport, AlignmentViewPanel alignPanel)
  58   {
  59     this.avcg = alignFrame;
  60     this.viewport = viewport;
  61     this.alignPanel = alignPanel;
  62   }
  63
  64   @Override
  65   public void setViewportAndAlignmentPanel(AlignViewportI viewport,
  66           AlignmentViewPanel alignPanel)
  67   {
  68     this.alignPanel = alignPanel;
  69     this.viewport = viewport;
  70
  71   }
  72
  73   @Override
  74   public boolean makeGroupsFromSelection()
  75   {
  76     SequenceGroup sg = viewport.getSelectionGroup();
  77     ColumnSelection cs = viewport.getColumnSelection();
  78     SequenceGroup[] gps = null;
  79     if (sg != null && (cs == null || cs.isEmpty()))
  80     {
  81       gps = jalview.analysis.Grouping.makeGroupsFrom(
  82               viewport.getSequenceSelection(),
  83               viewport.getAlignmentView(true)
  84                       .getSequenceStrings(viewport.getGapCharacter()),
  85               viewport.getAlignment().getGroups());
  86     }
  87     else
  88     {
  89       if (cs != null)
  90       {
  91         gps = jalview.analysis.Grouping.makeGroupsFromCols(
  92                 (sg == null) ? viewport.getAlignment().getSequencesArray()
  93                         : sg.getSequences().toArray(new SequenceI[0]),
  94                 cs, viewport.getAlignment().getGroups());
  95       }
  96     }
  97     if (gps != null)
  98     {
  99       viewport.getAlignment().deleteAllGroups();
 100       viewport.clearSequenceColours();
 101       viewport.setSelectionGroup(null);
 102       // set view properties for each group
 103       for (int g = 0; g < gps.length; g++)
 104       {
 105         // gps[g].setShowunconserved(viewport.getShowUnconserved());
 106         gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo());
 107         viewport.getAlignment().addGroup(gps[g]);
 108         Color col = new Color((int) (Math.random() * 255),
 109                 (int) (Math.random() * 255), (int) (Math.random() * 255));
 110         col = col.brighter();
 111         for (SequenceI sq : gps[g].getSequences(null))
 112         {
 113           viewport.setSequenceColour(sq, col);
 114         }
 115       }
 116       return true;
 117     }
 118     return false;
 119   }
 120
 121   @Override
 122   public boolean createGroup()
 123   {
 124
 125     SequenceGroup sg = viewport.getSelectionGroup();
 126     if (sg != null)
 127     {
 128       viewport.getAlignment().addGroup(sg);
 129       return true;
 130     }
 131     return false;
 132   }
 133
 134   @Override
 135   public boolean unGroup()
 136   {
 137     SequenceGroup sg = viewport.getSelectionGroup();
 138     if (sg != null)
 139     {
 140       viewport.getAlignment().deleteGroup(sg);
 141       return true;
 142     }
 143     return false;
 144   }
 145
 146   @Override
 147   public boolean deleteGroups()
 148   {
 149     if (viewport.getAlignment().getGroups() != null
 150             && viewport.getAlignment().getGroups().size() > 0)
 151     {
 152       viewport.getAlignment().deleteAllGroups();
 153       viewport.clearSequenceColours();
 154       viewport.setSelectionGroup(null);
 155       return true;
 156     }
 157     return false;
 158   }
 159
 160   @Override
 161   public boolean markColumnsContainingFeatures(boolean invert,
 162           boolean extendCurrent, boolean toggle, String featureType)
 163   {
 164     // JBPNote this routine could also mark rows, not just columns.
 165     // need a decent query structure to allow all types of feature searches
 166     BitSet bs = new BitSet();
 167     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null
 168             || extendCurrent) ? viewport.getAlignment()
 169                     : viewport.getSelectionGroup();
 170
 171     int nseq = findColumnsWithFeature(featureType, sqcol, bs);
 172
 173     ColumnSelection cs = viewport.getColumnSelection();
 174     if (cs == null)
 175     {
 176       cs = new ColumnSelection();
 177     }
 178
 179     if (bs.cardinality() > 0 || invert)
 180     {
 181       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 182               sqcol.getEndRes(), invert, extendCurrent, toggle);
 183       if (changed)
 184       {
 185         viewport.setColumnSelection(cs);
 186         alignPanel.paintAlignment(false, false);
 187         int columnCount = invert
 188                 ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 189                         - bs.cardinality()
 190                 : bs.cardinality();
 191         avcg.setStatus(MessageManager.formatMessage(
 192                 "label.view_controller_toggled_marked", new String[]
 193                 { toggle ? MessageManager.getString("label.toggled")
 194                         : MessageManager.getString("label.marked"),
 195                     String.valueOf(columnCount),
 196                     invert ? MessageManager
 197                             .getString("label.not_containing")
 198                             : MessageManager.getString("label.containing"),
 199                     featureType, Integer.valueOf(nseq).toString() }));
 200         return true;
 201       }
 202     }
 203     else
 204     {
 205       avcg.setStatus(MessageManager
 206               .formatMessage("label.no_feature_of_type_found", new String[]
 207               { featureType }));
 208       if (!extendCurrent)
 209       {
 210         cs.clear();
 211         alignPanel.paintAlignment(false, false);
 212       }
 213     }
 214     return false;
 215   }
 216
 217   /**
 218    * Sets a bit in the BitSet for each column (base 0) in the sequence
 219    * collection which includes the specified feature type. Returns the number of
 220    * sequences which have the feature in the selected range.
 221    *
 222    * @param featureType
 223    * @param sqcol
 224    * @param bs
 225    * @return
 226    */
 227   int findColumnsWithFeature(String featureType,
 228           SequenceCollectionI sqcol, BitSet bs)
 229   {
 230     FeatureRendererModel fr = (FeatureRendererModel) alignPanel
 231             .getFeatureRenderer();
 232     List<String> visibleFeatures = fr.getDisplayedFeatureTypes();
 233
 234     final int startColumn = sqcol.getStartRes() + 1; // converted to base 1
 235     final int endColumn = sqcol.getEndRes() + 1;
 236     List<SequenceI> seqs = sqcol.getSequences();
 237     int nseq = 0;
 238     for (SequenceI sq : seqs)
 239     {
 240       if (sq != null)
 241       {
 242         // int ist = sq.findPosition(sqcol.getStartRes());
 243         List<SequenceFeature> sfs = sq.findFeatures(startColumn,
 244                 endColumn, featureType);
 245
 246         if (!sfs.isEmpty())
 247         {
 248           nseq++;
 249         }
 250
 251         for (SequenceFeature sf : sfs)
 252         {
 253           {
 254             if (!visibleFeatures.contains(sf.getType())
 255                     || fr.getColour(sf) == null) // could pull up getColour to FeatureRenderer interface
 256             {
 257               continue;
 258             }
 259           }
 260           int sfStartCol = sq.findIndex(sf.getBegin());
 261           int sfEndCol = sq.findIndex(sf.getEnd());
 262
 263           if (sf.isContactFeature())
 264           {
 265             /*
 266              * 'contact' feature - check for 'start' or 'end'
 267              * position within the selected region
 268              */
 269             if (sfStartCol >= startColumn && sfStartCol <= endColumn)
 270             {
 271               bs.set(sfStartCol - 1);
 272             }
 273             if (sfEndCol >= startColumn && sfEndCol <= endColumn)
 274             {
 275               bs.set(sfEndCol - 1);
 276             }
 277             continue;
 278           }
 279
 280           /*
 281            * contiguous feature - select feature positions (if any)
 282            * within the selected region
 283            */
 284           if (sfStartCol < startColumn)
 285           {
 286             sfStartCol = startColumn;
 287           }
 288           // not sure what the point of this is
 289           // if (sfStartCol < ist)
 290           // {
 291           // sfStartCol = ist;
 292           // }
 293           if (sfEndCol > endColumn)
 294           {
 295             sfEndCol = endColumn;
 296           }
 297           for (; sfStartCol <= sfEndCol; sfStartCol++)
 298           {
 299             bs.set(sfStartCol - 1); // convert to base 0
 300           }
 301         }
 302       }
 303     }
 304     return nseq;
 305   }
 306
 307   @Override
 308   public void sortAlignmentByFeatureDensity(List<String> typ)
 309   {
 310     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
 311   }
 312
 313   protected void sortBy(List<String> typ, String methodText,
 314           final String method)
 315   {
 316     FeatureRenderer fr = alignPanel.getFeatureRenderer();
 317     if (typ == null && fr != null)
 318     {
 319       typ = fr.getDisplayedFeatureTypes();
 320     }
 321     List<String> gps = null;
 322     if (fr != null)
 323     {
 324       gps = fr.getDisplayedFeatureGroups();
 325     }
 326     AlignmentI al = viewport.getAlignment();
 327
 328     int start, stop;
 329     SequenceGroup sg = viewport.getSelectionGroup();
 330     if (sg != null)
 331     {
 332       start = sg.getStartRes();
 333       stop = sg.getEndRes();
 334     }
 335     else
 336     {
 337       start = 0;
 338       stop = al.getWidth();
 339     }
 340     SequenceI[] oldOrder = al.getSequencesArray();
 341     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
 342     avcg.addHistoryItem(new OrderCommand(methodText, oldOrder,
 343             viewport.getAlignment()));
 344     alignPanel.paintAlignment(true, false);
 345
 346   }
 347
 348   @Override
 349   public void sortAlignmentByFeatureScore(List<String> typ)
 350   {
 351     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
 352   }
 353
 354   @Override
 355   public boolean parseFeaturesFile(String file, DataSourceType protocol,
 356           boolean relaxedIdMatching)
 357   {
 358     boolean featuresFile = false;
 359     try
 360     {
 361       featuresFile = new FeaturesFile(false, file, protocol).parse(
 362               viewport.getAlignment().getDataset(),
 363               alignPanel.getFeatureRenderer().getFeatureColours(), false,
 364               relaxedIdMatching);
 365     } catch (Exception ex)
 366     {
 367       ex.printStackTrace();
 368     }
 369
 370     if (featuresFile)
 371     {
 372       avcg.refreshFeatureUI(true);
 373       if (alignPanel.getFeatureRenderer() != null)
 374       {
 375         // update the min/max ranges where necessary
 376         alignPanel.getFeatureRenderer().findAllFeatures(true);
 377       }
 378       if (avcg.getFeatureSettingsUI() != null)
 379       {
 380         avcg.getFeatureSettingsUI().discoverAllFeatureData();
 381       }
 382       alignPanel.paintAlignment(true, true);
 383     }
 384
 385     return featuresFile;
 386
 387   }
 388
 389   @Override
 390   public boolean markHighlightedColumns(boolean invert,
 391           boolean extendCurrent, boolean toggle)
 392   {
 393     if (!viewport.hasSearchResults())
 394     {
 395       // do nothing if no selection exists
 396       return false;
 397     }
 398     // JBPNote this routine could also mark rows, not just columns.
 399     BitSet bs = new BitSet();
 400     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null
 401             || extendCurrent) ? viewport.getAlignment()
 402                     : viewport.getSelectionGroup();
 403
 404     // this could be a lambda... - the remains of the method is boilerplate,
 405     // except for the different messages for reporting selection.
 406     int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
 407
 408     ColumnSelection cs = viewport.getColumnSelection();
 409     if (cs == null)
 410     {
 411       cs = new ColumnSelection();
 412     }
 413
 414     if (bs.cardinality() > 0 || invert)
 415     {
 416       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 417               sqcol.getEndRes(), invert, extendCurrent, toggle);
 418       if (changed)
 419       {
 420         viewport.setColumnSelection(cs);
 421         alignPanel.paintAlignment(false, false);
 422         int columnCount = invert
 423                 ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 424                         - bs.cardinality()
 425                 : bs.cardinality();
 426         avcg.setStatus(MessageManager.formatMessage(
 427                 "label.view_controller_toggled_marked", new String[]
 428                 { toggle ? MessageManager.getString("label.toggled")
 429                         : MessageManager.getString("label.marked"),
 430                     String.valueOf(columnCount),
 431                     invert ? MessageManager
 432                             .getString("label.not_containing")
 433                             : MessageManager.getString("label.containing"),
 434                     "Highlight", Integer.valueOf(nseq).toString() }));
 435         return true;
 436       }
 437     }
 438     else
 439     {
 440       avcg.setStatus(MessageManager
 441               .formatMessage("No highlighted regions marked"));
 442       if (!extendCurrent)
 443       {
 444         cs.clear();
 445         alignPanel.paintAlignment(false, false);
 446       }
 447     }
 448     return false;
 449   }
 450
 451 }