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