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