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.SearchResultsI;
  33 import jalview.datamodel.SequenceCollectionI;
  34 import jalview.datamodel.SequenceFeature;
  35 import jalview.datamodel.SequenceGroup;
  36 import jalview.datamodel.SequenceI;
  37 import jalview.io.DataSourceType;
  38 import jalview.io.FeaturesFile;
  39 import jalview.util.MessageManager;
  40
  41 import java.awt.Color;
  42 import java.util.ArrayList;
  43 import java.util.BitSet;
  44 import java.util.List;
  45
  46 public class AlignViewController implements AlignViewControllerI
  47 {
  48   AlignViewportI viewport = null;
  49
  50   AlignmentViewPanel alignPanel = null;
  51
  52   /**
  53    * the GUI container that is handling interactions with the user
  54    */
  55   private AlignViewControllerGuiI avcg;
  56
  57   public AlignViewController(AlignViewControllerGuiI alignFrame,
  58           AlignViewportI vp, AlignmentViewPanel ap)
  59   {
  60     this.avcg = alignFrame;
  61     this.viewport = vp;
  62     this.alignPanel = ap;
  63   }
  64
  65   @Override
  66   public void setViewportAndAlignmentPanel(AlignViewportI vp,
  67           AlignmentViewPanel ap)
  68   {
  69     this.alignPanel = ap;
  70     this.viewport = vp;
  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 a visible feature of the specified feature type.
 220    * Returns the number of sequences which have the feature visible in the
 221    * selected range.
 222    *
 223    * @param featureType
 224    * @param sqcol
 225    * @param bs
 226    * @return
 227    */
 228   int findColumnsWithFeature(String featureType,
 229           SequenceCollectionI sqcol, BitSet bs)
 230   {
 231     FeatureRenderer fr = alignPanel == null ? null : alignPanel
 232             .getFeatureRenderer();
 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         boolean found = false;
 247         for (SequenceFeature sf : sfs)
 248         {
 249           if (fr.getColour(sf) == null)
 250           {
 251             continue;
 252           }
 253           if (!found)
 254           {
 255             nseq++;
 256           }
 257           found = true;
 258
 259           int sfStartCol = sq.findIndex(sf.getBegin());
 260           int sfEndCol = sq.findIndex(sf.getEnd());
 261
 262           if (sf.isContactFeature())
 263           {
 264             /*
 265              * 'contact' feature - check for 'start' or 'end'
 266              * position within the selected region
 267              */
 268             if (sfStartCol >= startColumn && sfStartCol <= endColumn)
 269             {
 270               bs.set(sfStartCol - 1);
 271             }
 272             if (sfEndCol >= startColumn && sfEndCol <= endColumn)
 273             {
 274               bs.set(sfEndCol - 1);
 275             }
 276             continue;
 277           }
 278
 279           /*
 280            * contiguous feature - select feature positions (if any)
 281            * within the selected region
 282            */
 283           if (sfStartCol < startColumn)
 284           {
 285             sfStartCol = startColumn;
 286           }
 287           // not sure what the point of this is
 288           // if (sfStartCol < ist)
 289           // {
 290           // sfStartCol = ist;
 291           // }
 292           if (sfEndCol > endColumn)
 293           {
 294             sfEndCol = endColumn;
 295           }
 296           for (; sfStartCol <= sfEndCol; sfStartCol++)
 297           {
 298             bs.set(sfStartCol - 1); // convert to base 0
 299           }
 300         }
 301       }
 302     }
 303     return nseq;
 304   }
 305
 306   @Override
 307   public void sortAlignmentByFeatureDensity(List<String> typ)
 308   {
 309     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
 310   }
 311
 312   protected void sortBy(List<String> typ, String methodText,
 313           final String method)
 314   {
 315     FeatureRenderer fr = alignPanel.getFeatureRenderer();
 316     if (typ == null && fr != null)
 317     {
 318       typ = fr.getDisplayedFeatureTypes();
 319     }
 320     List<String> gps = null;
 321     if (fr != null)
 322     {
 323       gps = fr.getDisplayedFeatureGroups();
 324     }
 325     AlignmentI al = viewport.getAlignment();
 326
 327     int start, stop;
 328     SequenceGroup sg = viewport.getSelectionGroup();
 329     if (sg != null)
 330     {
 331       start = sg.getStartRes();
 332       stop = sg.getEndRes();
 333     }
 334     else
 335     {
 336       start = 0;
 337       stop = al.getWidth();
 338     }
 339     SequenceI[] oldOrder = al.getSequencesArray();
 340     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
 341     avcg.addHistoryItem(new OrderCommand(methodText, oldOrder,
 342             viewport.getAlignment()));
 343     alignPanel.paintAlignment(true, false);
 344
 345   }
 346
 347   @Override
 348   public void sortAlignmentByFeatureScore(List<String> typ)
 349   {
 350     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
 351   }
 352
 353   @Override
 354   public boolean parseFeaturesFile(String file, DataSourceType protocol,
 355           boolean relaxedIdMatching)
 356   {
 357     boolean featuresAdded = false;
 358     FeatureRenderer fr = alignPanel.getFeatureRenderer();
 359     try
 360     {
 361       featuresAdded = new FeaturesFile(false, file, protocol).parse(
 362               viewport.getAlignment().getDataset(), fr.getFeatureColours(),
 363               fr.getFeatureFilters(), false, relaxedIdMatching);
 364     } catch (Exception ex)
 365     {
 366       ex.printStackTrace();
 367     }
 368
 369     if (featuresAdded)
 370     {
 371       avcg.refreshFeatureUI(true);
 372       if (fr != null)
 373       {
 374         // update the min/max ranges where necessary
 375         fr.findAllFeatures(true);
 376       }
 377       if (avcg.getFeatureSettingsUI() != null)
 378       {
 379         avcg.getFeatureSettingsUI().discoverAllFeatureData();
 380       }
 381       alignPanel.paintAlignment(true, true);
 382     }
 383
 384     return featuresAdded;
 385
 386   }
 387
 388
 389   @Override
 390   public boolean selectHighlightedSequences(boolean invert,
 391           boolean extendCurrent, boolean toggle)
 392   {
 393     List<SequenceI> results = alignPanel.getAlignViewport()
 394             .getHighlightedSeqs();
 395
 396     SequenceGroup sq = (extendCurrent
 397             && viewport.getSelectionGroup() != null)
 398                     ? viewport.getSelectionGroup()
 399                     : new SequenceGroup();
 400
 401     SearchResultsI searchResults = viewport.getSearchResults();
 402     if (invert)
 403     {
 404       List<SequenceI> nothighlighted = new ArrayList();
 405       for (SequenceI seq : alignPanel.getAlignViewport().getAlignment()
 406               .getSequences())
 407       {
 408         if (!results.contains(seq) && (searchResults == null
 409                 || !searchResults.involvesSequence(seq)))
 410         {
 411           nothighlighted.add(seq);
 412         }
 413       }
 414       results = nothighlighted;
 415     }
 416     else
 417     {
 418       // copy list and add in search results
 419       results = new ArrayList(results);
 420       if (searchResults != null)
 421       {
 422         for (SequenceI seq : alignPanel.getAlignViewport().getAlignment()
 423                 .getSequences())
 424         {
 425           if (searchResults.involvesSequence(seq))
 426           {
 427             results.add(seq);
 428           }
 429         }
 430       }
 431     }
 432
 433     if (results == null || results.size() == 0)
 434     {
 435       // do nothing if no selection exists
 436       // unless toggle ??
 437       return false;
 438     }
 439
 440     boolean changed = false;
 441
 442     for (SequenceI seq : results)
 443     {
 444       int size = sq.getSize();
 445       if (toggle)
 446       {
 447         sq.addOrRemove(seq, false);
 448       }
 449       else
 450       {
 451         sq.addSequence(seq, false);
 452       }
 453       changed |= size != sq.getSize();
 454     }
 455
 456     if (sq.getSize() == 0)
 457     {
 458       viewport.setSelectionGroup(null);
 459     }
 460     else
 461     {
 462       if (sq != viewport.getSelectionGroup())
 463     {
 464       sq.setStartRes(0);
 465       sq.setEndRes(viewport.getRanges().getAbsoluteAlignmentWidth());
 466     }
 467       viewport.setSelectionGroup(sq);
 468     }
 469
 470     alignPanel.paintAlignment(false, false);
 471
 472     return changed;
 473   }
 474
 475   @Override
 476   public boolean markHighlightedColumns(boolean invert,
 477           boolean extendCurrent, boolean toggle)
 478   {
 479     if (!viewport.hasSearchResults())
 480     {
 481       // do nothing if no selection exists
 482       return false;
 483     }
 484     // JBPNote this routine could also mark rows, not just columns.
 485     BitSet bs = new BitSet();
 486     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null
 487             || extendCurrent) ? viewport.getAlignment()
 488                     : viewport.getSelectionGroup();
 489
 490     // this could be a lambda... - the remains of the method is boilerplate,
 491     // except for the different messages for reporting selection.
 492     int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
 493
 494     ColumnSelection cs = viewport.getColumnSelection();
 495     if (cs == null)
 496     {
 497       cs = new ColumnSelection();
 498     }
 499
 500     if (bs.cardinality() > 0 || invert)
 501     {
 502       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 503               sqcol.getEndRes(), invert, extendCurrent, toggle);
 504       if (changed)
 505       {
 506         viewport.setColumnSelection(cs);
 507         alignPanel.paintAlignment(false, false);
 508         int columnCount = invert
 509                 ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 510                         - bs.cardinality()
 511                 : bs.cardinality();
 512         avcg.setStatus(MessageManager.formatMessage(
 513                 "label.view_controller_toggled_marked", new String[]
 514                 { toggle ? MessageManager.getString("label.toggled")
 515                         : MessageManager.getString("label.marked"),
 516                     String.valueOf(columnCount),
 517                     invert ? MessageManager
 518                             .getString("label.not_containing")
 519                             : MessageManager.getString("label.containing"),
 520                     "Highlight", Integer.valueOf(nseq).toString() }));
 521         return true;
 522       }
 523     }
 524     else
 525     {
 526       avcg.setStatus(MessageManager
 527               .formatMessage("No highlighted regions marked"));
 528       if (!extendCurrent)
 529       {
 530         cs.clear();
 531         alignPanel.paintAlignment(false, false);
 532       }
 533     }
 534     return false;
 535   }
 536
 537 }