src/jalview/io/JSONFile.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.io;
  23
  24 import jalview.api.AlignmentViewPanel;
  25 import jalview.api.ComplexAlignFile;
  26 import jalview.api.FeatureRenderer;
  27 import jalview.api.FeaturesDisplayedI;
  28 import jalview.datamodel.AlignmentAnnotation;
  29 import jalview.datamodel.Annotation;
  30 import jalview.datamodel.ColumnSelection;
  31 import jalview.datamodel.HiddenSequences;
  32 import jalview.datamodel.Sequence;
  33 import jalview.datamodel.SequenceFeature;
  34 import jalview.datamodel.SequenceGroup;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.json.binding.v1.AlignmentAnnotationPojo;
  37 import jalview.json.binding.v1.AlignmentPojo;
  38 import jalview.json.binding.v1.AlignmentPojo.JalviewBioJsColorSchemeMapper;
  39 import jalview.json.binding.v1.AnnotationPojo;
  40 import jalview.json.binding.v1.SequenceFeaturesPojo;
  41 import jalview.json.binding.v1.SequenceGrpPojo;
  42 import jalview.json.binding.v1.SequencePojo;
  43 import jalview.schemes.ColourSchemeI;
  44 import jalview.schemes.ColourSchemeProperty;
  45
  46 import java.awt.Color;
  47 import java.io.IOException;
  48 import java.io.Reader;
  49 import java.util.ArrayList;
  50 import java.util.Hashtable;
  51 import java.util.Iterator;
  52 import java.util.List;
  53 import java.util.Vector;
  54
  55 import org.json.simple.JSONArray;
  56 import org.json.simple.JSONObject;
  57 import org.json.simple.parser.JSONParser;
  58
  59 public class JSONFile extends AlignFile implements ComplexAlignFile
  60 {
  61   private ColourSchemeI colourScheme;
  62
  63   private String version = "2.9";
  64
  65   private String webstartUrl = "www.jalview.org/services/launchApp";
  66
  67   private String application = "Jalview";
  68
  69   public static final String FILE_EXT = "json";
  70
  71   public static final String FILE_DESC = "JSON";
  72
  73   private String globalColorScheme;
  74
  75   private boolean showSeqFeatures;
  76
  77   private Hashtable<String, Sequence> seqMap;
  78
  79   private FeaturesDisplayedI displayedFeatures;
  80
  81   private FeatureRenderer fr;
  82
  83   private List<int[]> hiddenColumns;
  84
  85   private ColumnSelection columnSelection;
  86
  87   private List<String> hiddenSeqRefs;
  88
  89   private ArrayList<SequenceI> hiddenSequences;
  90
  91   public JSONFile()
  92   {
  93     super();
  94   }
  95
  96   public JSONFile(FileParse source) throws IOException
  97   {
  98     super(source);
  99   }
 100
 101   public JSONFile(String inFile, String type) throws IOException
 102   {
 103     super(inFile, type);
 104   }
 105
 106   @Override
 107   public void parse() throws IOException
 108   {
 109     parse(getReader());
 110
 111   }
 112   @Override
 113   public String print()
 114   {
 115     String jsonOutput = null;
 116     try
 117     {
 118       AlignmentPojo jsonAlignmentPojo = new AlignmentPojo();
 119       if (getViewport() != null)
 120       {
 121         configureFromViewport();
 122
 123       }
 124
 125       int count = 0;
 126       for (SequenceI seq : seqs)
 127       {
 128         StringBuilder name = new StringBuilder();
 129         name.append(seq.getName()).append("/").append(seq.getStart())
 130                 .append("-").append(seq.getEnd());
 131         SequencePojo jsonSeqPojo = new SequencePojo();
 132         jsonSeqPojo.setId(String.valueOf(seq.hashCode()));
 133         jsonSeqPojo.setOrder(++count);
 134         jsonSeqPojo.setEnd(seq.getEnd());
 135         jsonSeqPojo.setStart(seq.getStart());
 136         jsonSeqPojo.setName(name.toString());
 137         jsonSeqPojo.setSeq(seq.getSequenceAsString());
 138         jsonAlignmentPojo.getSeqs().add(jsonSeqPojo);
 139       }
 140
 141       jsonAlignmentPojo.setGlobalColorScheme(globalColorScheme);
 142       jsonAlignmentPojo.getAppSettings().put("application", application);
 143       jsonAlignmentPojo.getAppSettings().put("version", version);
 144       jsonAlignmentPojo.getAppSettings().put("webStartUrl", webstartUrl);
 145       jsonAlignmentPojo.getAppSettings().put("showSeqFeatures",
 146               String.valueOf(showSeqFeatures));
 147
 148       String[] hiddenSections = getHiddenSections();
 149       if (hiddenSections != null)
 150       {
 151         if (hiddenSections[0] != null
 152                 && getExportSettings()
 153                         .isExportHiddenColumns())
 154         {
 155           jsonAlignmentPojo.getAppSettings().put("hiddenCols",
 156                   String.valueOf(hiddenSections[0]));
 157         }
 158         if (hiddenSections[1] != null
 159                 && getExportSettings()
 160                         .isExportHiddenSequences())
 161         {
 162           jsonAlignmentPojo.getAppSettings().put("hiddenSeqs",
 163                   String.valueOf(hiddenSections[1]));
 164         }
 165       }
 166
 167       if (getExportSettings().isExportAnnotations())
 168       {
 169         jsonAlignmentPojo
 170                 .setAlignAnnotation(annotationToJsonPojo(annotations));
 171       }
 172
 173       if (getExportSettings().isExportFeatures())
 174       {
 175         jsonAlignmentPojo
 176                 .setSeqFeatures(sequenceFeatureToJsonPojo(seqs, fr));
 177       }
 178
 179       if (getExportSettings().isExportGroups()
 180               && seqGroups != null
 181               && seqGroups.size() > 0)
 182       {
 183         for (SequenceGroup seqGrp : seqGroups)
 184         {
 185           SequenceGrpPojo seqGrpPojo = new SequenceGrpPojo();
 186           seqGrpPojo.setGroupName(seqGrp.getName());
 187           seqGrpPojo.setColourScheme(ColourSchemeProperty
 188                   .getColourName(seqGrp.cs));
 189           seqGrpPojo.setColourText(seqGrp.getColourText());
 190           seqGrpPojo.setDescription(seqGrp.getDescription());
 191           seqGrpPojo.setDisplayBoxes(seqGrp.getDisplayBoxes());
 192           seqGrpPojo.setDisplayText(seqGrp.getDisplayText());
 193           seqGrpPojo.setEndRes(seqGrp.getEndRes());
 194           seqGrpPojo.setStartRes(seqGrp.getStartRes());
 195           seqGrpPojo.setShowNonconserved(seqGrp.getShowNonconserved());
 196           for (SequenceI seq : seqGrp.getSequences())
 197           {
 198             seqGrpPojo.getSeqsHash().add(String.valueOf(seq.hashCode()));
 199           }
 200           jsonAlignmentPojo.getSeqGroups().add(seqGrpPojo);
 201         }
 202       }
 203       org.json.JSONObject generatedJSon = new org.json.JSONObject(
 204               jsonAlignmentPojo);
 205       jsonOutput = generatedJSon.toString();
 206       return jsonOutput.replaceAll("xstart", "xStart").replaceAll("xend",
 207               "xEnd");
 208     } catch (Exception e)
 209     {
 210       e.printStackTrace();
 211     }
 212     return jsonOutput;
 213   }
 214
 215   public String[] getHiddenSections()
 216   {
 217     String[] hiddenSections = new String[2];
 218     if (getViewport() == null)
 219     {
 220       return null;
 221     }
 222
 223     // hidden column business
 224     if (getViewport().hasHiddenColumns())
 225     {
 226       List<int[]> hiddenCols = getViewport().getColumnSelection()
 227               .getHiddenColumns();
 228       StringBuilder hiddenColsBuilder = new StringBuilder();
 229       for (int[] range : hiddenCols)
 230       {
 231         hiddenColsBuilder.append(";").append(range[0]).append("-")
 232                 .append(range[1]);
 233       }
 234
 235       hiddenColsBuilder.deleteCharAt(0);
 236       hiddenSections[0] = hiddenColsBuilder.toString();
 237     }
 238
 239     // hidden rows/seqs business
 240     HiddenSequences hiddenSeqsObj = getViewport().getAlignment()
 241             .getHiddenSequences();
 242     if (hiddenSeqsObj == null || hiddenSeqsObj.hiddenSequences == null)
 243     {
 244       return hiddenSections;
 245     }
 246
 247     SequenceI[] hiddenSeqs = hiddenSeqsObj.hiddenSequences;
 248     StringBuilder hiddenSeqsBuilder = new StringBuilder();
 249     for (SequenceI hiddenSeq : hiddenSeqs)
 250     {
 251       if (hiddenSeq != null)
 252       {
 253         hiddenSeqsBuilder.append(";").append(hiddenSeq.hashCode());
 254       }
 255     }
 256     if (hiddenSeqsBuilder.length() > 0)
 257     {
 258       hiddenSeqsBuilder.deleteCharAt(0);
 259     }
 260     hiddenSections[1] = hiddenSeqsBuilder.toString();
 261
 262     return hiddenSections;
 263   }
 264
 265   public static List<SequenceFeaturesPojo> sequenceFeatureToJsonPojo(
 266           List<SequenceI> seqs, FeatureRenderer fr)
 267   {
 268     FeaturesDisplayedI displayedFeatures = (fr == null) ? null : fr
 269             .getFeaturesDisplayed();
 270     List<SequenceFeaturesPojo> sequenceFeaturesPojo = new ArrayList<SequenceFeaturesPojo>();
 271     for (SequenceI seq : seqs)
 272     {
 273       SequenceI dataSetSequence = seq.getDatasetSequence();
 274       SequenceFeature[] seqFeatures = (dataSetSequence == null) ? null
 275               : seq.getDatasetSequence().getSequenceFeatures();
 276
 277       seqFeatures = (seqFeatures == null) ? seq.getSequenceFeatures()
 278               : seqFeatures;
 279       if (seqFeatures == null)
 280       {
 281         continue;
 282       }
 283
 284       for (SequenceFeature sf : seqFeatures)
 285       {
 286         if (displayedFeatures != null
 287                 && displayedFeatures.isVisible(sf.getType()))
 288         {
 289           SequenceFeaturesPojo jsonFeature = new SequenceFeaturesPojo(
 290                   String.valueOf(seq.hashCode()));
 291           String featureColour = (fr == null) ? null : jalview.util.Format
 292                   .getHexString(fr
 293                   .findFeatureColour(Color.white, seq,
 294                           seq.findIndex(sf.getBegin())));
 295           jsonFeature.setXstart(seq.findIndex(sf.getBegin()) - 1);
 296           jsonFeature.setXend(seq.findIndex(sf.getEnd()));
 297           jsonFeature.setType(sf.getType());
 298           jsonFeature.setDescription(sf.getDescription());
 299           jsonFeature.setLinks(sf.links);
 300           jsonFeature.setOtherDetails(sf.otherDetails);
 301           jsonFeature.setScore(sf.getScore());
 302           jsonFeature.setFillColor(featureColour);
 303           jsonFeature.setFeatureGroup(sf.getFeatureGroup());
 304           sequenceFeaturesPojo.add(jsonFeature);
 305         }
 306       }
 307     }
 308     return sequenceFeaturesPojo;
 309   }
 310
 311   public static List<AlignmentAnnotationPojo> annotationToJsonPojo(
 312           Vector<AlignmentAnnotation> annotations)
 313   {
 314     List<AlignmentAnnotationPojo> jsonAnnotations = new ArrayList<AlignmentAnnotationPojo>();
 315     if (annotations == null)
 316     {
 317       return jsonAnnotations;
 318     }
 319     for (AlignmentAnnotation annot : annotations)
 320     {
 321       AlignmentAnnotationPojo alignAnnotPojo = new AlignmentAnnotationPojo();
 322       alignAnnotPojo.setDescription(annot.description);
 323       alignAnnotPojo.setLabel(annot.label);
 324       for (Annotation annotation : annot.annotations)
 325       {
 326         AnnotationPojo annotationPojo = new AnnotationPojo();
 327         if (annotation != null)
 328         {
 329           annotationPojo.setDescription(annotation.description);
 330           annotationPojo.setValue(annotation.value);
 331           annotationPojo
 332                   .setSecondaryStructure(annotation.secondaryStructure);
 333           annotationPojo.setDisplayCharacter(annotation.displayCharacter);
 334           alignAnnotPojo.getAnnotations().add(annotationPojo);
 335         }
 336         else
 337         {
 338           alignAnnotPojo.getAnnotations().add(annotationPojo);
 339         }
 340       }
 341       jsonAnnotations.add(alignAnnotPojo);
 342     }
 343     return jsonAnnotations;
 344   }
 345
 346   @SuppressWarnings("unchecked")
 347   public JSONFile parse(Reader jsonAlignmentString)
 348   {
 349     try
 350     {
 351       JSONParser jsonParser = new JSONParser();
 352       JSONObject alignmentJsonObj = (JSONObject) jsonParser
 353               .parse(jsonAlignmentString);
 354       JSONArray seqJsonArray = (JSONArray) alignmentJsonObj.get("seqs");
 355       JSONArray alAnnotJsonArray = (JSONArray) alignmentJsonObj
 356               .get("alignAnnotation");
 357       JSONArray jsonSeqArray = (JSONArray) alignmentJsonObj
 358               .get("seqFeatures");
 359       JSONArray seqGrpJsonArray = (JSONArray) alignmentJsonObj
 360               .get("seqGroups");
 361       JSONObject jvSettingsJsonObj = (JSONObject) alignmentJsonObj
 362               .get("appSettings");
 363
 364       if (jvSettingsJsonObj != null)
 365       {
 366         String jsColourScheme = (String) jvSettingsJsonObj
 367                 .get("globalColorScheme");
 368         Boolean showFeatures = Boolean.valueOf(jvSettingsJsonObj.get(
 369                 "showSeqFeatures").toString());
 370         setColourScheme(getJalviewColorScheme(jsColourScheme));
 371         setShowSeqFeatures(showFeatures);
 372         parseHiddenSeqRefsAsList(jvSettingsJsonObj);
 373         parseHiddenCols(jvSettingsJsonObj);
 374       }
 375
 376       hiddenSequences = new ArrayList<SequenceI>();
 377       seqMap = new Hashtable<String, Sequence>();
 378       for (Iterator<JSONObject> sequenceIter = seqJsonArray.iterator(); sequenceIter
 379               .hasNext();)
 380       {
 381         JSONObject sequence = sequenceIter.next();
 382         String sequcenceString = sequence.get("seq").toString();
 383         String sequenceName = sequence.get("name").toString();
 384         String seqUniqueId = sequence.get("id").toString();
 385         int start = Integer.valueOf(sequence.get("start").toString());
 386         int end = Integer.valueOf(sequence.get("end").toString());
 387         Sequence seq = new Sequence(sequenceName, sequcenceString, start,
 388                 end);
 389         if (hiddenSeqRefs != null && hiddenSeqRefs.contains(seqUniqueId))
 390         {
 391           hiddenSequences.add(seq);
 392         }
 393         seqs.add(seq);
 394         seqMap.put(seqUniqueId, seq);
 395       }
 396       parseFeatures(jsonSeqArray);
 397
 398       for (Iterator<JSONObject> seqGrpIter = seqGrpJsonArray.iterator(); seqGrpIter
 399               .hasNext();)
 400       {
 401         JSONObject seqGrpObj = seqGrpIter.next();
 402         String grpName = seqGrpObj.get("groupName").toString();
 403         String colourScheme = seqGrpObj.get("colourScheme").toString();
 404         String description = (seqGrpObj.get("description") == null) ? null
 405                 : seqGrpObj.get("description").toString();
 406         boolean displayBoxes = Boolean.valueOf(seqGrpObj
 407                 .get("displayBoxes").toString());
 408         boolean displayText = Boolean.valueOf(seqGrpObj.get("displayText")
 409                 .toString());
 410         boolean colourText = Boolean.valueOf(seqGrpObj.get("colourText")
 411                 .toString());
 412         boolean showNonconserved = Boolean.valueOf(seqGrpObj.get(
 413                 "showNonconserved").toString());
 414         int startRes = Integer
 415                 .valueOf(seqGrpObj.get("startRes").toString());
 416         int endRes = Integer.valueOf(seqGrpObj.get("endRes").toString());
 417         JSONArray seqsHashArray = (JSONArray) seqGrpObj.get("seqsHash");
 418
 419         ArrayList<SequenceI> grpSeqs = new ArrayList<SequenceI>();
 420         if (seqsHashArray.size() > 0)
 421         {
 422           Iterator<String> seqHashIter = seqsHashArray.iterator();
 423           while (seqHashIter.hasNext())
 424           {
 425             String seqHash = seqHashIter.next();
 426             Sequence sequence = seqMap.get(seqHash);
 427             if (sequence != null)
 428             {
 429               grpSeqs.add(sequence);
 430             }
 431           }
 432         }
 433         ColourSchemeI scheme = getJalviewColorScheme(colourScheme);
 434         SequenceGroup seqGrp = new SequenceGroup(grpSeqs, grpName, scheme,
 435                 displayBoxes, displayText, colourText, startRes, endRes);
 436         seqGrp.setShowNonconserved(showNonconserved);
 437         seqGrp.setDescription(description);
 438         this.seqGroups.add(seqGrp);
 439
 440       }
 441
 442       for (Iterator<JSONObject> alAnnotIter = alAnnotJsonArray.iterator(); alAnnotIter
 443               .hasNext();)
 444       {
 445         JSONObject alAnnot = alAnnotIter.next();
 446         JSONArray annotJsonArray = (JSONArray) alAnnot.get("annotations");
 447         Annotation[] annotations = new Annotation[annotJsonArray.size()];
 448         int count = 0;
 449         for (Iterator<JSONObject> annotIter = annotJsonArray.iterator(); annotIter
 450                 .hasNext();)
 451         {
 452           JSONObject annot = annotIter.next();
 453           if (annot == null)
 454           {
 455             annotations[count] = null;
 456           }
 457           else
 458           {
 459             float val = annot.get("value") == null ? null : Float
 460                     .valueOf(annot.get("value").toString());
 461             String desc = annot.get("description") == null ? null : annot
 462                     .get("description").toString();
 463
 464             char ss = annot.get("secondaryStructure") == null ? ' '
 465                     : annot.get("secondaryStructure").toString().charAt(0);
 466             String displayChar = annot.get("displayCharacter").toString();
 467
 468             annotations[count] = new Annotation(displayChar, desc, ss, val);
 469           }
 470           ++count;
 471         }
 472
 473         AlignmentAnnotation alignAnnot = new AlignmentAnnotation(alAnnot
 474                 .get("label").toString(), alAnnot.get("description")
 475                 .toString(), annotations);
 476         this.annotations.add(alignAnnot);
 477       }
 478
 479     } catch (Exception e)
 480     {
 481       e.printStackTrace();
 482     }
 483     return this;
 484   }
 485
 486   public void parseHiddenSeqRefsAsList(JSONObject jvSettingsJson)
 487   {
 488     hiddenSeqRefs = new ArrayList<String>();
 489     String hiddenSeqs = (String) jvSettingsJson.get("hiddenSeqs");
 490     if(hiddenSeqs != null && !hiddenSeqs.isEmpty()){
 491       String[] seqRefs = hiddenSeqs.split(";");
 492       for(String seqRef : seqRefs){
 493         hiddenSeqRefs.add(seqRef);
 494       }
 495     }
 496   }
 497
 498   public void parseHiddenCols(JSONObject jvSettingsJson)
 499   {
 500     String hiddenCols = (String) jvSettingsJson.get("hiddenCols");
 501     if(hiddenCols != null && !hiddenCols.isEmpty()){
 502       columnSelection = new ColumnSelection();
 503       String[] rangeStrings = hiddenCols.split(";");
 504       for(String rangeString : rangeStrings){
 505         String[] range = rangeString.split("-");
 506         columnSelection.hideColumns(Integer.valueOf(range[0]),
 507                 Integer.valueOf(range[1]));
 508       }
 509     }
 510   }
 511
 512   @SuppressWarnings("unchecked")
 513   private void parseFeatures(JSONArray jsonSeqFeatures)
 514   {
 515     if (jsonSeqFeatures != null)
 516     {
 517       for (Iterator<JSONObject> seqFeatureItr = jsonSeqFeatures.iterator(); seqFeatureItr
 518               .hasNext();)
 519       {
 520         JSONObject jsonFeature = seqFeatureItr.next();
 521         Long begin = (Long) jsonFeature.get("xStart");
 522         Long end = (Long) jsonFeature.get("xEnd");
 523         String type = (String) jsonFeature.get("type");
 524         String featureGrp = (String) jsonFeature.get("featureGroup");
 525         String descripiton = (String) jsonFeature.get("description");
 526         String seqRef = (String) jsonFeature.get("sequenceRef");
 527         Float score = Float.valueOf(jsonFeature.get("score").toString());
 528
 529         Sequence seq = seqMap.get(seqRef);
 530         SequenceFeature sequenceFeature = new SequenceFeature();
 531         JSONArray linksJsonArray = (JSONArray) jsonFeature.get("links");
 532         if (linksJsonArray != null && linksJsonArray.size() > 0)
 533         {
 534           Iterator<String> linkList = linksJsonArray.iterator();
 535           while (linkList.hasNext())
 536           {
 537             String link = linkList.next();
 538             sequenceFeature.addLink(link);
 539           }
 540         }
 541         sequenceFeature.setFeatureGroup(featureGrp);
 542         sequenceFeature.setScore(score);
 543         sequenceFeature.setDescription(descripiton);
 544         sequenceFeature.setType(type);
 545         sequenceFeature.setBegin(seq.findPosition(begin.intValue()));
 546         sequenceFeature.setEnd(seq.findPosition(end.intValue()) - 1);
 547         seq.addSequenceFeature(sequenceFeature);
 548       }
 549     }
 550   }
 551
 552   public static ColourSchemeI getJalviewColorScheme(
 553           String bioJsColourSchemeName)
 554   {
 555     ColourSchemeI jalviewColor = null;
 556     for (JalviewBioJsColorSchemeMapper cs : JalviewBioJsColorSchemeMapper
 557             .values())
 558     {
 559       if (cs.getBioJsName().equalsIgnoreCase(bioJsColourSchemeName))
 560       {
 561         jalviewColor = cs.getJvColourScheme();
 562         break;
 563       }
 564     }
 565     return jalviewColor;
 566   }
 567
 568   public String getGlobalColorScheme()
 569   {
 570     return globalColorScheme;
 571   }
 572
 573   public void setGlobalColorScheme(String globalColorScheme)
 574   {
 575     this.globalColorScheme = globalColorScheme;
 576   }
 577
 578   public ColourSchemeI getColourScheme()
 579   {
 580     return colourScheme;
 581   }
 582
 583   public void setColourScheme(ColourSchemeI colourScheme)
 584   {
 585     this.colourScheme = colourScheme;
 586   }
 587
 588   public FeaturesDisplayedI getDisplayedFeatures()
 589   {
 590     return displayedFeatures;
 591   }
 592
 593   public void setDisplayedFeatures(FeaturesDisplayedI displayedFeatures)
 594   {
 595     this.displayedFeatures = displayedFeatures;
 596   }
 597
 598   public void configureForView(AlignmentViewPanel avpanel)
 599   {
 600
 601     setViewport(avpanel.getAlignViewport());
 602     seqGroups = avpanel.getAlignment().getGroups();
 603     setDisplayedFeatures(getViewport().getFeaturesDisplayed());
 604     fr = avpanel.cloneFeatureRenderer();
 605
 606     for (SequenceI seq : getViewport().getAlignment().getSequences())
 607     {
 608       seqs.add(seq);
 609     }
 610
 611     // Add non auto calculated annotation to AlignFile
 612     for (AlignmentAnnotation annot : getViewport().getAlignment()
 613             .getAlignmentAnnotation())
 614     {
 615       if (annot != null && !annot.autoCalculated)
 616       {
 617         if (annot.label.equals("PDB.CATempFactor"))
 618         {
 619           continue;
 620         }
 621         annotations.add(annot);
 622       }
 623     }
 624   }
 625
 626   public void configureFromViewport()
 627   {
 628     if (getViewport() == null)
 629     {
 630       return;
 631     }
 632     globalColorScheme = ColourSchemeProperty.getColourName(getViewport()
 633             .getGlobalColourScheme());
 634     setDisplayedFeatures(getViewport().getFeaturesDisplayed());
 635     showSeqFeatures = getViewport().isShowSequenceFeatures();
 636   }
 637
 638   public static String getJSONData(AlignmentViewPanel av)
 639   {
 640     JSONFile jsonFile = new JSONFile();
 641     jsonFile.configureForView(av);
 642     String jsonString = jsonFile.print();
 643     return jsonString;
 644   }
 645
 646   public boolean isShowSeqFeatures()
 647   {
 648     return showSeqFeatures;
 649   }
 650
 651   public void setShowSeqFeatures(boolean showSeqFeatures)
 652   {
 653     this.showSeqFeatures = showSeqFeatures;
 654   }
 655
 656   public Vector<AlignmentAnnotation> getAnnotations()
 657   {
 658     return annotations;
 659   }
 660
 661   public List<int[]> getHiddenColumns()
 662   {
 663     return hiddenColumns;
 664   }
 665
 666   public ColumnSelection getColumnSelection()
 667   {
 668     return columnSelection;
 669   }
 670
 671   public void setColumnSelection(ColumnSelection columnSelection)
 672   {
 673     this.columnSelection = columnSelection;
 674   }
 675
 676   public SequenceI[] getHiddenSequences()
 677   {
 678     if (hiddenSequences == null || hiddenSequences.isEmpty())
 679     {
 680       return new SequenceI[]
 681       {};
 682     }
 683     synchronized (hiddenSequences)
 684     {
 685       return hiddenSequences.toArray(new SequenceI[hiddenSequences.size()]);
 686     }
 687   }
 688
 689   public void setHiddenSequences(ArrayList<SequenceI> hiddenSequences)
 690   {
 691     this.hiddenSequences = hiddenSequences;
 692   }
 693
 694   public class JSONExportSettings
 695   {
 696     private boolean exportSequence;
 697
 698     private boolean exportSequenceFeatures;
 699
 700     private boolean exportAnnotations;
 701
 702     private boolean exportGroups;
 703
 704     private boolean exportJalviewSettings;
 705
 706     public boolean isExportSequence()
 707     {
 708       return exportSequence;
 709     }
 710
 711     public void setExportSequence(boolean exportSequence)
 712     {
 713       this.exportSequence = exportSequence;
 714     }
 715
 716     public boolean isExportSequenceFeatures()
 717     {
 718       return exportSequenceFeatures;
 719     }
 720
 721     public void setExportSequenceFeatures(boolean exportSequenceFeatures)
 722     {
 723       this.exportSequenceFeatures = exportSequenceFeatures;
 724     }
 725
 726     public boolean isExportAnnotations()
 727     {
 728       return exportAnnotations;
 729     }
 730
 731     public void setExportAnnotations(boolean exportAnnotations)
 732     {
 733       this.exportAnnotations = exportAnnotations;
 734     }
 735
 736     public boolean isExportGroups()
 737     {
 738       return exportGroups;
 739     }
 740
 741     public void setExportGroups(boolean exportGroups)
 742     {
 743       this.exportGroups = exportGroups;
 744     }
 745
 746     public boolean isExportJalviewSettings()
 747     {
 748       return exportJalviewSettings;
 749     }
 750
 751     public void setExportJalviewSettings(boolean exportJalviewSettings)
 752     {
 753       this.exportJalviewSettings = exportJalviewSettings;
 754     }
 755   }
 756 }