src/jalview/gui/AnnotationExporter.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 package jalview.gui;
  22
  23 import java.awt.Color;
  24 import java.awt.Dimension;
  25 import java.awt.event.ActionEvent;
  26 import java.awt.event.ActionListener;
  27 import java.io.FileWriter;
  28 import java.io.PrintWriter;
  29 import java.util.Locale;
  30
  31 import javax.swing.BoxLayout;
  32 import javax.swing.ButtonGroup;
  33 import javax.swing.JButton;
  34 import javax.swing.JCheckBox;
  35 import javax.swing.JInternalFrame;
  36 import javax.swing.JLabel;
  37 import javax.swing.JLayeredPane;
  38 import javax.swing.JPanel;
  39 import javax.swing.JRadioButton;
  40 import javax.swing.SwingConstants;
  41
  42 import jalview.api.FeatureRenderer;
  43 import jalview.bin.Cache;
  44 import jalview.datamodel.AlignmentAnnotation;
  45 import jalview.datamodel.SequenceI;
  46 import jalview.io.AnnotationFile;
  47 import jalview.io.FeaturesFile;
  48 import jalview.io.JalviewFileChooser;
  49 import jalview.io.JalviewFileView;
  50 import jalview.util.MessageManager;
  51
  52 /**
  53  *
  54  * GUI dialog for exporting features or alignment annotations depending upon
  55  * which method is called.
  56  *
  57  * @author AMW
  58  *
  59  */
  60 public class AnnotationExporter extends JPanel
  61 {
  62   private JInternalFrame frame;
  63
  64   private AlignmentPanel ap;
  65
  66   /*
  67    * true if exporting features, false if exporting annotations
  68    */
  69   private boolean exportFeatures = true;
  70
  71   private AlignmentAnnotation[] annotations;
  72
  73   private boolean wholeView;
  74
  75   /*
  76    * option to export linked (CDS/peptide) features when shown
  77    * on the alignment, converted to this alignment's coordinates
  78    */
  79   private JCheckBox includeLinkedFeatures;
  80
  81   /*
  82    * output format option shown for feature export
  83    */
  84   JRadioButton GFFFormat = new JRadioButton();
  85
  86   /*
  87    * output format option shown for annotation export
  88    */
  89   JRadioButton CSVFormat = new JRadioButton();
  90
  91   private JPanel linkedFeaturesPanel;
  92
  93   /**
  94    * Constructor
  95    *
  96    * @param panel
  97    */
  98   public AnnotationExporter(AlignmentPanel panel)
  99   {
 100     this.ap = panel;
 101     try
 102     {
 103       jbInit();
 104     } catch (Exception ex)
 105     {
 106       ex.printStackTrace();
 107     }
 108
 109     frame = new JInternalFrame();
 110     frame.setFrameIcon(null);
 111     frame.setContentPane(this);
 112     frame.setLayer(JLayeredPane.PALETTE_LAYER);
 113     Dimension preferredSize = frame.getPreferredSize();
 114     Desktop.addInternalFrame(frame, "", true, preferredSize.width,
 115             preferredSize.height, true, true);
 116   }
 117
 118   /**
 119    * Configures the dialog for options to export visible features. If from a
 120    * split frame panel showing linked features, make the option to include these
 121    * in the export visible.
 122    */
 123   public void exportFeatures()
 124   {
 125     exportFeatures = true;
 126     CSVFormat.setVisible(false);
 127     if (ap.av.isShowComplementFeatures())
 128     {
 129       linkedFeaturesPanel.setVisible(true);
 130       frame.pack();
 131     }
 132     frame.setTitle(MessageManager.getString("label.export_features"));
 133   }
 134
 135   /**
 136    * Configures the dialog for options to export all visible annotations
 137    */
 138   public void exportAnnotations()
 139   {
 140     boolean showAnnotation = ap.av.isShowAnnotation();
 141     exportAnnotation(showAnnotation ? null
 142             : ap.av.getAlignment().getAlignmentAnnotation(), true);
 143   }
 144
 145   /**
 146    * Configures the dialog for options to export the given annotation row
 147    *
 148    * @param toExport
 149    */
 150   public void exportAnnotation(AlignmentAnnotation toExport)
 151   {
 152     exportAnnotation(new AlignmentAnnotation[] { toExport }, false);
 153   }
 154
 155   private void exportAnnotation(AlignmentAnnotation[] toExport,
 156           boolean forWholeView)
 157   {
 158     wholeView = forWholeView;
 159     annotations = toExport;
 160     exportFeatures = false;
 161     GFFFormat.setVisible(false);
 162     CSVFormat.setVisible(true);
 163     frame.setTitle(MessageManager.getString("label.export_annotations"));
 164   }
 165
 166   private void toFile_actionPerformed()
 167   {
 168     // TODO: JAL-3048 JalviewFileChooser - Save option
 169     JalviewFileChooser chooser = new JalviewFileChooser(
 170             Cache.getProperty("LAST_DIRECTORY"));
 171
 172     chooser.setFileView(new JalviewFileView());
 173     chooser.setDialogTitle(exportFeatures
 174             ? MessageManager.getString("label.save_features_to_file")
 175             : MessageManager.getString("label.save_annotation_to_file"));
 176     chooser.setToolTipText(MessageManager.getString("action.save"));
 177
 178     int value = chooser.showSaveDialog(this);
 179
 180     if (value == JalviewFileChooser.APPROVE_OPTION)
 181     {
 182       String text = getText();
 183
 184       try
 185       {
 186         PrintWriter out = new PrintWriter(
 187                 new FileWriter(chooser.getSelectedFile()));
 188         out.print(text);
 189         out.close();
 190       } catch (Exception ex)
 191       {
 192         ex.printStackTrace();
 193       }
 194     }
 195
 196     close_actionPerformed();
 197   }
 198
 199   /**
 200    * Answers the text to output for either Features (in GFF or Jalview format)
 201    * or Annotations (in CSV or Jalview format)
 202    *
 203    * @return
 204    */
 205   private String getText()
 206   {
 207     return exportFeatures ? getFeaturesText() : getAnnotationsText();
 208   }
 209
 210   /**
 211    * Returns the text contents for output of annotations in either CSV or
 212    * Jalview format
 213    *
 214    * @return
 215    */
 216   private String getAnnotationsText()
 217   {
 218     String text;
 219     if (CSVFormat.isSelected())
 220     {
 221       text = new AnnotationFile().printCSVAnnotations(annotations);
 222     }
 223     else
 224     {
 225       if (wholeView)
 226       {
 227         text = new AnnotationFile().printAnnotationsForView(ap.av);
 228       }
 229       else
 230       {
 231         text = new AnnotationFile().printAnnotations(annotations, null,
 232                 null);
 233       }
 234     }
 235     return text;
 236   }
 237
 238   /**
 239    * Returns the text contents for output of features in either GFF or Jalview
 240    * format
 241    *
 242    * @return
 243    */
 244   private String getFeaturesText()
 245   {
 246     String text;
 247     SequenceI[] sequences = ap.av.getAlignment().getSequencesArray();
 248     boolean includeNonPositional = ap.av.isShowNPFeats();
 249
 250     FeaturesFile formatter = new FeaturesFile();
 251     final FeatureRenderer fr = ap.getFeatureRenderer();
 252     boolean includeComplement = includeLinkedFeatures.isSelected();
 253
 254     if (GFFFormat.isSelected())
 255     {
 256       text = formatter.printGffFormat(sequences, fr, includeNonPositional,
 257               includeComplement);
 258     }
 259     else
 260     {
 261       text = formatter.printJalviewFormat(sequences, fr,
 262               includeNonPositional, includeComplement);
 263     }
 264     return text;
 265   }
 266
 267   private void toTextbox_actionPerformed()
 268   {
 269     CutAndPasteTransfer cap = new CutAndPasteTransfer();
 270
 271     try
 272     {
 273       String text = getText();
 274       cap.setText(text);
 275       Desktop.addInternalFrame(cap, (exportFeatures ? MessageManager
 276               .formatMessage("label.features_for_params", new String[]
 277               { ap.alignFrame.getTitle() })
 278               : MessageManager.formatMessage("label.annotations_for_params",
 279                       new String[]
 280                       { ap.alignFrame.getTitle() })),
 281               600, 500);
 282     } catch (OutOfMemoryError oom)
 283     {
 284       new OOMWarning((exportFeatures ? MessageManager.formatMessage(
 285               "label.generating_features_for_params", new String[]
 286               { ap.alignFrame.getTitle() })
 287               : MessageManager.formatMessage(
 288                       "label.generating_annotations_for_params",
 289                       new String[]
 290                       { ap.alignFrame.getTitle() })),
 291               oom);
 292       cap.dispose();
 293     }
 294
 295     close_actionPerformed();
 296   }
 297
 298   private void close_actionPerformed()
 299   {
 300     try
 301     {
 302       frame.setClosed(true);
 303     } catch (java.beans.PropertyVetoException ex)
 304     {
 305     }
 306   }
 307
 308   /**
 309    * Adds widgets to the panel
 310    *
 311    * @throws Exception
 312    */
 313   private void jbInit() throws Exception
 314   {
 315     this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
 316     this.setBackground(Color.white);
 317
 318     JPanel formatPanel = buildFormatOptionsPanel();
 319     JPanel linkedFeatures = buildLinkedFeaturesPanel();
 320     JPanel actionsPanel = buildActionsPanel();
 321
 322     this.add(formatPanel);
 323     this.add(linkedFeatures);
 324     this.add(actionsPanel);
 325   }
 326
 327   /**
 328    * Builds a panel with a checkbox for the option to export linked
 329    * (CDS/peptide) features. This is hidden by default, and only made visible if
 330    * exporting features from a split frame panel which is configured to show
 331    * linked features.
 332    *
 333    * @return
 334    */
 335   private JPanel buildLinkedFeaturesPanel()
 336   {
 337     linkedFeaturesPanel = new JPanel();
 338     linkedFeaturesPanel.setOpaque(false);
 339
 340     boolean nucleotide = ap.av.isNucleotide();
 341     String complement = nucleotide ? MessageManager
 342             .getString("label.protein").toLowerCase(Locale.ROOT) : "CDS";
 343     JLabel label = new JLabel(MessageManager
 344             .formatMessage("label.include_linked_features", complement));
 345     label.setHorizontalAlignment(SwingConstants.TRAILING);
 346     String tooltip = MessageManager
 347             .formatMessage("label.include_linked_tooltip", complement);
 348     label.setToolTipText(JvSwingUtils.wrapTooltip(true, tooltip));
 349
 350     includeLinkedFeatures = new JCheckBox();
 351     linkedFeaturesPanel.add(label);
 352     linkedFeaturesPanel.add(includeLinkedFeatures);
 353     linkedFeaturesPanel.setVisible(false);
 354
 355     return linkedFeaturesPanel;
 356   }
 357
 358   /**
 359    * Builds the panel with to File or Textbox or Close actions
 360    *
 361    * @return
 362    */
 363   JPanel buildActionsPanel()
 364   {
 365     JPanel actionsPanel = new JPanel();
 366     actionsPanel.setOpaque(false);
 367
 368     JButton toFile = new JButton(MessageManager.getString("label.to_file"));
 369     toFile.addActionListener(new ActionListener()
 370     {
 371       @Override
 372       public void actionPerformed(ActionEvent e)
 373       {
 374         toFile_actionPerformed();
 375       }
 376     });
 377     JButton toTextbox = new JButton(
 378             MessageManager.getString("label.to_textbox"));
 379     toTextbox.addActionListener(new ActionListener()
 380     {
 381       @Override
 382       public void actionPerformed(ActionEvent e)
 383       {
 384         toTextbox_actionPerformed();
 385       }
 386     });
 387     JButton close = new JButton(MessageManager.getString("action.close"));
 388     close.addActionListener(new ActionListener()
 389     {
 390       @Override
 391       public void actionPerformed(ActionEvent e)
 392       {
 393         close_actionPerformed();
 394       }
 395     });
 396
 397     actionsPanel.add(toFile);
 398     actionsPanel.add(toTextbox);
 399     actionsPanel.add(close);
 400
 401     return actionsPanel;
 402   }
 403
 404   /**
 405    * Builds the panel with options to output in Jalview, GFF or CSV format. GFF
 406    * is only made visible when exporting features, CSV only when exporting
 407    * annotation.
 408    *
 409    * @return
 410    */
 411   JPanel buildFormatOptionsPanel()
 412   {
 413     JPanel formatPanel = new JPanel();
 414     // formatPanel.setBorder(BorderFactory.createEtchedBorder());
 415     formatPanel.setOpaque(false);
 416
 417     JRadioButton jalviewFormat = new JRadioButton("Jalview");
 418     jalviewFormat.setOpaque(false);
 419     jalviewFormat.setSelected(true);
 420     GFFFormat.setOpaque(false);
 421     GFFFormat.setText("GFF");
 422     CSVFormat.setOpaque(false);
 423     CSVFormat.setText(MessageManager.getString("label.csv_spreadsheet"));
 424
 425     ButtonGroup buttonGroup = new ButtonGroup();
 426     buttonGroup.add(jalviewFormat);
 427     buttonGroup.add(GFFFormat);
 428     buttonGroup.add(CSVFormat);
 429
 430     JLabel format = new JLabel(
 431             MessageManager.getString("action.format") + " ");
 432     format.setHorizontalAlignment(SwingConstants.TRAILING);
 433
 434     formatPanel.add(format);
 435     formatPanel.add(jalviewFormat);
 436     formatPanel.add(GFFFormat);
 437     formatPanel.add(CSVFormat);
 438
 439     return formatPanel;
 440   }
 441 }