src/jalview/gui/StructureChooser.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
  22 package jalview.gui;
  23
  24 import jalview.bin.Jalview;
  25 import jalview.datamodel.DBRefEntry;
  26 import jalview.datamodel.DBRefSource;
  27 import jalview.datamodel.PDBEntry;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.jbgui.GStructureChooser;
  30 import jalview.jbgui.PDBDocFieldPreferences;
  31 import jalview.structure.StructureSelectionManager;
  32 import jalview.util.MessageManager;
  33 import jalview.ws.dbsources.PDBRestClient;
  34 import jalview.ws.dbsources.PDBRestClient.PDBDocField;
  35 import jalview.ws.sifts.SiftsSettings;
  36 import jalview.ws.uimodel.PDBRestRequest;
  37 import jalview.ws.uimodel.PDBRestResponse;
  38 import jalview.ws.uimodel.PDBRestResponse.PDBResponseSummary;
  39
  40 import java.awt.event.ItemEvent;
  41 import java.util.ArrayList;
  42 import java.util.Collection;
  43 import java.util.HashSet;
  44 import java.util.LinkedHashSet;
  45 import java.util.List;
  46 import java.util.Objects;
  47 import java.util.Vector;
  48
  49 import javax.swing.JCheckBox;
  50 import javax.swing.JComboBox;
  51 import javax.swing.JLabel;
  52 import javax.swing.JOptionPane;
  53 import javax.swing.table.AbstractTableModel;
  54
  55 /**
  56  * Provides the behaviors for the Structure chooser Panel
  57  *
  58  * @author tcnofoegbu
  59  *
  60  */
  61 @SuppressWarnings("serial")
  62 public class StructureChooser extends GStructureChooser implements
  63         IProgressIndicator
  64 {
  65   private boolean structuresDiscovered = false;
  66
  67   private SequenceI selectedSequence;
  68
  69   private SequenceI[] selectedSequences;
  70
  71   private IProgressIndicator progressIndicator;
  72
  73   private Collection<PDBResponseSummary> discoveredStructuresSet;
  74
  75   private PDBRestRequest lastPdbRequest;
  76
  77   private PDBRestClient pdbRestCleint;
  78
  79   private String selectedPdbFileName;
  80
  81   private boolean isValidPBDEntry;
  82
  83   public StructureChooser(SequenceI[] selectedSeqs, SequenceI selectedSeq,
  84           AlignmentPanel ap)
  85   {
  86     this.ap = ap;
  87     this.selectedSequence = selectedSeq;
  88     this.selectedSequences = selectedSeqs;
  89     this.progressIndicator = (ap == null) ? null : ap.alignFrame;
  90     init();
  91   }
  92
  93   /**
  94    * Initializes parameters used by the Structure Chooser Panel
  95    */
  96   public void init()
  97   {
  98     if (!Jalview.isHeadlessMode())
  99     {
 100       progressBar = new ProgressBar(this.statusPanel, this.statusBar);
 101     }
 102
 103     Thread discoverPDBStructuresThread = new Thread(new Runnable()
 104     {
 105       @Override
 106       public void run()
 107       {
 108         long startTime = System.currentTimeMillis();
 109         updateProgressIndicator(MessageManager
 110                 .getString("status.loading_cached_pdb_entries"), startTime);
 111         loadLocalCachedPDBEntries();
 112         updateProgressIndicator(null, startTime);
 113         updateProgressIndicator(MessageManager
 114                 .getString("status.searching_for_pdb_structures"),
 115                 startTime);
 116         fetchStructuresMetaData();
 117         populateFilterComboBox();
 118         updateProgressIndicator(null, startTime);
 119         mainFrame.setVisible(true);
 120         updateCurrentView();
 121       }
 122     });
 123     discoverPDBStructuresThread.start();
 124   }
 125
 126   /**
 127    * Updates the progress indicator with the specified message
 128    *
 129    * @param message
 130    *          displayed message for the operation
 131    * @param id
 132    *          unique handle for this indicator
 133    */
 134   public void updateProgressIndicator(String message, long id)
 135   {
 136     if (progressIndicator != null)
 137     {
 138       progressIndicator.setProgressBar(message, id);
 139     }
 140   }
 141
 142   /**
 143    * Retrieve meta-data for all the structure(s) for a given sequence(s) in a
 144    * selection group
 145    */
 146   public void fetchStructuresMetaData()
 147   {
 148     long startTime = System.currentTimeMillis();
 149     Collection<PDBDocField> wantedFields = PDBDocFieldPreferences
 150             .getStructureSummaryFields();
 151
 152     discoveredStructuresSet = new LinkedHashSet<PDBResponseSummary>();
 153     HashSet<String> errors = new HashSet<String>();
 154     for (SequenceI seq : selectedSequences)
 155     {
 156       PDBRestRequest pdbRequest = new PDBRestRequest();
 157       pdbRequest.setAllowEmptySeq(false);
 158       pdbRequest.setResponseSize(500);
 159       pdbRequest.setFieldToSearchBy("(");
 160       pdbRequest.setWantedFields(wantedFields);
 161       pdbRequest.setSearchTerm(buildQuery(seq) + ")");
 162       pdbRequest.setAssociatedSequence(seq);
 163       pdbRestCleint = new PDBRestClient();
 164       PDBRestResponse resultList;
 165       try
 166       {
 167         resultList = pdbRestCleint.executeRequest(pdbRequest);
 168       } catch (Exception e)
 169       {
 170         e.printStackTrace();
 171         errors.add(e.getMessage());
 172         continue;
 173       }
 174       lastPdbRequest = pdbRequest;
 175       if (resultList.getSearchSummary() != null
 176               && !resultList.getSearchSummary().isEmpty())
 177       {
 178         discoveredStructuresSet.addAll(resultList.getSearchSummary());
 179       }
 180     }
 181
 182     int noOfStructuresFound = 0;
 183     String totalTime = (System.currentTimeMillis() - startTime)
 184             + " milli secs";
 185     if (discoveredStructuresSet != null
 186             && !discoveredStructuresSet.isEmpty())
 187     {
 188       tbl_summary.setModel(PDBRestResponse.getTableModel(lastPdbRequest,
 189               discoveredStructuresSet));
 190       structuresDiscovered = true;
 191       noOfStructuresFound = discoveredStructuresSet.size();
 192       mainFrame.setTitle(MessageManager.formatMessage(
 193               "label.structure_chooser_no_of_structures",
 194               noOfStructuresFound, totalTime));
 195     }
 196     else
 197     {
 198       mainFrame.setTitle(MessageManager
 199               .getString("label.structure_chooser_manual_association"));
 200       if (errors.size() > 0)
 201       {
 202         StringBuilder errorMsg = new StringBuilder();
 203         for (String error : errors)
 204         {
 205           errorMsg.append(error).append("\n");
 206         }
 207         JOptionPane.showMessageDialog(this, errorMsg.toString(),
 208                 MessageManager.getString("label.pdb_web-service_error"),
 209                 JOptionPane.ERROR_MESSAGE);
 210       }
 211     }
 212   }
 213
 214   public void loadLocalCachedPDBEntries()
 215   {
 216     ArrayList<CachedPDB> entries = new ArrayList<CachedPDB>();
 217     for (SequenceI seq : selectedSequences)
 218     {
 219       if (seq.getDatasetSequence() != null
 220               && seq.getDatasetSequence().getAllPDBEntries() != null)
 221       {
 222         for (PDBEntry pdbEntry : seq.getDatasetSequence()
 223                 .getAllPDBEntries())
 224         {
 225           if (pdbEntry.getFile() != null)
 226           {
 227             entries.add(new CachedPDB(seq, pdbEntry));
 228           }
 229         }
 230       }
 231     }
 232
 233     PDBEntryTableModel tableModelx = new PDBEntryTableModel(entries);
 234     tbl_local_pdb.setModel(tableModelx);
 235   }
 236
 237   /**
 238    * Builds a query string for a given sequences using its DBRef entries
 239    *
 240    * @param seq
 241    *          the sequences to build a query for
 242    * @return the built query string
 243    */
 244
 245   public static String buildQuery(SequenceI seq)
 246   {
 247     boolean isPDBRefsFound = false;
 248     boolean isUniProtRefsFound = false;
 249     StringBuilder queryBuilder = new StringBuilder();
 250     HashSet<String> seqRefs = new LinkedHashSet<String>();
 251
 252     if (seq.getAllPDBEntries() != null)
 253     {
 254       for (PDBEntry entry : seq.getAllPDBEntries())
 255       {
 256         if (isValidSeqName(entry.getId()))
 257         {
 258           queryBuilder.append(PDBRestClient.PDBDocField.PDB_ID.getCode())
 259                   .append(":")
 260 .append(entry.getId().toLowerCase())
 261                   .append(" OR ");
 262           isPDBRefsFound = true;
 263           // seqRefs.add(entry.getId());
 264         }
 265       }
 266     }
 267
 268     if (seq.getDBRefs() != null && seq.getDBRefs().length != 0)
 269     {
 270       for (DBRefEntry dbRef : seq.getDBRefs())
 271       {
 272         if (isValidSeqName(getDBRefId(dbRef)))
 273         {
 274           if (dbRef.getSource().equalsIgnoreCase(DBRefSource.UNIPROT))
 275           {
 276             queryBuilder
 277                     .append(PDBRestClient.PDBDocField.UNIPROT_ACCESSION
 278                             .getCode()).append(":")
 279                     .append(getDBRefId(dbRef))
 280                     .append(" OR ");
 281             queryBuilder
 282                     .append(PDBRestClient.PDBDocField.UNIPROT_ID.getCode())
 283                     .append(":")
 284                     .append(getDBRefId(dbRef)).append(" OR ");
 285             isUniProtRefsFound = true;
 286           }
 287           else if (dbRef.getSource().equalsIgnoreCase(DBRefSource.PDB))
 288           {
 289
 290             queryBuilder.append(PDBRestClient.PDBDocField.PDB_ID.getCode())
 291                     .append(":").append(getDBRefId(dbRef).toLowerCase())
 292                     .append(" OR ");
 293             isPDBRefsFound = true;
 294           }
 295           else
 296           {
 297             seqRefs.add(getDBRefId(dbRef));
 298           }
 299         }
 300       }
 301     }
 302
 303     if (!isPDBRefsFound && !isUniProtRefsFound)
 304     {
 305       String seqName = seq.getName();
 306       seqName = sanitizeSeqName(seqName);
 307       String[] names = seqName.toLowerCase().split("\\|");
 308       for (String name : names)
 309       {
 310         // System.out.println("Found name : " + name);
 311         name.trim();
 312         if (isValidSeqName(name))
 313         {
 314           seqRefs.add(name);
 315         }
 316       }
 317
 318       for (String seqRef : seqRefs)
 319       {
 320         queryBuilder.append("text:").append(seqRef).append(" OR ");
 321       }
 322     }
 323
 324     int endIndex = queryBuilder.lastIndexOf(" OR ");
 325     if (queryBuilder.toString().length() < 6)
 326     {
 327       return null;
 328     }
 329     String query = queryBuilder.toString().substring(0, endIndex);
 330     return query;
 331   }
 332
 333   /**
 334    * Remove the following special characters from input string +, -, &, |, !, (,
 335    * ), {, }, [, ], ^, ", ~, *, ?, :, \
 336    *
 337    * @param seqName
 338    * @return
 339    */
 340   private static String sanitizeSeqName(String seqName)
 341   {
 342     Objects.requireNonNull(seqName);
 343     return seqName.replaceAll("\\[\\d*\\]", "")
 344             .replaceAll("[^\\dA-Za-z ]", "").replaceAll("\\s+", "+");
 345   }
 346
 347
 348   /**
 349    * Ensures sequence ref names are not less than 3 characters and does not
 350    * contain a database name
 351    *
 352    * @param seqName
 353    * @return
 354    */
 355   public static boolean isValidSeqName(String seqName)
 356   {
 357     // System.out.println("seqName : " + seqName);
 358     String ignoreList = "pdb,uniprot,swiss-prot";
 359     if (seqName.length() < 3)
 360     {
 361       return false;
 362     }
 363     if (seqName.contains(":"))
 364     {
 365       return false;
 366     }
 367     seqName = seqName.toLowerCase();
 368     for (String ignoredEntry : ignoreList.split(","))
 369     {
 370       if (seqName.contains(ignoredEntry))
 371       {
 372         return false;
 373       }
 374     }
 375     return true;
 376   }
 377
 378   public static String getDBRefId(DBRefEntry dbRef)
 379   {
 380     String ref = dbRef.getAccessionId().replaceAll("GO:", "");
 381     return ref;
 382   }
 383
 384   /**
 385    * Filters a given list of discovered structures based on supplied argument
 386    *
 387    * @param fieldToFilterBy
 388    *          the field to filter by
 389    */
 390   public void filterResultSet(final String fieldToFilterBy)
 391   {
 392     Thread filterThread = new Thread(new Runnable()
 393     {
 394       @Override
 395       public void run()
 396       {
 397         long startTime = System.currentTimeMillis();
 398         lbl_loading.setVisible(true);
 399         Collection<PDBDocField> wantedFields = PDBDocFieldPreferences
 400                 .getStructureSummaryFields();
 401         Collection<PDBResponseSummary> filteredResponse = new HashSet<PDBResponseSummary>();
 402         HashSet<String> errors = new HashSet<String>();
 403
 404         for (SequenceI seq : selectedSequences)
 405         {
 406           PDBRestRequest pdbRequest = new PDBRestRequest();
 407           if (fieldToFilterBy.equalsIgnoreCase("uniprot_coverage"))
 408           {
 409             System.out.println(">>>>>> Filtering with uniprot coverate");
 410             pdbRequest.setAllowEmptySeq(false);
 411             pdbRequest.setResponseSize(1);
 412             pdbRequest.setFieldToSearchBy("(");
 413             pdbRequest.setSearchTerm(buildQuery(seq) + ")");
 414             pdbRequest.setWantedFields(wantedFields);
 415             pdbRequest.setAssociatedSequence(seq);
 416             pdbRequest.setFacet(true);
 417             pdbRequest.setFacetPivot(fieldToFilterBy + ",entry_entity");
 418             pdbRequest.setFacetPivotMinCount(1);
 419           }
 420           else
 421           {
 422             pdbRequest.setAllowEmptySeq(false);
 423             pdbRequest.setResponseSize(1);
 424             pdbRequest.setFieldToSearchBy("(");
 425             pdbRequest.setFieldToSortBy(fieldToFilterBy,
 426                     !chk_invertFilter.isSelected());
 427             pdbRequest.setSearchTerm(buildQuery(seq) + ")");
 428             pdbRequest.setWantedFields(wantedFields);
 429             pdbRequest.setAssociatedSequence(seq);
 430           }
 431           pdbRestCleint = new PDBRestClient();
 432           PDBRestResponse resultList;
 433           try
 434           {
 435             resultList = pdbRestCleint.executeRequest(pdbRequest);
 436           } catch (Exception e)
 437           {
 438             e.printStackTrace();
 439             errors.add(e.getMessage());
 440             continue;
 441           }
 442           lastPdbRequest = pdbRequest;
 443           if (resultList.getSearchSummary() != null
 444                   && !resultList.getSearchSummary().isEmpty())
 445           {
 446             filteredResponse.addAll(resultList.getSearchSummary());
 447           }
 448         }
 449
 450         String totalTime = (System.currentTimeMillis() - startTime)
 451                 + " milli secs";
 452         if (!filteredResponse.isEmpty())
 453         {
 454           final int filterResponseCount = filteredResponse.size();
 455           Collection<PDBResponseSummary> reorderedStructuresSet = new LinkedHashSet<PDBResponseSummary>();
 456           reorderedStructuresSet.addAll(filteredResponse);
 457           reorderedStructuresSet.addAll(discoveredStructuresSet);
 458           tbl_summary.setModel(PDBRestResponse.getTableModel(
 459                   lastPdbRequest, reorderedStructuresSet));
 460
 461           PDBRestResponse.configureTableColumn(tbl_summary, wantedFields);
 462           tbl_summary.getColumn("Ref Sequence").setPreferredWidth(120);
 463           tbl_summary.getColumn("Ref Sequence").setMinWidth(100);
 464           tbl_summary.getColumn("Ref Sequence").setMaxWidth(200);
 465           // Update table selection model here
 466           tbl_summary.addRowSelectionInterval(0, filterResponseCount - 1);
 467           mainFrame.setTitle(MessageManager.formatMessage(
 468                   "label.structure_chooser_filter_time", totalTime));
 469         }
 470         else
 471         {
 472           mainFrame.setTitle(MessageManager.formatMessage(
 473                   "label.structure_chooser_filter_time", totalTime));
 474           if (errors.size() > 0)
 475           {
 476             StringBuilder errorMsg = new StringBuilder();
 477             for (String error : errors)
 478             {
 479               errorMsg.append(error).append("\n");
 480             }
 481             JOptionPane.showMessageDialog(
 482                     null,
 483                     errorMsg.toString(),
 484                     MessageManager.getString("label.pdb_web-service_error"),
 485                     JOptionPane.ERROR_MESSAGE);
 486           }
 487         }
 488
 489         lbl_loading.setVisible(false);
 490
 491         validateSelections();
 492       }
 493     });
 494     filterThread.start();
 495   }
 496
 497   /**
 498    * Handles action event for btn_pdbFromFile
 499    */
 500   @Override
 501   public void pdbFromFile_actionPerformed()
 502   {
 503     jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
 504             jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
 505     chooser.setFileView(new jalview.io.JalviewFileView());
 506     chooser.setDialogTitle(MessageManager.formatMessage(
 507             "label.select_pdb_file_for",
 508             selectedSequence.getDisplayId(false)));
 509     chooser.setToolTipText(MessageManager.formatMessage(
 510             "label.load_pdb_file_associate_with_sequence",
 511             selectedSequence.getDisplayId(false)));
 512
 513     int value = chooser.showOpenDialog(null);
 514     if (value == jalview.io.JalviewFileChooser.APPROVE_OPTION)
 515     {
 516       selectedPdbFileName = chooser.getSelectedFile().getPath();
 517       jalview.bin.Cache.setProperty("LAST_DIRECTORY", selectedPdbFileName);
 518       validateSelections();
 519     }
 520   }
 521
 522   /**
 523    * Populates the filter combo-box options dynamically depending on discovered
 524    * structures
 525    */
 526   @Override
 527   protected void populateFilterComboBox()
 528   {
 529     if (isStructuresDiscovered())
 530     {
 531       cmb_filterOption.addItem(new FilterOption("Best Quality",
 532               PDBDocField.OVERALL_QUALITY.getCode(), VIEWS_FILTER));
 533       cmb_filterOption.addItem(new FilterOption("Most UniProt Coverage",
 534               PDBDocField.UNIPROT_COVERAGE.getCode(), VIEWS_FILTER));
 535       cmb_filterOption.addItem(new FilterOption("Best Resolution",
 536               PDBDocField.RESOLUTION.getCode(), VIEWS_FILTER));
 537       cmb_filterOption.addItem(new FilterOption("Most Protein Chain",
 538               PDBDocField.PROTEIN_CHAIN_COUNT.getCode(), VIEWS_FILTER));
 539       cmb_filterOption.addItem(new FilterOption("Most Bound Molecules",
 540               PDBDocField.BOUND_MOLECULE_COUNT.getCode(), VIEWS_FILTER));
 541       cmb_filterOption.addItem(new FilterOption("Most Polymer Residues",
 542               PDBDocField.POLYMER_RESIDUE_COUNT.getCode(), VIEWS_FILTER));
 543     }
 544     cmb_filterOption.addItem(new FilterOption("Enter PDB Id", "-",
 545             VIEWS_ENTER_ID));
 546     cmb_filterOption.addItem(new FilterOption("From File", "-",
 547             VIEWS_FROM_FILE));
 548     cmb_filterOption.addItem(new FilterOption("Cached PDB Entries", "-",
 549             VIEWS_LOCAL_PDB));
 550   }
 551
 552   /**
 553    * Updates the displayed view based on the selected filter option
 554    */
 555   @Override
 556   protected void updateCurrentView()
 557   {
 558     FilterOption selectedFilterOpt = ((FilterOption) cmb_filterOption
 559             .getSelectedItem());
 560     layout_switchableViews.show(pnl_switchableViews,
 561             selectedFilterOpt.getView());
 562     String filterTitle = mainFrame.getTitle();
 563     mainFrame.setTitle(frameTitle);
 564     chk_invertFilter.setVisible(false);
 565     if (selectedFilterOpt.getView() == VIEWS_FILTER)
 566     {
 567       mainFrame.setTitle(filterTitle);
 568       chk_invertFilter.setVisible(true);
 569       filterResultSet(selectedFilterOpt.getValue());
 570     }
 571     else if (selectedFilterOpt.getView() == VIEWS_ENTER_ID
 572             || selectedFilterOpt.getView() == VIEWS_FROM_FILE)
 573     {
 574       mainFrame.setTitle(MessageManager
 575               .getString("label.structure_chooser_manual_association"));
 576       idInputAssSeqPanel.loadCmbAssSeq();
 577       fileChooserAssSeqPanel.loadCmbAssSeq();
 578     }
 579     validateSelections();
 580   }
 581
 582   /**
 583    * Validates user selection and activates the view button if all parameters
 584    * are correct
 585    */
 586   @Override
 587   public void validateSelections()
 588   {
 589     FilterOption selectedFilterOpt = ((FilterOption) cmb_filterOption
 590             .getSelectedItem());
 591     btn_view.setEnabled(false);
 592     String currentView = selectedFilterOpt.getView();
 593     if (currentView == VIEWS_FILTER)
 594     {
 595       if (tbl_summary.getSelectedRows().length > 0)
 596       {
 597         btn_view.setEnabled(true);
 598       }
 599     }
 600     else if (currentView == VIEWS_LOCAL_PDB)
 601     {
 602       if (tbl_local_pdb.getSelectedRows().length > 0)
 603       {
 604         btn_view.setEnabled(true);
 605       }
 606     }
 607     else if (currentView == VIEWS_ENTER_ID)
 608     {
 609       validateAssociationEnterPdb();
 610     }
 611     else if (currentView == VIEWS_FROM_FILE)
 612     {
 613       validateAssociationFromFile();
 614     }
 615   }
 616
 617   /**
 618    * Validates inputs from the Manual PDB entry panel
 619    */
 620   public void validateAssociationEnterPdb()
 621   {
 622     AssociateSeqOptions assSeqOpt = (AssociateSeqOptions) idInputAssSeqPanel
 623             .getCmb_assSeq().getSelectedItem();
 624     lbl_pdbManualFetchStatus.setIcon(errorImage);
 625     lbl_pdbManualFetchStatus.setToolTipText("");
 626     if (txt_search.getText().length() > 0)
 627     {
 628       lbl_pdbManualFetchStatus
 629               .setToolTipText(JvSwingUtils.wrapTooltip(true, MessageManager
 630                       .formatMessage("info.no_pdb_entry_found_for",
 631                               txt_search.getText())));
 632     }
 633
 634     if (errorWarning.length() > 0)
 635     {
 636       lbl_pdbManualFetchStatus.setIcon(warningImage);
 637       lbl_pdbManualFetchStatus.setToolTipText(JvSwingUtils.wrapTooltip(
 638               true, errorWarning.toString()));
 639     }
 640
 641     if (selectedSequences.length == 1
 642             || !assSeqOpt.getName().equalsIgnoreCase(
 643                     "-Select Associated Seq-"))
 644     {
 645       txt_search.setEnabled(true);
 646       if (isValidPBDEntry)
 647       {
 648         btn_view.setEnabled(true);
 649         lbl_pdbManualFetchStatus.setToolTipText("");
 650         lbl_pdbManualFetchStatus.setIcon(goodImage);
 651       }
 652     }
 653     else
 654     {
 655       txt_search.setEnabled(false);
 656       lbl_pdbManualFetchStatus.setIcon(errorImage);
 657     }
 658   }
 659
 660   /**
 661    * Validates inputs for the manual PDB file selection options
 662    */
 663   public void validateAssociationFromFile()
 664   {
 665     AssociateSeqOptions assSeqOpt = (AssociateSeqOptions) fileChooserAssSeqPanel
 666             .getCmb_assSeq().getSelectedItem();
 667     lbl_fromFileStatus.setIcon(errorImage);
 668     if (selectedSequences.length == 1
 669             || (assSeqOpt != null && !assSeqOpt.getName().equalsIgnoreCase(
 670                     "-Select Associated Seq-")))
 671     {
 672       btn_pdbFromFile.setEnabled(true);
 673       if (selectedPdbFileName != null && selectedPdbFileName.length() > 0)
 674       {
 675         btn_view.setEnabled(true);
 676         lbl_fromFileStatus.setIcon(goodImage);
 677       }
 678     }
 679     else
 680     {
 681       btn_pdbFromFile.setEnabled(false);
 682       lbl_fromFileStatus.setIcon(errorImage);
 683     }
 684   }
 685
 686   @Override
 687   public void cmbAssSeqStateChanged()
 688   {
 689     validateSelections();
 690   }
 691
 692   /**
 693    * Handles the state change event for the 'filter' combo-box and 'invert'
 694    * check-box
 695    */
 696   @Override
 697   protected void stateChanged(ItemEvent e)
 698   {
 699     if (e.getSource() instanceof JCheckBox)
 700     {
 701       updateCurrentView();
 702     }
 703     else
 704     {
 705       if (e.getStateChange() == ItemEvent.SELECTED)
 706       {
 707         updateCurrentView();
 708       }
 709     }
 710
 711   }
 712
 713   /**
 714    * Handles action event for btn_ok
 715    */
 716   @Override
 717   public void ok_ActionPerformed()
 718   {
 719     final long progressSessionId = System.currentTimeMillis();
 720     final StructureSelectionManager ssm = ap.getStructureSelectionManager();
 721     ssm.setProgressIndicator(this);
 722     ssm.setProgressSessionId(progressSessionId);
 723     new Thread(new Runnable()
 724     {
 725       @Override
 726       public void run()
 727       {
 728     FilterOption selectedFilterOpt = ((FilterOption) cmb_filterOption
 729             .getSelectedItem());
 730     String currentView = selectedFilterOpt.getView();
 731     if (currentView == VIEWS_FILTER)
 732     {
 733       int pdbIdColIndex = tbl_summary.getColumn(
 734               PDBRestClient.PDBDocField.PDB_ID.getName()).getModelIndex();
 735       int refSeqColIndex = tbl_summary.getColumn("Ref Sequence")
 736               .getModelIndex();
 737       int[] selectedRows = tbl_summary.getSelectedRows();
 738       PDBEntry[] pdbEntriesToView = new PDBEntry[selectedRows.length];
 739       int count = 0;
 740       ArrayList<SequenceI> selectedSeqsToView = new ArrayList<SequenceI>();
 741       for (int row : selectedRows)
 742       {
 743         String pdbIdStr = tbl_summary.getValueAt(row, pdbIdColIndex)
 744                 .toString();
 745         SequenceI selectedSeq = (SequenceI) tbl_summary.getValueAt(row,
 746                 refSeqColIndex);
 747         selectedSeqsToView.add(selectedSeq);
 748             PDBEntry pdbEntry = selectedSeq.getPDBEntry(pdbIdStr);
 749             if (pdbEntry == null)
 750             {
 751               pdbEntry = getFindEntry(pdbIdStr,
 752                       selectedSeq.getAllPDBEntries());
 753             }
 754         if (pdbEntry == null)
 755         {
 756           pdbEntry = new PDBEntry();
 757           pdbEntry.setId(pdbIdStr);
 758           pdbEntry.setType(PDBEntry.Type.PDB);
 759           selectedSeq.getDatasetSequence().addPDBId(pdbEntry);
 760         }
 761         pdbEntriesToView[count++] = pdbEntry;
 762       }
 763       SequenceI[] selectedSeqs = selectedSeqsToView
 764               .toArray(new SequenceI[selectedSeqsToView.size()]);
 765           launchStructureViewer(ssm, pdbEntriesToView, ap, selectedSeqs);
 766     }
 767     else if (currentView == VIEWS_LOCAL_PDB)
 768     {
 769       int[] selectedRows = tbl_local_pdb.getSelectedRows();
 770       PDBEntry[] pdbEntriesToView = new PDBEntry[selectedRows.length];
 771       int count = 0;
 772       int pdbIdColIndex = tbl_local_pdb.getColumn(
 773               PDBRestClient.PDBDocField.PDB_ID.getName()).getModelIndex();
 774       int refSeqColIndex = tbl_local_pdb.getColumn("Ref Sequence")
 775               .getModelIndex();
 776       ArrayList<SequenceI> selectedSeqsToView = new ArrayList<SequenceI>();
 777       for (int row : selectedRows)
 778       {
 779         PDBEntry pdbEntry = (PDBEntry) tbl_local_pdb.getValueAt(row,
 780                 pdbIdColIndex);
 781         pdbEntriesToView[count++] = pdbEntry;
 782         SequenceI selectedSeq = (SequenceI) tbl_local_pdb.getValueAt(row,
 783                 refSeqColIndex);
 784         selectedSeqsToView.add(selectedSeq);
 785       }
 786       SequenceI[] selectedSeqs = selectedSeqsToView
 787               .toArray(new SequenceI[selectedSeqsToView.size()]);
 788           launchStructureViewer(ssm, pdbEntriesToView, ap, selectedSeqs);
 789     }
 790     else if (currentView == VIEWS_ENTER_ID)
 791     {
 792       SequenceI userSelectedSeq = ((AssociateSeqOptions) idInputAssSeqPanel
 793               .getCmb_assSeq().getSelectedItem()).getSequence();
 794       if (userSelectedSeq != null)
 795       {
 796         selectedSequence = userSelectedSeq;
 797       }
 798
 799       String pdbIdStr = txt_search.getText();
 800       PDBEntry pdbEntry = selectedSequence.getPDBEntry(pdbIdStr);
 801       if (pdbEntry == null)
 802       {
 803         pdbEntry = new PDBEntry();
 804         pdbEntry.setId(pdbIdStr);
 805         pdbEntry.setType(PDBEntry.Type.PDB);
 806         selectedSequence.getDatasetSequence().addPDBId(pdbEntry);
 807       }
 808
 809       PDBEntry[] pdbEntriesToView = new PDBEntry[] { pdbEntry };
 810           launchStructureViewer(ssm, pdbEntriesToView, ap,
 811                   new SequenceI[] { selectedSequence });
 812     }
 813     else if (currentView == VIEWS_FROM_FILE)
 814     {
 815       SequenceI userSelectedSeq = ((AssociateSeqOptions) fileChooserAssSeqPanel
 816               .getCmb_assSeq().getSelectedItem()).getSequence();
 817       if (userSelectedSeq != null)
 818       {
 819         selectedSequence = userSelectedSeq;
 820       }
 821       PDBEntry fileEntry = new AssociatePdbFileWithSeq()
 822               .associatePdbWithSeq(selectedPdbFileName,
 823                       jalview.io.AppletFormatAdapter.FILE,
 824                       selectedSequence, true, Desktop.instance);
 825
 826           launchStructureViewer(ssm, new PDBEntry[] { fileEntry }, ap,
 827                   new SequenceI[] { selectedSequence });
 828     }
 829     mainFrame.dispose();
 830       }
 831     }).start();
 832   }
 833
 834   private PDBEntry getFindEntry(String id, Vector<PDBEntry> pdbEntries)
 835   {
 836     Objects.requireNonNull(id);
 837     Objects.requireNonNull(pdbEntries);
 838     PDBEntry foundEntry = null;
 839     for (PDBEntry entry : pdbEntries)
 840     {
 841       if (entry.getId().equalsIgnoreCase(id))
 842       {
 843         return entry;
 844       }
 845     }
 846     return foundEntry;
 847   }
 848
 849   private void launchStructureViewer(StructureSelectionManager ssm,
 850           final PDBEntry[] pdbEntriesToView,
 851           final AlignmentPanel alignPanel, SequenceI[] sequences)
 852   {
 853     ssm.setProgressBar("Launching PDB structure viewer..");
 854     final StructureViewer sViewer = new StructureViewer(ssm);
 855
 856     if (SiftsSettings.isMapWithSifts())
 857     {
 858       for (SequenceI seq : sequences)
 859       {
 860         if (seq.getSourceDBRef() == null)
 861         {
 862           ssm.setProgressBar(null);
 863           ssm.setProgressBar("Fetching Database refs..");
 864           new jalview.ws.DBRefFetcher(sequences, null, null, null, false)
 865                   .fetchDBRefs(true);
 866           break;
 867         }
 868       }
 869     }
 870         if (pdbEntriesToView.length > 1)
 871         {
 872           ArrayList<SequenceI[]> seqsMap = new ArrayList<SequenceI[]>();
 873           for (SequenceI seq : sequences)
 874           {
 875             seqsMap.add(new SequenceI[] { seq });
 876           }
 877           SequenceI[][] collatedSeqs = seqsMap.toArray(new SequenceI[0][0]);
 878       ssm.setProgressBar(null);
 879       ssm.setProgressBar("Fetching PDB Structures for selected entries..");
 880           sViewer.viewStructures(pdbEntriesToView, collatedSeqs, alignPanel);
 881         }
 882         else
 883         {
 884       ssm.setProgressBar(null);
 885       ssm.setProgressBar("Fetching PDB Structure for "
 886               + pdbEntriesToView[0].getId());
 887           sViewer.viewStructures(pdbEntriesToView[0], sequences, alignPanel);
 888         }
 889   }
 890
 891   /**
 892    * Populates the combo-box used in associating manually fetched structures to
 893    * a unique sequence when more than one sequence selection is made.
 894    */
 895   @Override
 896   public void populateCmbAssociateSeqOptions(
 897           JComboBox<AssociateSeqOptions> cmb_assSeq, JLabel lbl_associateSeq)
 898   {
 899     cmb_assSeq.removeAllItems();
 900     cmb_assSeq.addItem(new AssociateSeqOptions("-Select Associated Seq-",
 901             null));
 902     lbl_associateSeq.setVisible(false);
 903     if (selectedSequences.length > 1)
 904     {
 905       for (SequenceI seq : selectedSequences)
 906       {
 907         cmb_assSeq.addItem(new AssociateSeqOptions(seq));
 908       }
 909     }
 910     else
 911     {
 912       String seqName = selectedSequence.getDisplayId(false);
 913       seqName = seqName.length() <= 40 ? seqName : seqName.substring(0, 39);
 914       lbl_associateSeq.setText(seqName);
 915       lbl_associateSeq.setVisible(true);
 916       cmb_assSeq.setVisible(false);
 917     }
 918   }
 919
 920   public boolean isStructuresDiscovered()
 921   {
 922     return structuresDiscovered;
 923   }
 924
 925   public void setStructuresDiscovered(boolean structuresDiscovered)
 926   {
 927     this.structuresDiscovered = structuresDiscovered;
 928   }
 929
 930   public Collection<PDBResponseSummary> getDiscoveredStructuresSet()
 931   {
 932     return discoveredStructuresSet;
 933   }
 934
 935   @Override
 936   protected void txt_search_ActionPerformed()
 937   {
 938     new Thread()
 939     {
 940       @Override
 941       public void run()
 942       {
 943         errorWarning.setLength(0);
 944         isValidPBDEntry = false;
 945         if (txt_search.getText().length() > 0)
 946         {
 947           List<PDBDocField> wantedFields = new ArrayList<PDBDocField>();
 948           wantedFields.add(PDBDocField.PDB_ID);
 949           PDBRestRequest pdbRequest = new PDBRestRequest();
 950           pdbRequest.setAllowEmptySeq(false);
 951           pdbRequest.setResponseSize(1);
 952           pdbRequest.setFieldToSearchBy("(pdb_id:");
 953           pdbRequest.setWantedFields(wantedFields);
 954           pdbRequest
 955                   .setSearchTerm(txt_search.getText().toLowerCase() + ")");
 956           pdbRequest.setAssociatedSequence(selectedSequence);
 957           pdbRestCleint = new PDBRestClient();
 958           PDBRestResponse resultList;
 959           try
 960           {
 961             resultList = pdbRestCleint.executeRequest(pdbRequest);
 962           } catch (Exception e)
 963           {
 964             errorWarning.append(e.getMessage());
 965             return;
 966           } finally
 967           {
 968             validateSelections();
 969           }
 970           if (resultList.getSearchSummary() != null
 971                   && resultList.getSearchSummary().size() > 0)
 972           {
 973             isValidPBDEntry = true;
 974           }
 975         }
 976         validateSelections();
 977       }
 978     }.start();
 979   }
 980
 981   @Override
 982   public void tabRefresh()
 983   {
 984     if (selectedSequences != null)
 985     {
 986       Thread refreshThread = new Thread(new Runnable()
 987       {
 988         @Override
 989         public void run()
 990         {
 991           fetchStructuresMetaData();
 992           filterResultSet(((FilterOption) cmb_filterOption
 993                   .getSelectedItem()).getValue());
 994         }
 995       });
 996       refreshThread.start();
 997     }
 998   }
 999
1000   public class PDBEntryTableModel extends AbstractTableModel
1001   {
1002     String[] columns = { "Ref Sequence", "PDB Id", "Chain", "Type", "File" };
1003
1004     private List<CachedPDB> pdbEntries;
1005
1006     public PDBEntryTableModel(List<CachedPDB> pdbEntries)
1007     {
1008       this.pdbEntries = new ArrayList<CachedPDB>(pdbEntries);
1009     }
1010
1011     @Override
1012     public String getColumnName(int columnIndex)
1013     {
1014       return columns[columnIndex];
1015     }
1016
1017     @Override
1018     public int getRowCount()
1019     {
1020       return pdbEntries.size();
1021     }
1022
1023     @Override
1024     public int getColumnCount()
1025     {
1026       return columns.length;
1027     }
1028
1029     @Override
1030     public boolean isCellEditable(int row, int column)
1031     {
1032       return false;
1033     }
1034
1035     @Override
1036     public Object getValueAt(int rowIndex, int columnIndex)
1037     {
1038       Object value = "??";
1039       CachedPDB entry = pdbEntries.get(rowIndex);
1040       switch (columnIndex)
1041       {
1042       case 0:
1043         value = entry.getSequence();
1044         break;
1045       case 1:
1046         value = entry.getPdbEntry();
1047         break;
1048       case 2:
1049         value = entry.getPdbEntry().getChainCode() == null ? "_" : entry
1050                 .getPdbEntry().getChainCode();
1051         break;
1052       case 3:
1053         value = entry.getPdbEntry().getType();
1054         break;
1055       case 4:
1056         value = entry.getPdbEntry().getFile();
1057         break;
1058       }
1059       return value;
1060     }
1061
1062     @Override
1063     public Class<?> getColumnClass(int columnIndex)
1064     {
1065       return columnIndex == 0 ? SequenceI.class : PDBEntry.class;
1066     }
1067
1068     public CachedPDB getPDBEntryAt(int row)
1069     {
1070       return pdbEntries.get(row);
1071     }
1072
1073   }
1074
1075   private class CachedPDB
1076   {
1077     private SequenceI sequence;
1078
1079     private PDBEntry pdbEntry;
1080
1081     public CachedPDB(SequenceI sequence, PDBEntry pdbEntry)
1082     {
1083       this.sequence = sequence;
1084       this.pdbEntry = pdbEntry;
1085     }
1086
1087     public SequenceI getSequence()
1088     {
1089       return sequence;
1090     }
1091
1092     public PDBEntry getPdbEntry()
1093     {
1094       return pdbEntry;
1095     }
1096
1097   }
1098
1099   private IProgressIndicator progressBar;
1100
1101   @Override
1102   public void setProgressBar(String message, long id)
1103   {
1104     progressBar.setProgressBar(message, id);
1105   }
1106
1107   @Override
1108   public void registerHandler(long id, IProgressIndicatorHandler handler)
1109   {
1110     progressBar.registerHandler(id, handler);
1111   }
1112
1113   @Override
1114   public boolean operationInProgress()
1115   {
1116     return progressBar.operationInProgress();
1117   }
1118 }