label.save_png_image = Save As PNG Image
label.load_tree_for_sequence_set = Load a tree for this sequence set
label.export_image = Export Image
+label.export_split_frame = Export Split Frame Image
+label.export_tooltip = Alignments image with {0} above
label.vamsas_store = VAMSAS store
label.translate_cDNA = Translate as cDNA
label.reverse = Reverse
label.mapping_method = Sequence \u27f7 Structure mapping method
status.waiting_for_user_to_select_output_file = Waiting for user to select {0} file
status.cancelled_image_export_operation = Cancelled {0} export operation
+label.make_alignment_image = Create {0} image from alignment
+label.make_pca_image = Make {0} image from PCA
+label.make_pdb_image = Make {0} image from view
info.error_creating_file = Error creating {0} file
exception.outofmemory_loading_mmcif_file = Out of memory loading mmCIF File
label.run_groovy = Run Groovy console script
label.save_png_image = Guardar como imagen PNG
label.load_tree_for_sequence_set = Cargar un árbol para este conjunto de secuencias
label.export_image = Exportar imagen
+label.export_split_frame = Exportar imagen de la ventana dividida
+label.export_tooltipe = Imagen de alineamientos con {0} arriba
label.vamsas_store = Almacén VAMSAS
label.translate_cDNA = Traducir cDNA
label.extract_scores = Extraer puntuaciones
if (outputFormat.equalsIgnoreCase("png"))
{
- af.createPNG(new File(file));
+ af.createPNG(new File(file), false);
imageName = (new File(file)).getName();
System.out.println("Creating PNG image: " + file);
continue;
File outputFile = new File(file);
System.out.println(
"Creating EPS file: " + outputFile.getAbsolutePath());
- af.createEPS(outputFile);
+ af.createEPS(outputFile, false);
continue;
}
}
/**
- * DOCUMENT ME!
+ * Creates and writes a PNG image of the alignment, to the given file if
+ * specified, else after prompting for the output file
*
- * @param e
- * DOCUMENT ME!
+ * @param f
+ * @param forSplitFrame
*/
@Override
- public void createPNG(File f)
+ public void createPNG(File f, boolean forSplitFrame)
{
- alignPanel.makePNG(f);
+ alignPanel.makePNG(f, forSplitFrame);
}
/**
- * DOCUMENT ME!
+ * Creates and writes an EPS image of the alignment, to the given file if
+ * specified, else after prompting for the output file
*
- * @param e
- * DOCUMENT ME!
+ * @param f
+ * @param forSplitFrame
*/
@Override
- public void createEPS(File f)
+ public void createEPS(File f, boolean forSplitFrame)
{
- alignPanel.makeEPS(f);
+ alignPanel.makeEPS(f, forSplitFrame);
}
@Override
public void createSVG(File f)
{
- alignPanel.makeSVG(f);
+ alignPanel.makeSVG(f, false);
}
@Override
*/
package jalview.gui;
+import static jalview.util.ImageMaker.TYPE.EPS;
+import static jalview.util.ImageMaker.TYPE.PNG;
+import static jalview.util.ImageMaker.TYPE.SVG;
+
import jalview.analysis.AnnotationSorter;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
import jalview.schemes.ResidueProperties;
import jalview.structure.StructureSelectionManager;
import jalview.util.Comparison;
+import jalview.util.ImageMaker;
import jalview.util.MessageManager;
import jalview.viewmodel.ViewportListenerI;
import jalview.viewmodel.ViewportRanges;
}
/**
- * DOCUMENT ME!
+ * Provides the implementation of Printable.print
*
* @param pg
- * DOCUMENT ME!
+ * DOCUMENT ME!
* @param pf
- * DOCUMENT ME!
+ * DOCUMENT ME!
* @param pi
- * DOCUMENT ME!
+ * DOCUMENT ME!
*
* @return DOCUMENT ME!
*
* @throws PrinterException
- * DOCUMENT ME!
*/
@Override
public int print(Graphics pg, PageFormat pf, int pi)
if (av.getWrapAlignment())
{
- return printWrappedAlignment(pwidth, pheight, pi, pg);
+ return printWrappedAlignment(pwidth, pheight, pi, pg, true);
}
else
{
alignmentDrawnHeight);
getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(), av,
alignmentGraphics, -1, startRes, endRes + 1);
+
+ /*
+ * reset to left margin
+ */
+ alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
}
return Printable.PAGE_EXISTS;
* Prints one page of an alignment in wrapped mode. Returns
* Printable.PAGE_EXISTS (0) if a page was drawn, or Printable.NO_SUCH_PAGE if
* no page could be drawn (page number out of range).
+ * <p>
+ * The method is to write the whole alignment, but set a clip region such that
+ * only the specified page is written. This allows specified page(s) to be
+ * printed from the print dialog. The whole image may be written simply by
+ * making the page size match the image size. In this case, parameter
+ * {@code clipToPage} should be set to {@code false}, so that more output (for
+ * example the second panel of a split frame) can be written if wanted.
*
* @param pageWidth
* @param pageHeight
* @param pageNumber
- * (0, 1, ...)
+ * (0, 1, ...)
* @param g
+ * @param clipToPage
*
* @return
- *
- * @throws PrinterException
*/
public int printWrappedAlignment(int pageWidth, int pageHeight, int pageNumber,
- Graphics g) throws PrinterException
+ Graphics g, boolean clipToPage)
{
getSeqPanel().seqCanvas.calculateWrappedGeometry(getWidth(),
getHeight());
*/
g.translate(0, -pageNumber * pageHeight);
- g.setClip(0, pageNumber * pageHeight, pageWidth, pageHeight);
+ if (clipToPage)
+ {
+ g.setClip(0, pageNumber * pageHeight, pageWidth, pageHeight);
+ }
/*
* draw sequence ids and annotation labels (if shown)
idCanvas.drawIdsWrapped((Graphics2D) g, av, 0, totalHeight);
g.translate(idWidth, 0);
-
getSeqPanel().seqCanvas.drawWrappedPanelForPrinting(g, pageWidth - idWidth,
totalHeight, 0);
+ g.translate(-idWidth, 0);
if ((pageNumber * pageHeight) < totalHeight)
{
return idwidth.intValue() + 4;
}
- void makeAlignmentImage(jalview.util.ImageMaker.TYPE type, File file)
+ /**
+ * Generates an image of the alignment panel of the specified type. If
+ * {@code type} is not null, the image is written to the file, otherwise the
+ * user is prompted to specify the output file before writing to it.
+ *
+ * @param type
+ * @param file
+ * @param forSplitFrame
+ */
+ void makeAlignmentImage(ImageMaker.TYPE type, File file,
+ boolean forSplitFrame)
{
- int boarderBottomOffset = 5;
+ int borderBottomOffset = 5;
long pSessionId = System.currentTimeMillis();
headless = (System.getProperty("java.awt.headless") != null
&& System.getProperty("java.awt.headless").equals("true"));
}
try
{
- AlignmentDimension aDimension = getAlignmentDimension();
- try
+ /*
+ * if exporting a split frame image, the graphics object has
+ * width: maximum of the top and bottom image widths
+ * height: sum of the top and bottom image heights
+ */
+ AlignmentPanel comp = null;
+ AlignmentDimension dim1 = getAlignmentDimension();
+ AlignmentDimension dim2 = new AlignmentDimension(0, 0);
+ if (forSplitFrame)
{
- jalview.util.ImageMaker im;
- final String imageAction, imageTitle;
- if (type == jalview.util.ImageMaker.TYPE.PNG)
- {
- imageAction = "Create PNG image from alignment";
- imageTitle = null;
- }
- else if (type == jalview.util.ImageMaker.TYPE.EPS)
- {
- imageAction = "Create EPS file from alignment";
- imageTitle = alignFrame.getTitle();
- }
- else
- {
- imageAction = "Create SVG file from alignment";
- imageTitle = alignFrame.getTitle();
- }
+ comp = ((AlignViewport) av.getCodingComplement())
+ .getAlignPanel();
+ dim2 = comp.getAlignmentDimension();
+ }
+ final int graphicsHeight = dim1.height + dim2.height
+ + borderBottomOffset;
+ final int graphicsWidth = Math.max(dim1.width, dim2.width);
+
+ final String dialogTitle = MessageManager
+ .formatMessage("label.make_alignment_image", type.getName());
+ String imageTitle = type == PNG ? null : alignFrame.getTitle();
+
+ ImageMaker im = new ImageMaker(this, type, dialogTitle,
+ graphicsWidth, graphicsHeight, file,
+ imageTitle, alignFrame, pSessionId, headless);
+ Graphics graphics = im.getGraphics();
+ if (graphics == null)
+ {
+ return;
+ }
+ graphics.setColor(Color.white);
+ graphics.fillRect(0, 0, graphicsWidth, graphicsHeight);
+ if (av.getWrapAlignment())
+ {
+ printWrappedAlignment(dim1.width, dim1.height + borderBottomOffset,
+ 0, graphics, false);
+ }
+ else
+ {
+ printUnwrapped(dim1.width, dim1.height, 0, graphics, graphics);
+ }
- im = new jalview.util.ImageMaker(this, type, imageAction,
- aDimension.getWidth(),
- aDimension.getHeight() + boarderBottomOffset, file,
- imageTitle, alignFrame, pSessionId, headless);
- Graphics graphics = im.getGraphics();
- if (av.getWrapAlignment())
+ if (forSplitFrame)
+ {
+ /*
+ * append coding complement image
+ */
+ /*
+ * to debug location of next write to Graphics
+ */
+ // graphics.setColor(Color.red);
+ // graphics.drawString("Hello world", 0, 0);
+ if (av.getCodingComplement().getWrapAlignment())
{
- if (graphics != null)
- {
- printWrappedAlignment(aDimension.getWidth(),
- aDimension.getHeight() + boarderBottomOffset, 0,
- graphics);
- im.writeImage();
- }
+ comp.printWrappedAlignment(dim2.width,
+ dim2.height + borderBottomOffset, 0, graphics, false);
}
else
{
- if (graphics != null)
- {
- printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
- graphics, graphics);
- im.writeImage();
- }
+ comp.printUnwrapped(dim2.width, dim2.height, 0, graphics,
+ graphics);
}
-
- } catch (OutOfMemoryError err)
- {
- // Be noisy here.
- System.out.println("########################\n" + "OUT OF MEMORY "
- + file + "\n" + "########################");
- new OOMWarning("Creating Image for " + file, err);
- // System.out.println("Create IMAGE: " + err);
- } catch (Exception ex)
- {
- ex.printStackTrace();
}
- } finally
- {
+ im.writeImage();
+ } catch (OutOfMemoryError err)
+ {
+ // Be noisy here.
+ System.out.println("########################\n" + "OUT OF MEMORY "
+ + file + "\n" + "########################");
+ new OOMWarning("Creating Image for " + file, err);
+ // System.out.println("Create IMAGE: " + err);
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
}
}
+ /**
+ * Computes and answers the width and height of the alignment in pixels,
+ * including
+ * <ul>
+ * <li>sequence ids</li>
+ * <li>scale above, left or right if shown</li>
+ * <li>sequences</li>
+ * <li>annotations, if shown</li>
+ * </ul>
+ * The alignment may be in wrapped or unwrapped mode.
+ * <ul>
+ *
+ * @return
+ */
public AlignmentDimension getAlignmentDimension()
{
int maxwidth = av.getAlignment().getVisibleWidth();
{
height += getAnnotationPanel().adjustPanelHeight() + 3;
}
- return new AlignmentDimension(width, height);
+ return new AlignmentDimension(width, height);
}
/**
- * DOCUMENT ME!
+ * Creates and writes an EPS image of the alignment, to the given file if
+ * specified, else after prompting for the output file
+ *
+ * @param epsFile
+ * @param forSplitFrame
*/
- public void makeEPS(File epsFile)
+ public void makeEPS(File epsFile, boolean forSplitFrame)
{
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.EPS, epsFile);
+ makeAlignmentImage(EPS, epsFile, forSplitFrame);
}
/**
- * DOCUMENT ME!
+ * Creates and writes a PNG image of the alignment, to the given file if
+ * specified, else after prompting for the output file
+ *
+ * @param pngFile
+ * @param forSplitFrame
*/
- public void makePNG(File pngFile)
+ public void makePNG(File pngFile, boolean forSplitFrame)
{
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.PNG, pngFile);
+ makeAlignmentImage(PNG, pngFile, forSplitFrame);
}
- public void makeSVG(File svgFile)
+ /**
+ * Creates and writes an SVG image of the alignment, to the given file if
+ * specified, else after prompting for the output file
+ *
+ * @param svgFile
+ * @param forSplitFrame
+ */
+ public void makeSVG(File svgFile, boolean forSplitFrame)
{
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.SVG, svgFile);
+ makeAlignmentImage(SVG, svgFile, forSplitFrame);
}
public void makePNGImageMap(File imgMapFile, String imageName)
*/
package jalview.gui;
+import static jalview.util.ImageMaker.TYPE.PNG;
+
import jalview.bin.Cache;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.PDBEntry;
import jalview.gui.StructureViewer.ViewerType;
import jalview.structures.models.AAStructureBindingModel;
import jalview.util.BrowserLauncher;
+import jalview.util.ImageMaker;
import jalview.util.MessageManager;
import jalview.util.Platform;
import jalview.ws.dbsources.Pdb;
int width = getWidth();
int height = getHeight();
- jalview.util.ImageMaker im;
-
- if (type == jalview.util.ImageMaker.TYPE.PNG)
- {
- im = new jalview.util.ImageMaker(this,
- jalview.util.ImageMaker.TYPE.PNG, "Make PNG image from view",
- width, height, null, null, null, 0, false);
- }
- else if (type == jalview.util.ImageMaker.TYPE.EPS)
- {
- im = new jalview.util.ImageMaker(this,
- jalview.util.ImageMaker.TYPE.EPS, "Make EPS file from view",
- width, height, null, this.getTitle(), null, 0, false);
- }
- else
- {
-
- im = new jalview.util.ImageMaker(this,
- jalview.util.ImageMaker.TYPE.SVG, "Make SVG file from PCA",
- width, height, null, this.getTitle(), null, 0, false);
- }
+ String dialogTitle = MessageManager
+ .formatMessage("label.make_pdb_image", type.getName());
+ String imageTitle = type == PNG ? null : this.getTitle();
+ ImageMaker im = new ImageMaker(this, type, dialogTitle, width, height,
+ null, imageTitle, null, 0, false);
if (im.getGraphics() != null)
{
*/
package jalview.gui;
+import static jalview.util.ImageMaker.TYPE.PNG;
+
import jalview.analysis.scoremodels.ScoreModels;
import jalview.api.AlignViewportI;
import jalview.api.analysis.ScoreModelI;
int width = getRotatableCanvas().getWidth();
int height = getRotatableCanvas().getHeight();
- ImageMaker im;
-
- switch (type)
- {
- case PNG:
- im = new ImageMaker(this, ImageMaker.TYPE.PNG,
- "Make PNG image from PCA", width, height, null, null, null, 0,
- false);
- break;
- case EPS:
- im = new ImageMaker(this, ImageMaker.TYPE.EPS,
- "Make EPS file from PCA", width, height, null,
- this.getTitle(), null, 0, false);
- break;
- default:
- im = new ImageMaker(this, ImageMaker.TYPE.SVG,
- "Make SVG file from PCA", width, height, null,
- this.getTitle(), null, 0, false);
- }
+ String dialogTitle = MessageManager
+ .formatMessage("label.make_pca_image", type.getName());
+ String imageTitle = type == PNG ? null : this.getTitle();
+ ImageMaker im = new ImageMaker(this, type, dialogTitle, width, height,
+ null, imageTitle, null, 0, false);
if (im.getGraphics() != null)
{
public void drawWrappedPanelForPrinting(Graphics g, int canvasWidth,
int canvasHeight, int startRes)
{
- drawWrappedPanel(g, canvasWidth, canvasHeight, startRes);
+ int heightDrawn = drawWrappedPanel(g, canvasWidth, canvasHeight,
+ startRes);
SequenceGroup group = av.getSelectionGroup();
if (group != null)
drawWrappedSelection((Graphics2D) g, group, canvasWidth, canvasHeight,
startRes);
}
+
+ /*
+ * shift graphics (0, 0) to below the region drawn
+ */
+ g.translate(0, heightDrawn);
}
/**
}
/**
- * Draws as many widths of a wrapped alignment as can fit in the visible
- * window
+ * Draws as many widths of a wrapped alignment as can fit in the visible window,
+ * and returns the height drawn in pixels
*
* @param g
* @param canvasWidth
- * available width in pixels
+ * available width in pixels
* @param canvasHeight
- * available height in pixels
+ * available height in pixels
* @param startColumn
- * the first column (0...) of the alignment to draw
+ * the first column (0...) of the alignment to draw
+ *
+ * @return
*/
- public void drawWrappedPanel(Graphics g, int canvasWidth,
+ public int drawWrappedPanel(Graphics g, int canvasWidth,
int canvasHeight, final int startColumn)
{
int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
}
drawWrappedDecorators(g, startColumn);
+
+ return ypos;
}
/**
if (clip == null)
{
- g.setClip(0, 0, viewportWidth * charWidth, canvasHeight);
+ // g.setClip(0, 0, viewportWidth * charWidth, canvasHeight);
}
else
{
startColumn, endx + 1);
g.translate(0, -yShift);
}
- g.setClip(clip);
+
+ if (clip != null)
+ {
+ g.setClip(clip);
+ }
+
g.translate(-xOffset, 0);
}
*/
protected void init()
{
- getTopFrame().setSplitFrame(this);
- getBottomFrame().setSplitFrame(this);
+ getTopFrame().setSplitFrame(this, true);
+ getBottomFrame().setSplitFrame(this, false);
getTopFrame().setVisible(true);
getBottomFrame().setVisible(true);
}
public int printWrapped(int pwidth, int pheight, int pi, Graphics... pg)
- throws PrinterException
{
- return ap.printWrappedAlignment(pwidth, pheight, pi, pg[0]);
+ return ap.printWrappedAlignment(pwidth, pheight, pi, pg[0], false);
}
private String getHtml(String titleSvg, String alignmentSvg,
"status.exporting_alignment_as_x_file", "HTML"));
AlignmentDimension aDimension = ap.getAlignmentDimension();
SVGGraphics2D idPanelGraphics = new SVGGraphics2D(
- aDimension.getWidth(), aDimension.getHeight());
+ aDimension.width, aDimension.height);
SVGGraphics2D alignPanelGraphics = new SVGGraphics2D(
- aDimension.getWidth(), aDimension.getHeight());
+ aDimension.width, aDimension.height);
String renderStyle = jalview.bin.Cache.getDefault("HTML_RENDERING",
"Prompt each time");
}
if (ap.av.getWrapAlignment())
{
- printWrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
+ printWrapped(aDimension.width, aDimension.height, 0,
alignPanelGraphics);
}
else
{
- printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
+ printUnwrapped(aDimension.width, aDimension.height, 0,
idPanelGraphics, alignPanelGraphics);
}
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
+import java.io.File;
import java.util.HashMap;
import java.util.Map;
private SplitContainerI splitFrame;
+ protected JMenu exportSplitFrameMenu;
+
public GAlignFrame()
{
try
@Override
public void actionPerformed(ActionEvent e)
{
- createPNG(null);
+ createPNG(null, false);
}
});
createPNG.setActionCommand(
MessageManager.getString("label.save_png_image"));
+ JMenuItem createSplitFramePNG = new JMenuItem("PNG");
+ createSplitFramePNG.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ createPNG(null, true);
+ }
+ });
+
JMenuItem font = new JMenuItem(MessageManager.getString("action.font"));
font.addActionListener(new ActionListener()
{
seqLimit_actionPerformed(e);
}
});
- JMenuItem epsFile = new JMenuItem("EPS");
- epsFile.addActionListener(new ActionListener()
+ JMenuItem createEPS = new JMenuItem("EPS");
+ createEPS.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ createEPS(null, false);
+ }
+ });
+ JMenuItem createSplitFrameEPS = new JMenuItem("EPS");
+ createEPS.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
- createEPS(null);
+ createEPS(null, true);
}
});
JMenu exportImageMenu = new JMenu(
MessageManager.getString("label.export_image"));
+ exportSplitFrameMenu = new JMenu(
+ MessageManager.getString("label.export_split_frame"));
+ exportSplitFrameMenu.setVisible(false);
JMenu fileMenu = new JMenu(MessageManager.getString("action.file"));
alignFrameMenuBar.add(fileMenu);
alignFrameMenuBar.add(editMenu);
fileMenu.add(printMenuItem);
fileMenu.addSeparator();
fileMenu.add(exportImageMenu);
+ fileMenu.add(exportSplitFrameMenu);
fileMenu.add(exportFeatures);
fileMenu.add(exportAnnotations);
fileMenu.add(loadTreeMenuItem);
MessageManager.getString("label.no_services"));
webService.add(webServiceNoServices);
exportImageMenu.add(htmlMenuItem);
- exportImageMenu.add(epsFile);
+ exportImageMenu.add(createEPS);
exportImageMenu.add(createPNG);
exportImageMenu.add(createBioJS);
exportImageMenu.add(createSVG);
+ exportSplitFrameMenu.add(createSplitFrameEPS);
+ exportSplitFrameMenu.add(createSplitFramePNG);
addSequenceMenu.add(addFromFile);
addSequenceMenu.add(addFromText);
addSequenceMenu.add(addFromURL);
{
}
- public void createPNG(java.io.File f)
+ public void createPNG(File f, boolean forSplitFrame)
{
}
}
- public void createEPS(java.io.File f)
+ public void createEPS(File f, boolean forSplitFrame)
{
}
- public void createSVG(java.io.File f)
+ public void createSVG(File f)
{
}
}
/**
- * Sets a reference to the containing split frame. Also makes the 'toggle
- * split view' menu item visible and checked.
+ * Sets a reference to the containing split frame. Also makes the 'toggle split
+ * view' menu item visible and checked, and makes the 'export split frame image'
+ * menu visible.
*
* @param sf
*/
- public void setSplitFrame(SplitContainerI sf)
+ public void setSplitFrame(SplitContainerI sf, boolean asTopFrame)
{
this.splitFrame = sf;
if (sf != null)
{
this.showComplementMenuItem.setVisible(true);
this.showComplementMenuItem.setState(true);
+ this.exportSplitFrameMenu.setVisible(true);
+ String biotype = asTopFrame
+ ? MessageManager.getString("label.nucleotide")
+ : MessageManager.getString("label.protein");
+ this.exportSplitFrameMenu.setToolTipText(MessageManager
+ .formatMessage("label.export_tooltip", biotype));
}
}
public class AlignmentDimension
{
- private int width;
+ public final int width;
- private int height;
+ public final int height;
public AlignmentDimension(int width, int height)
{
this.width = width;
this.height = height;
}
-
- public int getWidth()
- {
- return width;
- }
-
- public void setWidth(int width)
- {
- this.width = width;
- }
-
- public int getHeight()
- {
- return height;
- }
-
- public void setHeight(int height)
- {
- this.height = height;
- }
-
}
System.err.println("Annotation Rendering time:"
+ (System.currentTimeMillis() - stime));
}
- ;
+ if (!av.getWrapAlignment())
+ {
+ g.translate(0, y);
+ }
return !usedFaded;
}
private boolean headless;
+ /**
+ * Image format, currently either EPS, PNG or SVG
+ */
public enum TYPE
{
EPS("EPS", MessageManager.getString("label.eps_file"), EPS_EXTENSION,
}
+ /**
+ * Constructor that prepares the image context for writing to. If {@code file}
+ * is null, the user is prompted to choose a file.
+ *
+ * @param parent
+ * @param type
+ * @param title
+ * @param width
+ * @param height
+ * @param file
+ * @param fileTitle
+ * @param pIndicator
+ * @param pSessionId
+ * @param headless
+ */
public ImageMaker(Component parent, TYPE type, String title, int width,
int height, File file, String fileTitle,
IProgressIndicator pIndicator, long pSessionId, boolean headless)
git://source.jalview.org / jalview.git / commitdiff