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 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     FeatureRendererModel fr = alignPanel == null ? null
 232             : (FeatureRendererModel) alignPanel.getFeatureRenderer();
 233     List<String> visibleFeatures = fr.getDisplayedFeatureTypes();
 234
 235     final int startColumn = sqcol.getStartRes() + 1; // converted to base 1
 236     final int endColumn = sqcol.getEndRes() + 1;
 237     List<SequenceI> seqs = sqcol.getSequences();
 238     int nseq = 0;
 239     for (SequenceI sq : seqs)
 240     {
 241       if (sq != null)
 242       {
 243         // int ist = sq.findPosition(sqcol.getStartRes());
 244         List<SequenceFeature> sfs = sq.findFeatures(startColumn,
 245                 endColumn, featureType);
 246
 247         boolean found = false;
 248         for (SequenceFeature sf : sfs)
 249         {
 250           {
 251             if (!visibleFeatures.contains(sf.getType())
 252                     || fr.getColour(sf) == null) // could pull up getColour to
 253                                                  // FeatureRenderer interface
 254             {
 255               continue;
 256             }
 257           }
 258           if (!found)
 259           {
 260             nseq++;
 261           }
 262           found = true;
 263           int sfStartCol = sq.findIndex(sf.getBegin());
 264           int sfEndCol = sq.findIndex(sf.getEnd());
 265
 266           if (sf.isContactFeature())
 267           {
 268             /*
 269              * 'contact' feature - check for 'start' or 'end'
 270              * position within the selected region
 271              */
 272             if (sfStartCol >= startColumn && sfStartCol <= endColumn)
 273             {
 274               bs.set(sfStartCol - 1);
 275             }
 276             if (sfEndCol >= startColumn && sfEndCol <= endColumn)
 277             {
 278               bs.set(sfEndCol - 1);
 279             }
 280             continue;
 281           }
 282
 283           /*
 284            * contiguous feature - select feature positions (if any)
 285            * within the selected region
 286            */
 287           if (sfStartCol < startColumn)
 288           {
 289             sfStartCol = startColumn;
 290           }
 291           // not sure what the point of this is
 292           // if (sfStartCol < ist)
 293           // {
 294           // sfStartCol = ist;
 295           // }
 296           if (sfEndCol > endColumn)
 297           {
 298             sfEndCol = endColumn;
 299           }
 300           for (; sfStartCol <= sfEndCol; sfStartCol++)
 301           {
 302             bs.set(sfStartCol - 1); // convert to base 0
 303           }
 304         }
 305       }
 306     }
 307     return nseq;
 308   }
 309
 310   @Override
 311   public void sortAlignmentByFeatureDensity(List<String> typ)
 312   {
 313     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
 314   }
 315
 316   protected void sortBy(List<String> typ, String methodText,
 317           final String method)
 318   {
 319     FeatureRenderer fr = alignPanel.getFeatureRenderer();
 320     if (typ == null && fr != null)
 321     {
 322       typ = fr.getDisplayedFeatureTypes();
 323     }
 324     List<String> gps = null;
 325     if (fr != null)
 326     {
 327       gps = fr.getDisplayedFeatureGroups();
 328     }
 329     AlignmentI al = viewport.getAlignment();
 330
 331     int start, stop;
 332     SequenceGroup sg = viewport.getSelectionGroup();
 333     if (sg != null)
 334     {
 335       start = sg.getStartRes();
 336       stop = sg.getEndRes();
 337     }
 338     else
 339     {
 340       start = 0;
 341       stop = al.getWidth();
 342     }
 343     SequenceI[] oldOrder = al.getSequencesArray();
 344     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
 345     avcg.addHistoryItem(new OrderCommand(methodText, oldOrder,
 346             viewport.getAlignment()));
 347     alignPanel.paintAlignment(true, false);
 348
 349   }
 350
 351   @Override
 352   public void sortAlignmentByFeatureScore(List<String> typ)
 353   {
 354     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
 355   }
 356
 357   @Override
 358   public boolean parseFeaturesFile(String file, DataSourceType protocol,
 359           boolean relaxedIdMatching)
 360   {
 361     boolean featuresFile = false;
 362     try
 363     {
 364       featuresFile = new FeaturesFile(false, file, protocol).parse(
 365               viewport.getAlignment().getDataset(),
 366               alignPanel.getFeatureRenderer().getFeatureColours(), false,
 367               relaxedIdMatching);
 368     } catch (Exception ex)
 369     {
 370       ex.printStackTrace();
 371     }
 372
 373     if (featuresFile)
 374     {
 375       avcg.refreshFeatureUI(true);
 376       if (alignPanel.getFeatureRenderer() != null)
 377       {
 378         // update the min/max ranges where necessary
 379         alignPanel.getFeatureRenderer().findAllFeatures(true);
 380       }
 381       if (avcg.getFeatureSettingsUI() != null)
 382       {
 383         avcg.getFeatureSettingsUI().discoverAllFeatureData();
 384       }
 385       alignPanel.paintAlignment(true, true);
 386     }
 387
 388     return featuresFile;
 389
 390   }
 391
 392   @Override
 393   public boolean markHighlightedColumns(boolean invert,
 394           boolean extendCurrent, boolean toggle)
 395   {
 396     if (!viewport.hasSearchResults())
 397     {
 398       // do nothing if no selection exists
 399       return false;
 400     }
 401     // JBPNote this routine could also mark rows, not just columns.
 402     BitSet bs = new BitSet();
 403     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null
 404             || extendCurrent) ? viewport.getAlignment()
 405                     : viewport.getSelectionGroup();
 406
 407     // this could be a lambda... - the remains of the method is boilerplate,
 408     // except for the different messages for reporting selection.
 409     int nseq = viewport.getSearchResults().markColumns(sqcol, bs);
 410
 411     ColumnSelection cs = viewport.getColumnSelection();
 412     if (cs == null)
 413     {
 414       cs = new ColumnSelection();
 415     }
 416
 417     if (bs.cardinality() > 0 || invert)
 418     {
 419       boolean changed = cs.markColumns(bs, sqcol.getStartRes(),
 420               sqcol.getEndRes(), invert, extendCurrent, toggle);
 421       if (changed)
 422       {
 423         viewport.setColumnSelection(cs);
 424         alignPanel.paintAlignment(false, false);
 425         int columnCount = invert
 426                 ? (sqcol.getEndRes() - sqcol.getStartRes() + 1)
 427                         - bs.cardinality()
 428                 : bs.cardinality();
 429         avcg.setStatus(MessageManager.formatMessage(
 430                 "label.view_controller_toggled_marked", new String[]
 431                 { toggle ? MessageManager.getString("label.toggled")
 432                         : MessageManager.getString("label.marked"),
 433                     String.valueOf(columnCount),
 434                     invert ? MessageManager
 435                             .getString("label.not_containing")
 436                             : MessageManager.getString("label.containing"),
 437                     "Highlight", Integer.valueOf(nseq).toString() }));
 438         return true;
 439       }
 440     }
 441     else
 442     {
 443       avcg.setStatus(MessageManager
 444               .formatMessage("No highlighted regions marked"));
 445       if (!extendCurrent)
 446       {
 447         cs.clear();
 448         alignPanel.paintAlignment(false, false);
 449       }
 450     }
 451     return false;
 452   }
 453
 454 }