import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
import jalview.bin.Cache;
+import jalview.bin.Console;
+import jalview.bin.Jalview;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.gui.ImageExporter.ImageWriterI;
import jalview.io.HTMLOutput;
import jalview.jbgui.GAlignmentPanel;
import jalview.math.AlignmentDimension;
import jalview.schemes.ResidueProperties;
import jalview.structure.StructureSelectionManager;
import jalview.util.Comparison;
+import jalview.util.ImageMaker;
import jalview.util.MessageManager;
-import jalview.util.Platform;
import jalview.viewmodel.ViewportListenerI;
import jalview.viewmodel.ViewportRanges;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
-import java.awt.Insets;
+import java.awt.Graphics2D;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.ComponentAdapter;
* @author $author$
* @version $Revision: 1.161 $
*/
+@SuppressWarnings("serial")
public class AlignmentPanel extends GAlignmentPanel implements
AdjustmentListener, Printable, AlignmentViewPanel, ViewportListenerI
{
+ /*
+ * spare space in pixels between sequence id and alignment panel
+ */
+ private static final int ID_WIDTH_PADDING = 4;
+
public AlignViewport av;
OverviewPanel overviewPanel;
private IdPanel idPanel;
- private boolean headless;
-
IdwidthAdjuster idwidthAdjuster;
- /** DOCUMENT ME!! */
public AlignFrame alignFrame;
private ScalePanel scalePanel;
*/
public AlignmentPanel(AlignFrame af, final AlignViewport av)
{
+// setBackground(Color.white); // BH 2019
alignFrame = af;
this.av = av;
setSeqPanel(new SeqPanel(av, this));
new Dimension(10, av.getCharHeight() + fm.getDescent()));
idwidthAdjuster.invalidate();
scalePanelHolder.invalidate();
- getIdPanel().getIdCanvas().gg = null;
+ // BH 2018 getIdPanel().getIdCanvas().gg = null;
getSeqPanel().seqCanvas.img = null;
getAnnotationPanel().adjustPanelHeight();
Dimension d = calculateIdWidth();
-
- d.setSize(d.width + 4, d.height);
getIdPanel().getIdCanvas().setPreferredSize(d);
hscrollFillerPanel.setPreferredSize(d);
}
/**
- * Calculate the width of the alignment labels based on the displayed names
- * and any bounds on label width set in preferences.
+ * Calculates the width of the alignment labels based on the displayed names
+ * and any bounds on label width set in preferences. The calculated width is
+ * also set as a property of the viewport.
*
* @return Dimension giving the maximum width of the alignment label panel
* that should be used.
*/
public Dimension calculateIdWidth()
{
+ int oldWidth = av.getIdWidth();
+
// calculate sensible default width when no preference is available
Dimension r = null;
if (av.getIdWidth() < 0)
{
int afwidth = (alignFrame != null ? alignFrame.getWidth() : 300);
- int maxwidth = Math.max(20, Math.min(afwidth - 200, 2 * afwidth / 3));
+ int idWidth = Math.min(afwidth - 200, 2 * afwidth / 3);
+ int maxwidth = Math.max(IdwidthAdjuster.MIN_ID_WIDTH, idWidth);
r = calculateIdWidth(maxwidth);
av.setIdWidth(r.width);
}
r.width = av.getIdWidth();
r.height = 0;
}
+
+ /*
+ * fudge: if desired width has changed, update layout
+ * (see also paintComponent - updates layout on a repaint)
+ */
+ if (r.width != oldWidth)
+ {
+ idPanelHolder.setPreferredSize(r);
+ validate();
+ }
return r;
}
* @return Dimension giving the maximum width of the alignment label panel
* that should be used.
*/
- public Dimension calculateIdWidth(int maxwidth)
+ protected Dimension calculateIdWidth(int maxwidth)
{
Container c = new Container();
AlignmentI al = av.getAlignment();
int i = 0;
int idWidth = 0;
- String id;
while ((i < al.getHeight()) && (al.getSequenceAt(i) != null))
{
SequenceI s = al.getSequenceAt(i);
-
- id = s.getDisplayId(av.getShowJVSuffix());
-
- if (fm.stringWidth(id) > idWidth)
- {
- idWidth = fm.stringWidth(id);
- }
-
+ String id = s.getDisplayId(av.getShowJVSuffix());
+ int stringWidth = fm.stringWidth(id);
+ idWidth = Math.max(idWidth, stringWidth);
i++;
}
while (i < al.getAlignmentAnnotation().length)
{
String label = al.getAlignmentAnnotation()[i].label;
-
- if (fm.stringWidth(label) > idWidth)
- {
- idWidth = fm.stringWidth(label);
- }
-
+ int stringWidth = fm.stringWidth(label);
+ idWidth = Math.max(idWidth, stringWidth);
i++;
}
}
- return new Dimension(
- maxwidth < 0 ? idWidth : Math.min(maxwidth, idWidth), 12);
+ int w = maxwidth < 0 ? idWidth : Math.min(maxwidth, idWidth);
+ w += ID_WIDTH_PADDING;
+
+ return new Dimension(w, 12);
}
/**
- * Highlight the given results on the alignment.
+ * Highlight the given results on the alignment
*
*/
public void highlightSearchResults(SearchResultsI results)
{
- boolean scrolled = scrollToPosition(results, 0, true, false);
+ boolean scrolled = scrollToPosition(results, 0, false);
- boolean noFastPaint = scrolled && av.getWrapAlignment();
+ boolean fastPaint = !(scrolled && av.getWrapAlignment());
- getSeqPanel().seqCanvas.highlightSearchResults(results, noFastPaint);
+ getSeqPanel().seqCanvas.highlightSearchResults(results, fastPaint);
}
/**
* (if any)
*
* @param searchResults
- * @param redrawOverview
* @return
*/
- public boolean scrollToPosition(SearchResultsI searchResults,
- boolean redrawOverview)
+ public boolean scrollToPosition(SearchResultsI searchResults)
{
- return scrollToPosition(searchResults, 0, redrawOverview, false);
+ return scrollToPosition(searchResults, 0, false);
}
/**
* @param verticalOffset
* if greater than zero, allows scrolling to a position below the
* first displayed sequence
- * @param redrawOverview
- * - when set, the overview will be recalculated (takes longer)
* @param centre
* if true, try to centre the search results horizontally in the view
* @return
*/
protected boolean scrollToPosition(SearchResultsI results,
- int verticalOffset, boolean redrawOverview, boolean centre)
+ int verticalOffset, boolean centre)
{
int startv, endv, starts, ends;
ViewportRanges ranges = av.getRanges();
if (av.hasHiddenColumns())
{
HiddenColumns hidden = av.getAlignment().getHiddenColumns();
- start = hidden.findColumnPosition(start);
- end = hidden.findColumnPosition(end);
+ start = hidden.absoluteToVisibleColumn(start);
+ end = hidden.absoluteToVisibleColumn(end);
if (start == end)
{
if (!hidden.isVisible(r[0]))
scrollNeeded = ranges.scrollToWrappedVisible(start);
}
- paintAlignment(redrawOverview, false);
+ paintAlignment(false, false);
return scrollNeeded;
}
addNotify();
// TODO: many places call this method and also paintAlignment with various
// different settings. this means multiple redraws are triggered...
- paintAlignment(true, false);
+ paintAlignment(true, av.needToUpdateStructureViews());
}
/**
*/
protected void validateAnnotationDimensions(boolean adjustPanelHeight)
{
- int annotationHeight = getAnnotationPanel().adjustPanelHeight();
-
- if (adjustPanelHeight)
- {
- int rowHeight = av.getCharHeight();
- int alignmentHeight = rowHeight * av.getAlignment().getHeight();
+ // BH 2018.04.18 comment: addNotify() is not appropriate here. We
+ // are not changing ancestors, and keyboard action listeners do
+ // not need to be reset. addNotify() is a very expensive operation,
+ // requiring a full re-layout of all parents and children.
+ // Note in JComponent:
+ // This method is called by the toolkit internally and should
+ // not be called directly by programs.
+ // I note that addNotify() is called in several areas of Jalview.
- /*
- * Estimate available height in the AlignFrame for alignment +
- * annotations. Deduct an estimate for title bar, menu bar, scale panel,
- * hscroll, status bar (as these are not laid out we can't inspect their
- * actual heights). Insets gives frame borders.
- */
- int stuff = Platform.isAMac() ? 80 : 100;
- Insets insets = alignFrame.getInsets();
- int availableHeight = alignFrame.getHeight() - stuff - insets.top
- - insets.bottom;
+ int annotationHeight = getAnnotationPanel().adjustPanelHeight();
+ annotationHeight = getAnnotationPanel()
+ .adjustForAlignFrame(adjustPanelHeight, annotationHeight);
- /*
- * If not enough vertical space, maximize annotation height while keeping
- * at least two rows of alignment visible
- */
- if (annotationHeight + alignmentHeight > availableHeight)
- {
- annotationHeight = Math.min(annotationHeight,
- availableHeight - 2 * rowHeight);
- }
- }
- else
- {
- // maintain same window layout whilst updating sliders
- annotationHeight = annotationScroller.getSize().height;
- }
hscroll.addNotify();
-
annotationScroller.setPreferredSize(
new Dimension(annotationScroller.getWidth(), annotationHeight));
Dimension e = idPanel.getSize();
alabels.setSize(new Dimension(e.width, annotationHeight));
+
annotationSpaceFillerHolder.setPreferredSize(new Dimension(
annotationSpaceFillerHolder.getWidth(), annotationHeight));
annotationScroller.validate();
{
annotationScroller.setVisible(true);
annotationSpaceFillerHolder.setVisible(true);
+ validateAnnotationDimensions(false);
}
int canvasWidth = getSeqPanel().seqCanvas.getWidth();
}
else
{
- int width = av.getAlignment().getWidth();
+ int width = av.getAlignment().getVisibleWidth();
int height = av.getAlignment().getHeight();
- if (av.hasHiddenColumns())
- {
- // reset the width to exclude hidden columns
- width = av.getAlignment().getHiddenColumns()
- .findColumnPosition(width);
- }
-
hextent = getSeqPanel().seqCanvas.getWidth() / av.getCharWidth();
vextent = getSeqPanel().seqCanvas.getHeight() / av.getCharHeight();
// could not be validated and it is not clear if it is now being
// called. Log warning here in case it is called and unforeseen
// problems occur
- Cache.log.warn(
+ Console.warn(
"Unexpected path through code: Wrapped jar file opened with wrap alignment set in preferences");
// scroll to start of panel
}
}
- /**
- * DOCUMENT ME!
- *
- * @param g
- * DOCUMENT ME!
- */
@Override
public void paintComponent(Graphics g)
{
- invalidate();
+ invalidate(); // needed so that the id width adjuster works correctly
Dimension d = getIdPanel().getIdCanvas().getPreferredSize();
idPanelHolder.setPreferredSize(d);
hscrollFillerPanel.setPreferredSize(new Dimension(d.width, 12));
- validate();
+
+ validate(); // needed so that the id width adjuster works correctly
/*
- * set scroll bar positions
+ * set scroll bar positions - tried to remove but necessary for split panel to resize correctly
+ * though I still think this call should be elsewhere.
*/
ViewportRanges ranges = av.getRanges();
setScrollValues(ranges.getStartRes(), ranges.getStartSeq());
+ super.paintComponent(g);
}
/**
}
/**
- * DOCUMENT ME!
- *
- * @param pg
- * DOCUMENT ME!
- * @param pwidth
- * DOCUMENT ME!
- * @param pheight
- * DOCUMENT ME!
- * @param pi
- * DOCUMENT ME!
- *
- * @return DOCUMENT ME!
- *
- * @throws PrinterException
- * DOCUMENT ME!
- */
- /**
* Draws the alignment image, including sequence ids, sequences, and
* annotation labels and annotations if shown, on either one or two Graphics
- * context.
+ * contexts.
*
* @param pageWidth
+ * in pixels
* @param pageHeight
- * @param pi
+ * in pixels
+ * @param pageIndex
+ * (0, 1, ...)
* @param idGraphics
* the graphics context for sequence ids and annotation labels
* @param alignmentGraphics
* @return
* @throws PrinterException
*/
- public int printUnwrapped(int pageWidth, int pageHeight, int pi,
+ public int printUnwrapped(int pageWidth, int pageHeight, int pageIndex,
Graphics idGraphics, Graphics alignmentGraphics)
throws PrinterException
{
: idWidth;
FontMetrics fm = getFontMetrics(av.getFont());
- int charHeight = av.getCharHeight();
- int scaleHeight = charHeight + fm.getDescent();
+ final int charHeight = av.getCharHeight();
+ final int scaleHeight = charHeight + fm.getDescent();
idGraphics.setColor(Color.white);
idGraphics.fillRect(0, 0, pageWidth, pageHeight);
/*
* How many sequences and residues can we fit on a printable page?
*/
- int totalRes = (pageWidth - idWidth) / av.getCharWidth();
+ final int totalRes = (pageWidth - idWidth) / av.getCharWidth();
- int totalSeq = (pageHeight - scaleHeight) / charHeight - 1;
+ final int totalSeq = (pageHeight - scaleHeight) / charHeight - 1;
- int alignmentWidth = av.getAlignment().getWidth();
+ final int alignmentWidth = av.getAlignment().getVisibleWidth();
int pagesWide = (alignmentWidth / totalRes) + 1;
- final int startRes = (pi % pagesWide) * totalRes;
- int endRes = (startRes + totalRes) - 1;
-
- if (endRes > (alignmentWidth - 1))
- {
- endRes = alignmentWidth - 1;
- }
-
- final int startSeq = (pi / pagesWide) * totalSeq;
- int endSeq = startSeq + totalSeq;
+ final int startRes = (pageIndex % pagesWide) * totalRes;
+ final int endRes = Math.min(startRes + totalRes - 1,
+ alignmentWidth - 1);
- int alignmentHeight = av.getAlignment().getHeight();
- if (endSeq > alignmentHeight)
- {
- endSeq = alignmentHeight;
- }
+ final int startSeq = (pageIndex / pagesWide) * totalSeq;
+ final int alignmentHeight = av.getAlignment().getHeight();
+ final int endSeq = Math.min(startSeq + totalSeq, alignmentHeight);
int pagesHigh = ((alignmentHeight / totalSeq) + 1) * pageHeight;
pagesHigh /= pageHeight;
- if (pi >= (pagesWide * pagesHigh))
+ if (pageIndex >= (pagesWide * pagesHigh))
{
return Printable.NO_SUCH_PAGE;
}
* then reset to top left (0, 0)
*/
idGraphics.translate(0, scaleHeight);
- idGraphics.setFont(getIdPanel().getIdCanvas().getIdfont());
- Color currentColor = null;
- Color currentTextColor = null;
-
- SequenceI seq;
- for (int i = startSeq; i < endSeq; i++)
- {
- seq = av.getAlignment().getSequenceAt(i);
- if ((av.getSelectionGroup() != null)
- && av.getSelectionGroup().getSequences(null).contains(seq))
- {
- /*
- * gray out ids of sequences in selection group (if any)
- */
- currentColor = Color.gray;
- currentTextColor = Color.black;
- }
- else
- {
- currentColor = av.getSequenceColour(seq);
- currentTextColor = Color.black;
- }
-
- idGraphics.setColor(currentColor);
- idGraphics.fillRect(0, (i - startSeq) * charHeight, idWidth,
- charHeight);
-
- idGraphics.setColor(currentTextColor);
+ IdCanvas idCanvas = getIdPanel().getIdCanvas();
+ List<SequenceI> selection = av.getSelectionGroup() == null ? null
+ : av.getSelectionGroup().getSequences(null);
+ idCanvas.drawIds((Graphics2D) idGraphics, av, startSeq, endSeq - 1,
+ selection);
- int xPos = 0;
- String displayId = seq.getDisplayId(av.getShowJVSuffix());
- if (av.isRightAlignIds())
- {
- fm = idGraphics.getFontMetrics();
- xPos = idWidth - fm.stringWidth(displayId) - 4;
- }
-
- idGraphics.drawString(displayId, xPos,
- (((i - startSeq) * charHeight) + charHeight)
- - (charHeight / 5));
- }
idGraphics.setFont(av.getFont());
idGraphics.translate(0, -scaleHeight);
*/
alignmentGraphics.translate(alignmentGraphicsOffset, scaleHeight);
getSeqPanel().seqCanvas.drawPanelForPrinting(alignmentGraphics, startRes,
- endRes, startSeq, endSeq);
+ endRes, startSeq, endSeq - 1);
alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
if (av.isShowAnnotation() && (endSeq == alignmentHeight))
}
/**
- * DOCUMENT ME!
+ * 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).
*
- * @param pg
- * DOCUMENT ME!
- * @param pwidth
- * DOCUMENT ME!
- * @param pheight
- * DOCUMENT ME!
- * @param pi
- * DOCUMENT ME!
+ * @param pageWidth
+ * @param pageHeight
+ * @param pageNumber
+ * (0, 1, ...)
+ * @param g
*
- * @return DOCUMENT ME!
+ * @return
*
* @throws PrinterException
- * DOCUMENT ME!
*/
- public int printWrappedAlignment(int pwidth, int pheight, int pi,
- Graphics pg) throws PrinterException
+ public int printWrappedAlignment(int pageWidth, int pageHeight, int pageNumber,
+ Graphics g) throws PrinterException
{
+ getSeqPanel().seqCanvas.calculateWrappedGeometry(getWidth(),
+ getHeight());
int annotationHeight = 0;
- AnnotationLabels labels = null;
if (av.isShowAnnotation())
{
annotationHeight = getAnnotationPanel().adjustPanelHeight();
- labels = new AnnotationLabels(av);
}
int hgap = av.getCharHeight();
int idWidth = getVisibleIdWidth(false);
- int maxwidth = av.getAlignment().getWidth();
- if (av.hasHiddenColumns())
- {
- maxwidth = av.getAlignment().getHiddenColumns()
- .findColumnPosition(maxwidth) - 1;
- }
+ int maxwidth = av.getAlignment().getVisibleWidth();
int resWidth = getSeqPanel().seqCanvas
- .getWrappedCanvasWidth(pwidth - idWidth);
+ .getWrappedCanvasWidth(pageWidth - idWidth);
+ av.getRanges().setViewportStartAndWidth(0, resWidth);
int totalHeight = cHeight * (maxwidth / resWidth + 1);
- pg.setColor(Color.white);
- pg.fillRect(0, 0, pwidth, pheight);
- pg.setFont(av.getFont());
-
- // //////////////
- // Draw the ids
- pg.setColor(Color.black);
-
- pg.translate(0, -pi * pheight);
-
- pg.setClip(0, pi * pheight, pwidth, pheight);
+ g.setColor(Color.white);
+ g.fillRect(0, 0, pageWidth, pageHeight);
+ g.setFont(av.getFont());
+ g.setColor(Color.black);
- int ypos = hgap;
-
- do
- {
- for (int i = 0; i < av.getAlignment().getHeight(); i++)
- {
- pg.setFont(getIdPanel().getIdCanvas().getIdfont());
- SequenceI s = av.getAlignment().getSequenceAt(i);
- String string = s.getDisplayId(av.getShowJVSuffix());
- int xPos = 0;
- if (av.isRightAlignIds())
- {
- FontMetrics fm = pg.getFontMetrics();
- xPos = idWidth - fm.stringWidth(string) - 4;
- }
- pg.drawString(string, xPos,
- ((i * av.getCharHeight()) + ypos + av.getCharHeight())
- - (av.getCharHeight() / 5));
- }
- if (labels != null)
- {
- pg.translate(-3, ypos
- + (av.getAlignment().getHeight() * av.getCharHeight()));
+ /*
+ * method: print the whole wrapped alignment, but with a clip region that
+ * is restricted to the requested page; this supports selective print of
+ * single pages or ranges, (at the cost of repeated processing in the
+ * 'normal' case, when all pages are printed)
+ */
+ g.translate(0, -pageNumber * pageHeight);
- pg.setFont(av.getFont());
- labels.drawComponent(pg, idWidth);
- pg.translate(+3, -ypos
- - (av.getAlignment().getHeight() * av.getCharHeight()));
- }
+ g.setClip(0, pageNumber * pageHeight, pageWidth, pageHeight);
- ypos += cHeight;
- } while (ypos < totalHeight);
+ /*
+ * draw sequence ids and annotation labels (if shown)
+ */
+ IdCanvas idCanvas = getIdPanel().getIdCanvas();
+ idCanvas.drawIdsWrapped((Graphics2D) g, av, 0, totalHeight);
- pg.translate(idWidth, 0);
+ g.translate(idWidth, 0);
- getSeqPanel().seqCanvas.drawWrappedPanelForPrinting(pg, pwidth - idWidth,
+ getSeqPanel().seqCanvas.drawWrappedPanelForPrinting(g, pageWidth - idWidth,
totalHeight, 0);
- if ((pi * pheight) < totalHeight)
+ if ((pageNumber * pageHeight) < totalHeight)
{
return Printable.PAGE_EXISTS;
-
}
else
{
* be returned
* @return
*/
- public int getVisibleIdWidth(boolean onscreen)
+ protected int getVisibleIdWidth(boolean onscreen)
{
// see if rendering offscreen - check preferences and calc width accordingly
if (!onscreen && Cache.getDefault("FIGURE_AUTOIDWIDTH", false))
{
- return calculateIdWidth(-1).width + 4;
+ return calculateIdWidth(-1).width;
}
- Integer idwidth = null;
- if (onscreen || (idwidth = Cache
- .getIntegerProperty("FIGURE_FIXEDIDWIDTH")) == null)
+ Integer idwidth = onscreen ? null
+ : Cache.getIntegerProperty("FIGURE_FIXEDIDWIDTH");
+ if (idwidth != null)
{
- int w = getIdPanel().getWidth();
- return (w > 0 ? w : calculateIdWidth().width + 4);
+ return idwidth.intValue() + ID_WIDTH_PADDING;
}
- return idwidth.intValue() + 4;
+
+ int w = getIdPanel().getWidth();
+ return (w > 0 ? w : calculateIdWidth().width);
}
- void makeAlignmentImage(jalview.util.ImageMaker.TYPE type, File file)
+ /**
+ * Builds an image of the alignment of the specified type (EPS/PNG/SVG) and
+ * writes it to the specified file
+ *
+ * @param type
+ * @param file
+ */
+ void makeAlignmentImage(ImageMaker.TYPE type, File file)
{
- int boarderBottomOffset = 5;
- long pSessionId = System.currentTimeMillis();
- headless = (System.getProperty("java.awt.headless") != null
- && System.getProperty("java.awt.headless").equals("true"));
- if (alignFrame != null && !headless)
- {
- if (file != null)
- {
- alignFrame.setProgressBar(MessageManager
- .formatMessage("status.saving_file", new Object[]
- { type.getLabel() }), pSessionId);
- }
- }
- try
+ final int borderBottomOffset = 5;
+
+ AlignmentDimension aDimension = getAlignmentDimension();
+ // todo use a lambda function in place of callback here?
+ ImageWriterI writer = new ImageWriterI()
{
- AlignmentDimension aDimension = getAlignmentDimension();
- try
+ @Override
+ public void exportImage(Graphics graphics) throws Exception
{
- 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();
- }
-
- 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 (graphics != null)
- {
- printWrappedAlignment(aDimension.getWidth(),
- aDimension.getHeight() + boarderBottomOffset, 0,
- graphics);
- im.writeImage();
- }
+ printWrappedAlignment(aDimension.getWidth(),
+ aDimension.getHeight() + borderBottomOffset, 0, graphics);
}
else
{
- if (graphics != null)
- {
- printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 0,
- graphics, graphics);
- im.writeImage();
- }
+ printUnwrapped(aDimension.getWidth(), aDimension.getHeight(), 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
- {
+ };
- }
+ String fileTitle = alignFrame.getTitle();
+ ImageExporter exporter = new ImageExporter(writer, alignFrame, type,
+ fileTitle);
+ int imageWidth = aDimension.getWidth();
+ int imageHeight = aDimension.getHeight() + borderBottomOffset;
+ String of = MessageManager.getString("label.alignment");
+ exporter.doExport(file, this, imageWidth, imageHeight, of);
}
+ /**
+ * Calculates and returns a suitable width and height (in pixels) for an
+ * exported image
+ *
+ * @return
+ */
public AlignmentDimension getAlignmentDimension()
{
- int maxwidth = av.getAlignment().getWidth();
- if (av.hasHiddenColumns())
- {
- maxwidth = av.getAlignment().getHiddenColumns()
- .findColumnPosition(maxwidth);
- }
+ int maxwidth = av.getAlignment().getVisibleWidth();
int height = ((av.getAlignment().getHeight() + 1) * av.getCharHeight())
+ getScalePanel().getHeight();
if (av.getWrapAlignment())
{
height = getWrappedHeight();
- if (headless)
+ if (Jalview.isHeadlessMode())
{
// need to obtain default alignment width and then add in any
// additional allowance for id margin
}
- /**
- * DOCUMENT ME!
- */
- public void makeEPS(File epsFile)
- {
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.EPS, epsFile);
- }
-
- /**
- * DOCUMENT ME!
- */
- public void makePNG(File pngFile)
- {
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.PNG, pngFile);
- }
-
- public void makeSVG(File svgFile)
- {
- makeAlignmentImage(jalview.util.ImageMaker.TYPE.SVG, svgFile);
- }
-
public void makePNGImageMap(File imgMapFile, String imageName)
{
// /////ONLY WORKS WITH NON WRAPPED ALIGNMENTS
}
+ /**
+ * Answers the height of the entire alignment in pixels, assuming it is in
+ * wrapped mode
+ *
+ * @return
+ */
int getWrappedHeight()
{
int seqPanelWidth = getSeqPanel().seqCanvas.getWidth();
int annotationHeight = 0;
if (av.isShowAnnotation())
{
+ hgap += SeqCanvas.SEQS_ANNOTATION_GAP;
annotationHeight = getAnnotationPanel().adjustPanelHeight();
}
if (av.hasHiddenColumns())
{
maxwidth = av.getAlignment().getHiddenColumns()
- .findColumnPosition(maxwidth) - 1;
+ .absoluteToVisibleColumn(maxwidth) - 1;
}
int height = ((maxwidth / chunkWidth) + 1) * cHeight;
}
else
{
- if (Cache.log.isDebugEnabled())
+ if (Console.isDebugEnabled())
{
- Cache.log.warn("Closing alignment panel which is already closed.");
+ Console.warn("Closing alignment panel which is already closed.");
}
}
}
@Override
public String getViewName()
{
- return av.viewName;
+ return av.getViewName();
}
/**
} catch (Exception ex)
{
}
-
if (b)
{
- alignFrame.setDisplayedView(this);
+ setAlignFrameView();
}
}
-
+ public void setAlignFrameView()
+ {
+ alignFrame.setDisplayedView(this);
+ }
+
@Override
public StructureSelectionManager getStructureSelectionManager()
{
*/
protected void scrollToCentre(SearchResultsI sr, int verticalOffset)
{
- /*
- * To avoid jumpy vertical scrolling (if some sequences are gapped or not
- * mapped), we can make the scroll-to location a sequence above the one
- * actually mapped.
- */
- SequenceI mappedTo = sr.getResults().get(0).getSequence();
- List<SequenceI> seqs = av.getAlignment().getSequences();
-
- /*
- * This is like AlignmentI.findIndex(seq) but here we are matching the
- * dataset sequence not the aligned sequence
- */
- boolean matched = false;
- for (SequenceI seq : seqs)
- {
- if (mappedTo == seq.getDatasetSequence())
- {
- matched = true;
- break;
- }
- }
- if (!matched)
- {
- return; // failsafe, shouldn't happen
- }
-
- /*
- * Scroll to position but centring the target residue.
- */
- scrollToPosition(sr, verticalOffset, true, true);
+ scrollToPosition(sr, verticalOffset, true);
}
/**
{
return calculationDialog;
}
+
}
git://source.jalview.org / jalview.git / blobdiff