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