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