-/*
- * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
- * Copyright (C) $$Year-Rel$$ The Jalview Authors
- *
- * This file is part of Jalview.
- *
- * Jalview is free software: you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation, either version 3
- * of the License, or (at your option) any later version.
- *
- * Jalview is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
- * The Jalview Authors are detailed in the 'AUTHORS' file.
- */
-package jalview.appletgui;
-
-import jalview.analysis.AnnotationSorter;
-import jalview.api.AlignViewportI;
-import jalview.api.AlignmentViewPanel;
-import jalview.bin.JalviewLite;
-import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
-import jalview.datamodel.SequenceI;
-import jalview.structure.StructureSelectionManager;
-
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.FontMetrics;
-import java.awt.Graphics;
-import java.awt.event.AdjustmentEvent;
-import java.awt.event.AdjustmentListener;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
-import java.util.List;
-
-import javax.swing.JPanel;
-import javax.swing.JFrame;
-import javax.swing.JScrollBar;
-
-public class AlignmentPanel extends JPanel implements AdjustmentListener,
- AlignmentViewPanel
-{
-
- public AlignViewport av;
-
- OverviewPanel overviewPanel;
-
- SeqPanel seqPanel;
-
- IdPanel idPanel;
-
- IdwidthAdjuster idwidthAdjuster;
-
- public AlignFrame alignFrame;
-
- ScalePanel scalePanel;
-
- AnnotationPanel annotationPanel;
-
- AnnotationLabels alabels;
-
- // this value is set false when selection area being dragged
- boolean fastPaint = true;
-
- public void finalize()
- {
- alignFrame = null;
- av = null;
- seqPanel = null;
- seqPanelHolder = null;
- sequenceHolderPanel = null;
- scalePanel = null;
- scalePanelHolder = null;
- annotationPanel = null;
- annotationPanelHolder = null;
- annotationSpaceFillerHolder = null;
- }
-
- public AlignmentPanel(AlignFrame af, final AlignViewport av)
- {
- try
- {
- jbInit();
- } catch (Exception e)
- {
- e.printStackTrace();
- }
-
- alignFrame = af;
- this.av = av;
- seqPanel = new SeqPanel(av, this);
- idPanel = new IdPanel(av, this);
- scalePanel = new ScalePanel(av, this);
- idwidthAdjuster = new IdwidthAdjuster(this);
- annotationPanel = new AnnotationPanel(this);
- annotationPanelHolder.add(annotationPanel, BorderLayout.CENTER);
-
- sequenceHolderPanel.add(annotationPanelHolder, BorderLayout.SOUTH);
- alabels = new AnnotationLabels(this);
-
- setAnnotationVisible(av.isShowAnnotation());
-
- idPanelHolder.add(idPanel, BorderLayout.CENTER);
- idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
- annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
- scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
- seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
-
- fontChanged();
- setScrollValues(0, 0);
-
- apvscroll.addAdjustmentListener(this);
- hscroll.addAdjustmentListener(this);
- vscroll.addAdjustmentListener(this);
-
- addComponentListener(new ComponentAdapter()
- {
- public void componentResized(ComponentEvent evt)
- {
- setScrollValues(av.getStartRes(), av.getStartSeq());
- if (getSize().height > 0
- && annotationPanelHolder.getSize().height > 0)
- {
- validateAnnotationDimensions(false);
- }
- repaint();
- }
-
- });
-
- Dimension d = calculateIdWidth();
- idPanel.idCanvas.setSize(d);
-
- hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height);
-
- idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
- annotationSpaceFillerHolder.setSize(d.width,
- annotationPanel.getSize().height);
- alabels.setSize(d.width, annotationPanel.getSize().height);
- final AlignmentPanel ap = this;
- av.addPropertyChangeListener(new java.beans.PropertyChangeListener()
- {
- public void propertyChange(java.beans.PropertyChangeEvent evt)
- {
- if (evt.getPropertyName().equals("alignment"))
- {
- PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);
- alignmentChanged();
- }
- }
- });
- }
-
- @Override
- public AlignViewportI getAlignViewport()
- {
- return av;
- }
- public SequenceRenderer getSequenceRenderer()
- {
- return seqPanel.seqCanvas.sr;
- }
- @Override
- public jalview.api.FeatureRenderer getFeatureRenderer()
- {
- return seqPanel.seqCanvas.fr;
- }
- @Override
- public jalview.api.FeatureRenderer cloneFeatureRenderer()
- {
- FeatureRenderer nfr = new FeatureRenderer(av);
- nfr.transferSettings(seqPanel.seqCanvas.fr);
- return nfr;
- }
- public void alignmentChanged()
- {
- av.alignmentChanged(this);
-
- if (overviewPanel != null)
- {
- overviewPanel.updateOverviewImage();
- }
-
- alignFrame.updateEditMenuBar();
-
- repaint();
- }
-
- public void fontChanged()
- {
- // set idCanvas bufferedImage to null
- // to prevent drawing old image
- idPanel.idCanvas.image = null;
- FontMetrics fm = getFontMetrics(av.getFont());
-
- scalePanel.setSize(new Dimension(10, av.getCharHeight()
- + fm.getDescent()));
- idwidthAdjuster.setSize(new Dimension(10, av.getCharHeight()
- + fm.getDescent()));
- av.updateSequenceIdColours();
- annotationPanel.image = null;
- int ap = annotationPanel.adjustPanelHeight(false);
- Dimension d = calculateIdWidth();
- d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height);
- alabels.setSize(d.width + 4, ap);
-
- idPanel.idCanvas.setSize(d);
- hscrollFillerPanel.setSize(d);
-
- validateAnnotationDimensions(false);
- annotationPanel.repaint();
- validate();
- repaint();
-
- if (overviewPanel != null)
- {
- overviewPanel.updateOverviewImage();
- }
- }
-
- public void setIdWidth(int w, int h)
- {
- idPanel.idCanvas.setSize(w, h);
- idPanelHolder.setSize(w, idPanelHolder.getSize().height);
- annotationSpaceFillerHolder.setSize(w,
- annotationSpaceFillerHolder.getSize().height);
- alabels.setSize(w, alabels.getSize().height);
- validate();
- }
-
- Dimension calculateIdWidth()
- {
- if (av.nullFrame == null)
- {
- av.nullFrame = new JFrame();
- av.nullFrame.addNotify();
- }
-
- Graphics g = av.nullFrame.getGraphics();
-
- FontMetrics fm = g.getFontMetrics(av.font);
- 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);
- }
- i++;
- }
-
- // Also check annotation label widths
- i = 0;
- if (al.getAlignmentAnnotation() != null)
- {
- fm = g.getFontMetrics(av.nullFrame.getFont());
- while (i < al.getAlignmentAnnotation().length)
- {
- String label = al.getAlignmentAnnotation()[i].label;
- if (fm.stringWidth(label) > idWidth)
- {
- idWidth = fm.stringWidth(label);
- }
- i++;
- }
- }
-
- return new Dimension(idWidth, idPanel.idCanvas.getSize().height);
- }
-
- /**
- * Highlight the given results on the alignment.
- *
- */
- public void highlightSearchResults(SearchResults results)
- {
- scrollToPosition(results);
- seqPanel.seqCanvas.highlightSearchResults(results);
- }
-
- /**
- * scroll the view to show the position of the highlighted region in results
- * (if any) and redraw the overview
- *
- * @param results
- * @return false if results were not found
- */
- public boolean scrollToPosition(SearchResults results)
- {
- return scrollToPosition(results, true);
- }
-
- /**
- * scroll the view to show the position of the highlighted region in results
- * (if any)
- *
- * @param results
- * @param redrawOverview
- * - when set, the overview will be recalculated (takes longer)
- * @return false if results were not found
- */
- public boolean scrollToPosition(SearchResults results,
- boolean redrawOverview)
- {
- return scrollToPosition(results, redrawOverview, false);
- }
-
- /**
- * scroll the view to show the position of the highlighted region in results
- * (if any)
- *
- * @param results
- * @param redrawOverview
- * - when set, the overview will be recalculated (takes longer)
- * @return false if results were not found
- */
- public boolean scrollToPosition(SearchResults results,
- boolean redrawOverview, boolean centre)
- {
- // do we need to scroll the panel?
- if (results != null && results.getSize() > 0)
- {
- AlignmentI alignment = av.getAlignment();
- int seqIndex = alignment.findIndex(results);
- if (seqIndex == -1)
- {
- return false;
- }
- SequenceI seq = alignment.getSequenceAt(seqIndex);
- int[] r = results.getResults(seq, 0, alignment.getWidth());
- if (r == null)
- {
- if (JalviewLite.debug)
- {// DEBUG
- System.out
- .println("DEBUG: scroll didn't happen - results not within alignment : "
- + seq.getStart() + "," + seq.getEnd());
- }
- return false;
- }
- if (JalviewLite.debug)
- {
- // DEBUG
- /*
- * System.out.println("DEBUG: scroll: start=" + r[0] +
- * " av.getStartRes()=" + av.getStartRes() + " end=" + r[1] +
- * " seq.end=" + seq.getEnd() + " av.getEndRes()=" + av.getEndRes() +
- * " hextent=" + hextent);
- */
- }
- int start = r[0];
- int end = r[1];
-
- /*
- * To centre results, scroll to positions half the visible width
- * left/right of the start/end positions
- */
- if (centre)
- {
- int offset = (av.getEndRes() - av.getStartRes() + 1) / 2 - 1;
- start = Math.max(start - offset, 0);
- end = Math.min(end + offset, seq.getEnd() - 1);
- }
-
- if (start < 0)
- {
- return false;
- }
- if (end == seq.getEnd())
- {
- return false;
- }
- return scrollTo(start, end, seqIndex, false, redrawOverview);
- }
- return true;
- }
-
- public boolean scrollTo(int ostart, int end, int seqIndex,
- boolean scrollToNearest, boolean redrawOverview)
- {
- int startv, endv, starts, ends, width;
-
- int start = -1;
- if (av.hasHiddenColumns())
- {
- start = av.getColumnSelection().findColumnPosition(ostart);
- end = av.getColumnSelection().findColumnPosition(end);
- if (start == end)
- {
- if (!scrollToNearest && !av.getColumnSelection().isVisible(ostart))
- {
- // don't scroll - position isn't visible
- return false;
- }
- }
- }
- else
- {
- start = ostart;
- }
- if (!av.getWrapAlignment())
- {
- /*
- * int spos=av.getStartRes(),sqpos=av.getStartSeq(); if ((startv =
- * av.getStartRes()) >= start) { spos=start-1; // seqIn //
- * setScrollValues(start - 1, seqIndex); } else if ((endv =
- * av.getEndRes()) <= end) { // setScrollValues(spos=startv + 1 + end -
- * endv, seqIndex); spos=startv + 1 + end - endv; } else if ((starts =
- * av.getStartSeq()) > seqIndex) { setScrollValues(av.getStartRes(),
- * seqIndex); } else if ((ends = av.getEndSeq()) <= seqIndex) {
- * setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1); }
- */
-
- // below is scrolling logic up to Jalview 2.8.2
- // if ((av.getStartRes() > end)
- // || (av.getEndRes() < start)
- // || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))
- // {
- // if (start > av.getAlignment().getWidth() - hextent)
- // {
- // start = av.getAlignment().getWidth() - hextent;
- // if (start < 0)
- // {
- // start = 0;
- // }
- //
- // }
- // if (seqIndex > av.getAlignment().getHeight() - vextent)
- // {
- // seqIndex = av.getAlignment().getHeight() - vextent;
- // if (seqIndex < 0)
- // {
- // seqIndex = 0;
- // }
- // }
- // setScrollValues(start, seqIndex);
- // }
- // logic copied from jalview.gui.AlignmentPanel:
- if ((startv = av.getStartRes()) >= start)
- {
- /*
- * Scroll left to make start of search results visible
- */
- setScrollValues(start - 1, seqIndex);
- }
- else if ((endv = av.getEndRes()) <= end)
- {
- /*
- * Scroll right to make end of search results visible
- */
- setScrollValues(startv + 1 + end - endv, seqIndex);
- }
- else if ((starts = av.getStartSeq()) > seqIndex)
- {
- /*
- * Scroll up to make start of search results visible
- */
- setScrollValues(av.getStartRes(), seqIndex);
- }
- else if ((ends = av.getEndSeq()) <= seqIndex)
- {
- /*
- * Scroll down to make end of search results visible
- */
- setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1);
- }
- /*
- * Else results are already visible - no need to scroll
- */
- }
- else
- {
- scrollToWrappedVisible(start);
- }
- if (redrawOverview && overviewPanel != null)
- {
- overviewPanel.setBoxPosition();
- }
- paintAlignment(redrawOverview);
- return true;
- }
-
- void scrollToWrappedVisible(int res)
- {
- int cwidth = seqPanel.seqCanvas
- .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
- if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))
- {
- vscroll.setValue(res / cwidth);
- av.startRes = vscroll.getValue() * cwidth;
- }
- }
-
- public OverviewPanel getOverviewPanel()
- {
- return overviewPanel;
- }
-
- public void setOverviewPanel(OverviewPanel op)
- {
- overviewPanel = op;
- }
-
- public void setAnnotationVisible(boolean b)
- {
- if (!av.getWrapAlignment())
- {
- annotationSpaceFillerHolder.setVisible(b);
- annotationPanelHolder.setVisible(b);
- }
- else
- {
- annotationSpaceFillerHolder.setVisible(false);
- annotationPanelHolder.setVisible(false);
- }
- validate();
- repaint();
- }
-
- /**
- * automatically adjust annotation panel height for new annotation whilst
- * ensuring the alignment is still visible.
- */
- public void adjustAnnotationHeight()
- {
- // TODO: display vertical annotation scrollbar if necessary
- // this is called after loading new annotation onto alignment
- if (alignFrame.getSize().height == 0)
- {
- System.out
- .println("adjustAnnotationHeight frame size zero NEEDS FIXING");
- }
- fontChanged();
- validateAnnotationDimensions(true);
- apvscroll.addNotify();
- hscroll.addNotify();
- validate();
- paintAlignment(true);
- }
-
- /**
- * Calculate the annotation dimensions and refresh slider values accordingly.
- * Need to do repaints/notifys afterwards.
- */
- protected void validateAnnotationDimensions(boolean adjustPanelHeight)
- {
- int rowHeight = av.getCharHeight();
- int alignmentHeight = rowHeight * av.getAlignment().getHeight();
- int annotationHeight = av.calcPanelHeight();
-
- int mheight = annotationHeight;
- Dimension d = sequenceHolderPanel.getSize();
-
- int availableHeight = d.height - scalePanelHolder.getHeight();
-
- if (adjustPanelHeight)
- {
- /*
- * 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 = annotationPanelHolder.getSize().height;
- }
-
- if (availableHeight - annotationHeight < 5)
- {
- annotationHeight = availableHeight;
- }
-
- annotationPanel.setSize(new Dimension(d.width, annotationHeight));
- annotationPanelHolder.setSize(new Dimension(d.width, annotationHeight));
- // seqPanelHolder.setSize(d.width, seqandannot - height);
- seqPanel.seqCanvas
- .setSize(d.width, seqPanel.seqCanvas.getSize().height);
-
- Dimension e = idPanel.getSize();
- alabels.setSize(new Dimension(e.width, annotationHeight));
- annotationSpaceFillerHolder.setSize(new Dimension(e.width,
- annotationHeight));
-
- int s = apvscroll.getValue();
- if (s > mheight - annotationHeight)
- {
- s = 0;
- }
- apvscroll.setValues(s, annotationHeight, 0, mheight);
- annotationPanel.setScrollOffset(apvscroll.getValue(), false);
- alabels.setScrollOffset(apvscroll.getValue(), false);
- }
-
- public void setWrapAlignment(boolean wrap)
- {
- av.startSeq = 0;
- av.startRes = 0;
- scalePanelHolder.setVisible(!wrap);
-
- hscroll.setVisible(!wrap);
- idwidthAdjuster.setVisible(!wrap);
-
- if (wrap)
- {
- annotationPanelHolder.setVisible(false);
- annotationSpaceFillerHolder.setVisible(false);
- }
- else if (av.isShowAnnotation())
- {
- annotationPanelHolder.setVisible(true);
- annotationSpaceFillerHolder.setVisible(true);
- }
-
- idSpaceFillerPanel1.setVisible(!wrap);
-
- fontChanged(); // This is so that the scalePanel is resized correctly
-
- validate();
- sequenceHolderPanel.validate();
- repaint();
-
- }
-
- int hextent = 0;
-
- int vextent = 0;
-
- // return value is true if the scroll is valid
- public boolean scrollUp(boolean up)
- {
- if (up)
- {
- if (vscroll.getValue() < 1)
- {
- return false;
- }
- setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);
- }
- else
- {
- if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())
- {
- return false;
- }
- setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);
- }
-
- repaint();
- return true;
- }
-
- public boolean scrollRight(boolean right)
- {
- if (!right)
- {
- if (hscroll.getValue() < 1)
- {
- return false;
- }
- setScrollValues(hscroll.getValue() - 1, vscroll.getValue());
- }
- else
- {
- if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())
- {
- return false;
- }
- setScrollValues(hscroll.getValue() + 1, vscroll.getValue());
- }
-
- repaint();
- return true;
- }
-
- public void setScrollValues(int x, int y)
- {
- int width = av.getAlignment().getWidth();
- int height = av.getAlignment().getHeight();
-
- if (av.hasHiddenColumns())
- {
- width = av.getColumnSelection().findColumnPosition(width);
- }
- if (x < 0)
- {
- x = 0;
- }
- ;
-
- hextent = seqPanel.seqCanvas.getSize().width / av.getCharWidth();
- vextent = seqPanel.seqCanvas.getSize().height / av.getCharHeight();
-
- if (hextent > width)
- {
- hextent = width;
- }
-
- if (vextent > height)
- {
- vextent = height;
- }
-
- if ((hextent + x) > width)
- {
- System.err.println("hextent was " + hextent + " and x was " + x);
-
- x = width - hextent;
- }
-
- if ((vextent + y) > height)
- {
- y = height - vextent;
- }
-
- if (y < 0)
- {
- y = 0;
- }
-
- if (x < 0)
- {
- System.err.println("x was " + x);
- x = 0;
- }
-
- av.setStartSeq(y);
-
- int endSeq = y + vextent;
- if (endSeq > av.getAlignment().getHeight())
- {
- endSeq = av.getAlignment().getHeight();
- }
-
- av.setEndSeq(endSeq);
- av.setStartRes(x);
- av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av
- .getCharWidth())) - 1);
-
- hscroll.setValues(x, hextent, 0, width);
- vscroll.setValues(y, vextent, 0, height);
-
- if (overviewPanel != null)
- {
- overviewPanel.setBoxPosition();
- }
- sendViewPosition();
-
- }
-
- public void adjustmentValueChanged(AdjustmentEvent evt)
- {
- int oldX = av.getStartRes();
- int oldY = av.getStartSeq();
-
- if (evt == null || evt.getSource() == apvscroll)
- {
- annotationPanel.setScrollOffset(apvscroll.getValue(), false);
- alabels.setScrollOffset(apvscroll.getValue(), false);
- // annotationPanel.image=null;
- // alabels.image=null;
- // alabels.repaint();
- // annotationPanel.repaint();
- }
- if (evt == null || evt.getSource() == hscroll)
- {
- int x = hscroll.getValue();
- av.setStartRes(x);
- av.setEndRes(x + seqPanel.seqCanvas.getSize().width
- / av.getCharWidth() - 1);
- }
-
- if (evt == null || evt.getSource() == vscroll)
- {
- int offy = vscroll.getValue();
- if (av.getWrapAlignment())
- {
- int rowSize = seqPanel.seqCanvas
- .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
- av.setStartRes(vscroll.getValue() * rowSize);
- av.setEndRes((vscroll.getValue() + 1) * rowSize);
- }
- else
- {
- av.setStartSeq(offy);
- av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height
- / av.getCharHeight());
- }
- }
-
- if (overviewPanel != null)
- {
- overviewPanel.setBoxPosition();
- }
-
- int scrollX = av.startRes - oldX;
- int scrollY = av.startSeq - oldY;
-
- if (av.getWrapAlignment() || !fastPaint || av.MAC)
- {
- repaint();
- }
- else
- {
- // Make sure we're not trying to draw a panel
- // larger than the visible window
- if (scrollX > av.endRes - av.startRes)
- {
- scrollX = av.endRes - av.startRes;
- }
- else if (scrollX < av.startRes - av.endRes)
- {
- scrollX = av.startRes - av.endRes;
- }
-
- idPanel.idCanvas.fastPaint(scrollY);
- seqPanel.seqCanvas.fastPaint(scrollX, scrollY);
-
- scalePanel.repaint();
- if (av.isShowAnnotation())
- {
- annotationPanel.fastPaint(av.getStartRes() - oldX);
- }
- }
- sendViewPosition();
-
- /*
- * If there is one, scroll the (Protein/cDNA) complementary alignment to
- * match, unless we are ourselves doing that.
- */
- if (isFollowingComplementScroll())
- {
- setFollowingComplementScroll(false);
- }
- else
- {
- AlignmentPanel ap = getComplementPanel();
- av.scrollComplementaryAlignment(ap);
- }
-
- }
-
- /**
- * A helper method to return the AlignmentPanel in the other (complementary)
- * half of a SplitFrame view. Returns null if not in a SplitFrame.
- *
- * @return
- */
- private AlignmentPanel getComplementPanel()
- {
- AlignmentPanel ap = null;
- if (alignFrame != null)
- {
- SplitFrame sf = alignFrame.getSplitFrame();
- if (sf != null)
- {
- AlignFrame other = sf.getComplement(alignFrame);
- if (other != null)
- {
- ap = other.alignPanel;
- }
- }
- }
- return ap;
- }
-
- /**
- * Follow a scrolling change in the (cDNA/Protein) complementary alignment.
- * The aim is to keep the two alignments 'lined up' on their centre columns.
- *
- * @param sr
- * holds mapped region(s) of this alignment that we are scrolling
- * 'to'; may be modified for sequence offset by this method
- * @param seqOffset
- * the number of visible sequences to show above the mapped region
- */
- protected void scrollToCentre(SearchResults sr, int seqOffset)
- {
- /*
- * 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.getResultSequence(0);
- List<SequenceI> seqs = av.getAlignment().getSequences();
-
- /*
- * This is like AlignmentI.findIndex(seq) but here we are matching the
- * dataset sequence not the aligned sequence
- */
- int sequenceIndex = 0;
- boolean matched = false;
- for (SequenceI seq : seqs)
- {
- if (mappedTo == seq.getDatasetSequence())
- {
- matched = true;
- break;
- }
- sequenceIndex++;
- }
- if (!matched)
- {
- return; // failsafe, shouldn't happen
- }
- sequenceIndex = Math.max(0, sequenceIndex - seqOffset);
- sr.getResults().get(0)
- .setSequence(av.getAlignment().getSequenceAt(sequenceIndex));
-
- /*
- * Scroll to position but centring the target residue. Also set a state flag
- * to prevent adjustmentValueChanged performing this recursively.
- */
- setFollowingComplementScroll(true);
- scrollToPosition(sr, true, true);
- }
-
- private void sendViewPosition()
- {
- StructureSelectionManager.getStructureSelectionManager(av.applet)
- .sendViewPosition(this, av.startRes, av.endRes, av.startSeq,
- av.endSeq);
- }
-
- /**
- * Repaint the alignment and annotations, and, optionally, any overview window
- */
- public void paintAlignment(boolean updateOverview)
- {
- final AnnotationSorter sorter = new AnnotationSorter(getAlignment(),
- av.isShowAutocalculatedAbove());
- sorter.sort(getAlignment().getAlignmentAnnotation(),
- av.getSortAnnotationsBy());
- repaint();
-
- if (updateOverview)
- {
- StructureSelectionManager.getStructureSelectionManager(av.applet)
- .sequenceColoursChanged(this);
-
- if (overviewPanel != null)
- {
- overviewPanel.updateOverviewImage();
- }
- }
- }
-
- public void update(Graphics g)
- {
- paint(g);
- }
-
- public void paint(Graphics g)
- {
- invalidate();
- Dimension d = idPanel.idCanvas.getSize();
- final int canvasHeight = seqPanel.seqCanvas.getSize().height;
- if (canvasHeight != d.height)
- {
- idPanel.idCanvas.setSize(d.width, canvasHeight);
- }
-
- if (av.getWrapAlignment())
- {
- int maxwidth = av.getAlignment().getWidth();
-
- if (av.hasHiddenColumns())
- {
- maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
- }
-
- int canvasWidth = seqPanel.seqCanvas
- .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
-
- if (canvasWidth > 0)
- {
- int max = maxwidth / canvasWidth;
- vscroll.setMaximum(1 + max);
- vscroll.setUnitIncrement(1);
- vscroll.setVisibleAmount(1);
- }
- }
- else
- {
- setScrollValues(av.getStartRes(), av.getStartSeq());
- }
-
- seqPanel.seqCanvas.repaint();
- idPanel.idCanvas.repaint();
- if (!av.getWrapAlignment())
- {
- if (av.isShowAnnotation())
- {
- alabels.repaint();
- annotationPanel.repaint();
- }
- scalePanel.repaint();
- }
-
- }
-
- protected JPanel sequenceHolderPanel = new JPanel();
-
- protected JScrollBar vscroll = new JScrollBar();
-
- protected JScrollBar hscroll = new JScrollBar();
-
- protected JPanel seqPanelHolder = new JPanel();
-
- protected JPanel scalePanelHolder = new JPanel();
-
- protected JPanel idPanelHolder = new JPanel();
-
- protected JPanel idSpaceFillerPanel1 = new JPanel();
-
- public JPanel annotationSpaceFillerHolder = new JPanel();
-
- protected JPanel hscrollFillerPanel = new JPanel();
-
- JPanel annotationPanelHolder = new JPanel();
-
- protected JScrollBar apvscroll = new JScrollBar();
-
- /*
- * Flag set while scrolling to follow complementary cDNA/protein scroll. When
- * true, suppresses invoking the same method recursively.
- */
- private boolean followingComplementScroll;
-
- private void jbInit() throws Exception
- {
- // idPanelHolder.setPreferredSize(new Dimension(70, 10));
- this.setLayout(new BorderLayout());
-
- // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));
- sequenceHolderPanel.setLayout(new BorderLayout());
- seqPanelHolder.setLayout(new BorderLayout());
- scalePanelHolder.setBackground(Color.white);
-
- // scalePanelHolder.setPreferredSize(new Dimension(10, 30));
- scalePanelHolder.setLayout(new BorderLayout());
- idPanelHolder.setLayout(new BorderLayout());
- idSpaceFillerPanel1.setBackground(Color.white);
-
- // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));
- idSpaceFillerPanel1.setLayout(new BorderLayout());
- annotationSpaceFillerHolder.setBackground(Color.white);
-
- // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));
- annotationSpaceFillerHolder.setLayout(new BorderLayout());
- hscroll.setOrientation(JScrollBar.HORIZONTAL);
-
- JPanel hscrollHolder = new JPanel();
- hscrollHolder.setLayout(new BorderLayout());
- hscrollFillerPanel.setBackground(Color.white);
- apvscroll.setOrientation(JScrollBar.VERTICAL);
- apvscroll.setVisible(true);
- apvscroll.addAdjustmentListener(this);
-
- annotationPanelHolder.setBackground(Color.white);
- annotationPanelHolder.setLayout(new BorderLayout());
- annotationPanelHolder.add(apvscroll, BorderLayout.EAST);
- // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));
- hscrollHolder.setBackground(Color.white);
-
- // annotationScroller.setPreferredSize(new Dimension(10, 80));
- // this.setPreferredSize(new Dimension(220, 166));
- seqPanelHolder.setBackground(Color.white);
- idPanelHolder.setBackground(Color.white);
- sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);
- sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);
- seqPanelHolder.add(vscroll, BorderLayout.EAST);
-
- // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);
- this.add(idPanelHolder, BorderLayout.WEST);
- idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);
- idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);
- this.add(hscrollHolder, BorderLayout.SOUTH);
- hscrollHolder.add(hscroll, BorderLayout.CENTER);
- hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);
- this.add(sequenceHolderPanel, BorderLayout.CENTER);
- }
-
- /**
- * hides or shows dynamic annotation rows based on groups and av state flags
- */
- public void updateAnnotation()
- {
- updateAnnotation(false);
- }
-
- public void updateAnnotation(boolean applyGlobalSettings)
- {
- updateAnnotation(applyGlobalSettings, false);
- }
-
- public void updateAnnotation(boolean applyGlobalSettings,
- boolean preserveNewGroupSettings)
- {
- av.updateGroupAnnotationSettings(applyGlobalSettings,
- preserveNewGroupSettings);
- adjustAnnotationHeight();
- }
-
- @Override
- public AlignmentI getAlignment()
- {
- return av.getAlignment();
- }
-
- @Override
- public String getViewName()
- {
- return getName();
- }
-
- @Override
- public StructureSelectionManager getStructureSelectionManager()
- {
- return StructureSelectionManager
- .getStructureSelectionManager(av.applet);
- }
-
- @Override
- public void raiseOOMWarning(String string, OutOfMemoryError error)
- {
- // TODO: JAL-960
- System.err.println("Out of memory whilst '" + string + "'");
- error.printStackTrace();
- }
-
- /**
- * Set a flag to say we are scrolling to follow a (cDNA/protein) complement.
- *
- * @param b
- */
- protected void setFollowingComplementScroll(boolean b)
- {
- this.followingComplementScroll = b;
- }
-
- protected boolean isFollowingComplementScroll()
- {
- return this.followingComplementScroll;
- }
-
-}
+/*\r
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)\r
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors\r
+ * \r
+ * This file is part of Jalview.\r
+ * \r
+ * Jalview is free software: you can redistribute it and/or\r
+ * modify it under the terms of the GNU General Public License \r
+ * as published by the Free Software Foundation, either version 3\r
+ * of the License, or (at your option) any later version.\r
+ * \r
+ * Jalview is distributed in the hope that it will be useful, but \r
+ * WITHOUT ANY WARRANTY; without even the implied warranty \r
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR \r
+ * PURPOSE. See the GNU General Public License for more details.\r
+ * \r
+ * You should have received a copy of the GNU General Public License\r
+ * along with Jalview. If not, see <http://www.gnu.org/licenses/>.\r
+ * The Jalview Authors are detailed in the 'AUTHORS' file.\r
+ */\r
+package jalview.appletgui;\r
+\r
+import jalview.analysis.AnnotationSorter;\r
+import jalview.api.AlignViewportI;\r
+import jalview.api.AlignmentViewPanel;\r
+import jalview.bin.JalviewLite;\r
+import jalview.datamodel.AlignmentI;\r
+import jalview.datamodel.SearchResults;\r
+import jalview.datamodel.SequenceI;\r
+import jalview.structure.StructureSelectionManager;\r
+\r
+import java.awt.BorderLayout;\r
+import java.awt.Color;\r
+import java.awt.Dimension;\r
+import java.awt.FontMetrics;\r
+import java.awt.Graphics;\r
+import java.awt.event.AdjustmentEvent;\r
+import java.awt.event.AdjustmentListener;\r
+import java.awt.event.ComponentAdapter;\r
+import java.awt.event.ComponentEvent;\r
+import java.util.List;\r
+\r
+import javax.swing.JPanel;\r
+import javax.swing.JFrame;\r
+import javax.swing.JScrollBar;\r
+\r
+public class AlignmentPanel extends JPanel implements AdjustmentListener,\r
+ AlignmentViewPanel\r
+{\r
+\r
+ public AlignViewport av;\r
+\r
+ OverviewPanel overviewPanel;\r
+\r
+ SeqPanel seqPanel;\r
+\r
+ IdPanel idPanel;\r
+\r
+ IdwidthAdjuster idwidthAdjuster;\r
+\r
+ public AlignFrame alignFrame;\r
+\r
+ ScalePanel scalePanel;\r
+\r
+ AnnotationPanel annotationPanel;\r
+\r
+ AnnotationLabels alabels;\r
+\r
+ // this value is set false when selection area being dragged\r
+ boolean fastPaint = true;\r
+\r
+ public void finalize()\r
+ {\r
+ alignFrame = null;\r
+ av = null;\r
+ seqPanel = null;\r
+ seqPanelHolder = null;\r
+ sequenceHolderPanel = null;\r
+ scalePanel = null;\r
+ scalePanelHolder = null;\r
+ annotationPanel = null;\r
+ annotationPanelHolder = null;\r
+ annotationSpaceFillerHolder = null;\r
+ }\r
+\r
+ public AlignmentPanel(AlignFrame af, final AlignViewport av)\r
+ {\r
+ try\r
+ {\r
+ jbInit();\r
+ } catch (Exception e)\r
+ {\r
+ e.printStackTrace();\r
+ }\r
+\r
+ alignFrame = af;\r
+ this.av = av;\r
+ seqPanel = new SeqPanel(av, this);\r
+ idPanel = new IdPanel(av, this);\r
+ scalePanel = new ScalePanel(av, this);\r
+ idwidthAdjuster = new IdwidthAdjuster(this);\r
+ annotationPanel = new AnnotationPanel(this);\r
+ annotationPanelHolder.add(annotationPanel, BorderLayout.CENTER);\r
+\r
+ sequenceHolderPanel.add(annotationPanelHolder, BorderLayout.SOUTH);\r
+ alabels = new AnnotationLabels(this);\r
+\r
+ setAnnotationVisible(av.isShowAnnotation());\r
+\r
+ idPanelHolder.add(idPanel, BorderLayout.CENTER);\r
+ idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);\r
+ annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);\r
+ scalePanelHolder.add(scalePanel, BorderLayout.CENTER);\r
+ seqPanelHolder.add(seqPanel, BorderLayout.CENTER);\r
+\r
+ fontChanged();\r
+ setScrollValues(0, 0);\r
+\r
+ apvscroll.addAdjustmentListener(this);\r
+ hscroll.addAdjustmentListener(this);\r
+ vscroll.addAdjustmentListener(this);\r
+\r
+ addComponentListener(new ComponentAdapter()\r
+ {\r
+ public void componentResized(ComponentEvent evt)\r
+ {\r
+ setScrollValues(av.getStartRes(), av.getStartSeq());\r
+ if (getSize().height > 0\r
+ && annotationPanelHolder.getSize().height > 0)\r
+ {\r
+ validateAnnotationDimensions(false);\r
+ }\r
+ repaint();\r
+ }\r
+\r
+ });\r
+\r
+ Dimension d = calculateIdWidth();\r
+ idPanel.idCanvas.setSize(d);\r
+\r
+ hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height);\r
+\r
+ idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);\r
+ annotationSpaceFillerHolder.setSize(d.width,\r
+ annotationPanel.getSize().height);\r
+ alabels.setSize(d.width, annotationPanel.getSize().height);\r
+ final AlignmentPanel ap = this;\r
+ av.addPropertyChangeListener(new java.beans.PropertyChangeListener()\r
+ {\r
+ public void propertyChange(java.beans.PropertyChangeEvent evt)\r
+ {\r
+ if (evt.getPropertyName().equals("alignment"))\r
+ {\r
+ PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);\r
+ alignmentChanged();\r
+ }\r
+ }\r
+ });\r
+ }\r
+\r
+ @Override\r
+ public AlignViewportI getAlignViewport()\r
+ {\r
+ return av;\r
+ }\r
+ public SequenceRenderer getSequenceRenderer()\r
+ {\r
+ return seqPanel.seqCanvas.sr;\r
+ }\r
+ @Override\r
+ public jalview.api.FeatureRenderer getFeatureRenderer()\r
+ {\r
+ return seqPanel.seqCanvas.fr;\r
+ }\r
+ @Override\r
+ public jalview.api.FeatureRenderer cloneFeatureRenderer()\r
+ {\r
+ FeatureRenderer nfr = new FeatureRenderer(av);\r
+ nfr.transferSettings(seqPanel.seqCanvas.fr);\r
+ return nfr;\r
+ }\r
+ public void alignmentChanged()\r
+ {\r
+ av.alignmentChanged(this);\r
+\r
+ if (overviewPanel != null)\r
+ {\r
+ overviewPanel.updateOverviewImage();\r
+ }\r
+\r
+ alignFrame.updateEditMenuBar();\r
+\r
+ repaint();\r
+ }\r
+\r
+ public void fontChanged()\r
+ {\r
+ // set idCanvas bufferedImage to null\r
+ // to prevent drawing old image\r
+ idPanel.idCanvas.image = null;\r
+ FontMetrics fm = getFontMetrics(av.getFont());\r
+\r
+ scalePanel.setSize(new Dimension(10, av.getCharHeight()\r
+ + fm.getDescent()));\r
+ idwidthAdjuster.setSize(new Dimension(10, av.getCharHeight()\r
+ + fm.getDescent()));\r
+ av.updateSequenceIdColours();\r
+ annotationPanel.image = null;\r
+ int ap = annotationPanel.adjustPanelHeight(false);\r
+ Dimension d = calculateIdWidth();\r
+ d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height);\r
+ alabels.setSize(d.width + 4, ap);\r
+\r
+ idPanel.idCanvas.setSize(d);\r
+ hscrollFillerPanel.setSize(d);\r
+\r
+ validateAnnotationDimensions(false);\r
+ annotationPanel.repaint();\r
+ validate();\r
+ repaint();\r
+\r
+ if (overviewPanel != null)\r
+ {\r
+ overviewPanel.updateOverviewImage();\r
+ }\r
+ }\r
+\r
+ public void setIdWidth(int w, int h)\r
+ {\r
+ idPanel.idCanvas.setSize(w, h);\r
+ idPanelHolder.setSize(w, idPanelHolder.getSize().height);\r
+ annotationSpaceFillerHolder.setSize(w,\r
+ annotationSpaceFillerHolder.getSize().height);\r
+ alabels.setSize(w, alabels.getSize().height);\r
+ validate();\r
+ }\r
+\r
+ Dimension calculateIdWidth()\r
+ {\r
+ if (av.nullFrame == null)\r
+ {\r
+ av.nullFrame = new JFrame();\r
+ av.nullFrame.addNotify();\r
+ }\r
+\r
+ Graphics g = av.nullFrame.getGraphics();\r
+\r
+ FontMetrics fm = g.getFontMetrics(av.font);\r
+ AlignmentI al = av.getAlignment();\r
+\r
+ int i = 0;\r
+ int idWidth = 0;\r
+ String id;\r
+ while (i < al.getHeight() && al.getSequenceAt(i) != null)\r
+ {\r
+ SequenceI s = al.getSequenceAt(i);\r
+ id = s.getDisplayId(av.getShowJVSuffix());\r
+\r
+ if (fm.stringWidth(id) > idWidth)\r
+ {\r
+ idWidth = fm.stringWidth(id);\r
+ }\r
+ i++;\r
+ }\r
+\r
+ // Also check annotation label widths\r
+ i = 0;\r
+ if (al.getAlignmentAnnotation() != null)\r
+ {\r
+ fm = g.getFontMetrics(av.nullFrame.getFont());\r
+ while (i < al.getAlignmentAnnotation().length)\r
+ {\r
+ String label = al.getAlignmentAnnotation()[i].label;\r
+ if (fm.stringWidth(label) > idWidth)\r
+ {\r
+ idWidth = fm.stringWidth(label);\r
+ }\r
+ i++;\r
+ }\r
+ }\r
+\r
+ return new Dimension(idWidth, idPanel.idCanvas.getSize().height);\r
+ }\r
+\r
+ /**\r
+ * Highlight the given results on the alignment.\r
+ * \r
+ */\r
+ public void highlightSearchResults(SearchResults results)\r
+ {\r
+ scrollToPosition(results);\r
+ seqPanel.seqCanvas.highlightSearchResults(results);\r
+ }\r
+\r
+ /**\r
+ * scroll the view to show the position of the highlighted region in results\r
+ * (if any) and redraw the overview\r
+ * \r
+ * @param results\r
+ * @return false if results were not found\r
+ */\r
+ public boolean scrollToPosition(SearchResults results)\r
+ {\r
+ return scrollToPosition(results, true);\r
+ }\r
+\r
+ /**\r
+ * scroll the view to show the position of the highlighted region in results\r
+ * (if any)\r
+ * \r
+ * @param results\r
+ * @param redrawOverview\r
+ * - when set, the overview will be recalculated (takes longer)\r
+ * @return false if results were not found\r
+ */\r
+ public boolean scrollToPosition(SearchResults results,\r
+ boolean redrawOverview)\r
+ {\r
+ return scrollToPosition(results, redrawOverview, false);\r
+ }\r
+\r
+ /**\r
+ * scroll the view to show the position of the highlighted region in results\r
+ * (if any)\r
+ * \r
+ * @param results\r
+ * @param redrawOverview\r
+ * - when set, the overview will be recalculated (takes longer)\r
+ * @return false if results were not found\r
+ */\r
+ public boolean scrollToPosition(SearchResults results,\r
+ boolean redrawOverview, boolean centre)\r
+ {\r
+ // do we need to scroll the panel?\r
+ if (results != null && results.getSize() > 0)\r
+ {\r
+ AlignmentI alignment = av.getAlignment();\r
+ int seqIndex = alignment.findIndex(results);\r
+ if (seqIndex == -1)\r
+ {\r
+ return false;\r
+ }\r
+ SequenceI seq = alignment.getSequenceAt(seqIndex);\r
+ int[] r = results.getResults(seq, 0, alignment.getWidth());\r
+ if (r == null)\r
+ {\r
+ if (JalviewLite.debug)\r
+ {// DEBUG\r
+ System.out\r
+ .println("DEBUG: scroll didn't happen - results not within alignment : "\r
+ + seq.getStart() + "," + seq.getEnd());\r
+ }\r
+ return false;\r
+ }\r
+ if (JalviewLite.debug)\r
+ {\r
+ // DEBUG\r
+ /*\r
+ * System.out.println("DEBUG: scroll: start=" + r[0] +\r
+ * " av.getStartRes()=" + av.getStartRes() + " end=" + r[1] +\r
+ * " seq.end=" + seq.getEnd() + " av.getEndRes()=" + av.getEndRes() +\r
+ * " hextent=" + hextent);\r
+ */\r
+ }\r
+ int start = r[0];\r
+ int end = r[1];\r
+\r
+ /*\r
+ * To centre results, scroll to positions half the visible width\r
+ * left/right of the start/end positions\r
+ */\r
+ if (centre)\r
+ {\r
+ int offset = (av.getEndRes() - av.getStartRes() + 1) / 2 - 1;\r
+ start = Math.max(start - offset, 0);\r
+ end = Math.min(end + offset, seq.getEnd() - 1);\r
+ }\r
+\r
+ if (start < 0)\r
+ {\r
+ return false;\r
+ }\r
+ if (end == seq.getEnd())\r
+ {\r
+ return false;\r
+ }\r
+ return scrollTo(start, end, seqIndex, false, redrawOverview);\r
+ }\r
+ return true;\r
+ }\r
+\r
+ public boolean scrollTo(int ostart, int end, int seqIndex,\r
+ boolean scrollToNearest, boolean redrawOverview)\r
+ {\r
+ int startv, endv, starts, ends, width;\r
+\r
+ int start = -1;\r
+ if (av.hasHiddenColumns())\r
+ {\r
+ start = av.getColumnSelection().findColumnPosition(ostart);\r
+ end = av.getColumnSelection().findColumnPosition(end);\r
+ if (start == end)\r
+ {\r
+ if (!scrollToNearest && !av.getColumnSelection().isVisible(ostart))\r
+ {\r
+ // don't scroll - position isn't visible\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ start = ostart;\r
+ }\r
+ if (!av.getWrapAlignment())\r
+ {\r
+ /*\r
+ * int spos=av.getStartRes(),sqpos=av.getStartSeq(); if ((startv =\r
+ * av.getStartRes()) >= start) { spos=start-1; // seqIn //\r
+ * setScrollValues(start - 1, seqIndex); } else if ((endv =\r
+ * av.getEndRes()) <= end) { // setScrollValues(spos=startv + 1 + end -\r
+ * endv, seqIndex); spos=startv + 1 + end - endv; } else if ((starts =\r
+ * av.getStartSeq()) > seqIndex) { setScrollValues(av.getStartRes(),\r
+ * seqIndex); } else if ((ends = av.getEndSeq()) <= seqIndex) {\r
+ * setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1); }\r
+ */\r
+\r
+ // below is scrolling logic up to Jalview 2.8.2\r
+ // if ((av.getStartRes() > end)\r
+ // || (av.getEndRes() < start)\r
+ // || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))\r
+ // {\r
+ // if (start > av.getAlignment().getWidth() - hextent)\r
+ // {\r
+ // start = av.getAlignment().getWidth() - hextent;\r
+ // if (start < 0)\r
+ // {\r
+ // start = 0;\r
+ // }\r
+ //\r
+ // }\r
+ // if (seqIndex > av.getAlignment().getHeight() - vextent)\r
+ // {\r
+ // seqIndex = av.getAlignment().getHeight() - vextent;\r
+ // if (seqIndex < 0)\r
+ // {\r
+ // seqIndex = 0;\r
+ // }\r
+ // }\r
+ // setScrollValues(start, seqIndex);\r
+ // }\r
+ // logic copied from jalview.gui.AlignmentPanel:\r
+ if ((startv = av.getStartRes()) >= start)\r
+ {\r
+ /*\r
+ * Scroll left to make start of search results visible\r
+ */\r
+ setScrollValues(start - 1, seqIndex);\r
+ }\r
+ else if ((endv = av.getEndRes()) <= end)\r
+ {\r
+ /*\r
+ * Scroll right to make end of search results visible\r
+ */\r
+ setScrollValues(startv + 1 + end - endv, seqIndex);\r
+ }\r
+ else if ((starts = av.getStartSeq()) > seqIndex)\r
+ {\r
+ /*\r
+ * Scroll up to make start of search results visible\r
+ */\r
+ setScrollValues(av.getStartRes(), seqIndex);\r
+ }\r
+ else if ((ends = av.getEndSeq()) <= seqIndex)\r
+ {\r
+ /*\r
+ * Scroll down to make end of search results visible\r
+ */\r
+ setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1);\r
+ }\r
+ /*\r
+ * Else results are already visible - no need to scroll\r
+ */\r
+ }\r
+ else\r
+ {\r
+ scrollToWrappedVisible(start);\r
+ }\r
+ if (redrawOverview && overviewPanel != null)\r
+ {\r
+ overviewPanel.setBoxPosition();\r
+ }\r
+ paintAlignment(redrawOverview);\r
+ return true;\r
+ }\r
+\r
+ void scrollToWrappedVisible(int res)\r
+ {\r
+ int cwidth = seqPanel.seqCanvas\r
+ .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);\r
+ if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))\r
+ {\r
+ vscroll.setValue(res / cwidth);\r
+ av.startRes = vscroll.getValue() * cwidth;\r
+ }\r
+ }\r
+\r
+ public OverviewPanel getOverviewPanel()\r
+ {\r
+ return overviewPanel;\r
+ }\r
+\r
+ public void setOverviewPanel(OverviewPanel op)\r
+ {\r
+ overviewPanel = op;\r
+ }\r
+\r
+ public void setAnnotationVisible(boolean b)\r
+ {\r
+ if (!av.getWrapAlignment())\r
+ {\r
+ annotationSpaceFillerHolder.setVisible(b);\r
+ annotationPanelHolder.setVisible(b);\r
+ }\r
+ else\r
+ {\r
+ annotationSpaceFillerHolder.setVisible(false);\r
+ annotationPanelHolder.setVisible(false);\r
+ }\r
+ validate();\r
+ repaint();\r
+ }\r
+\r
+ /**\r
+ * automatically adjust annotation panel height for new annotation whilst\r
+ * ensuring the alignment is still visible.\r
+ */\r
+ public void adjustAnnotationHeight()\r
+ {\r
+ // TODO: display vertical annotation scrollbar if necessary\r
+ // this is called after loading new annotation onto alignment\r
+ if (alignFrame.getSize().height == 0)\r
+ {\r
+ System.out\r
+ .println("adjustAnnotationHeight frame size zero NEEDS FIXING");\r
+ }\r
+ fontChanged();\r
+ validateAnnotationDimensions(true);\r
+ apvscroll.addNotify();\r
+ hscroll.addNotify();\r
+ validate();\r
+ paintAlignment(true);\r
+ }\r
+\r
+ /**\r
+ * Calculate the annotation dimensions and refresh slider values accordingly.\r
+ * Need to do repaints/notifys afterwards.\r
+ */\r
+ protected void validateAnnotationDimensions(boolean adjustPanelHeight)\r
+ {\r
+ int rowHeight = av.getCharHeight();\r
+ int alignmentHeight = rowHeight * av.getAlignment().getHeight();\r
+ int annotationHeight = av.calcPanelHeight();\r
+\r
+ int mheight = annotationHeight;\r
+ Dimension d = sequenceHolderPanel.getSize();\r
+\r
+ int availableHeight = d.height - scalePanelHolder.getHeight();\r
+\r
+ if (adjustPanelHeight)\r
+ {\r
+ /*\r
+ * If not enough vertical space, maximize annotation height while keeping\r
+ * at least two rows of alignment visible\r
+ */\r
+ if (annotationHeight + alignmentHeight > availableHeight)\r
+ {\r
+ annotationHeight = Math.min(annotationHeight, availableHeight - 2\r
+ * rowHeight);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ // maintain same window layout whilst updating sliders\r
+ annotationHeight = annotationPanelHolder.getSize().height;\r
+ }\r
+\r
+ if (availableHeight - annotationHeight < 5)\r
+ {\r
+ annotationHeight = availableHeight;\r
+ }\r
+\r
+ annotationPanel.setSize(new Dimension(d.width, annotationHeight));\r
+ annotationPanelHolder.setSize(new Dimension(d.width, annotationHeight));\r
+ // seqPanelHolder.setSize(d.width, seqandannot - height);\r
+ seqPanel.seqCanvas\r
+ .setSize(d.width, seqPanel.seqCanvas.getSize().height);\r
+\r
+ Dimension e = idPanel.getSize();\r
+ alabels.setSize(new Dimension(e.width, annotationHeight));\r
+ annotationSpaceFillerHolder.setSize(new Dimension(e.width,\r
+ annotationHeight));\r
+\r
+ int s = apvscroll.getValue();\r
+ if (s > mheight - annotationHeight)\r
+ {\r
+ s = 0;\r
+ }\r
+ apvscroll.setValues(s, annotationHeight, 0, mheight);\r
+ annotationPanel.setScrollOffset(apvscroll.getValue(), false);\r
+ alabels.setScrollOffset(apvscroll.getValue(), false);\r
+ }\r
+\r
+ public void setWrapAlignment(boolean wrap)\r
+ {\r
+ av.startSeq = 0;\r
+ av.startRes = 0;\r
+ scalePanelHolder.setVisible(!wrap);\r
+\r
+ hscroll.setVisible(!wrap);\r
+ idwidthAdjuster.setVisible(!wrap);\r
+\r
+ if (wrap)\r
+ {\r
+ annotationPanelHolder.setVisible(false);\r
+ annotationSpaceFillerHolder.setVisible(false);\r
+ }\r
+ else if (av.isShowAnnotation())\r
+ {\r
+ annotationPanelHolder.setVisible(true);\r
+ annotationSpaceFillerHolder.setVisible(true);\r
+ }\r
+\r
+ idSpaceFillerPanel1.setVisible(!wrap);\r
+\r
+ fontChanged(); // This is so that the scalePanel is resized correctly\r
+\r
+ validate();\r
+ sequenceHolderPanel.validate();\r
+ repaint();\r
+\r
+ }\r
+\r
+ int hextent = 0;\r
+\r
+ int vextent = 0;\r
+\r
+ // return value is true if the scroll is valid\r
+ public boolean scrollUp(boolean up)\r
+ {\r
+ if (up)\r
+ {\r
+ if (vscroll.getValue() < 1)\r
+ {\r
+ return false;\r
+ }\r
+ setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);\r
+ }\r
+ else\r
+ {\r
+ if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())\r
+ {\r
+ return false;\r
+ }\r
+ setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);\r
+ }\r
+\r
+ repaint();\r
+ return true;\r
+ }\r
+\r
+ public boolean scrollRight(boolean right)\r
+ {\r
+ if (!right)\r
+ {\r
+ if (hscroll.getValue() < 1)\r
+ {\r
+ return false;\r
+ }\r
+ setScrollValues(hscroll.getValue() - 1, vscroll.getValue());\r
+ }\r
+ else\r
+ {\r
+ if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())\r
+ {\r
+ return false;\r
+ }\r
+ setScrollValues(hscroll.getValue() + 1, vscroll.getValue());\r
+ }\r
+\r
+ repaint();\r
+ return true;\r
+ }\r
+\r
+ public void setScrollValues(int x, int y)\r
+ {\r
+ int width = av.getAlignment().getWidth();\r
+ int height = av.getAlignment().getHeight();\r
+\r
+ if (av.hasHiddenColumns())\r
+ {\r
+ width = av.getColumnSelection().findColumnPosition(width);\r
+ }\r
+ if (x < 0)\r
+ {\r
+ x = 0;\r
+ }\r
+ ;\r
+\r
+ hextent = seqPanel.seqCanvas.getSize().width / av.getCharWidth();\r
+ vextent = seqPanel.seqCanvas.getSize().height / av.getCharHeight();\r
+\r
+ if (hextent > width)\r
+ {\r
+ hextent = width;\r
+ }\r
+\r
+ if (vextent > height)\r
+ {\r
+ vextent = height;\r
+ }\r
+\r
+ if ((hextent + x) > width)\r
+ {\r
+ System.err.println("hextent was " + hextent + " and x was " + x);\r
+\r
+ x = width - hextent;\r
+ }\r
+\r
+ if ((vextent + y) > height)\r
+ {\r
+ y = height - vextent;\r
+ }\r
+\r
+ if (y < 0)\r
+ {\r
+ y = 0;\r
+ }\r
+\r
+ if (x < 0)\r
+ {\r
+ System.err.println("x was " + x);\r
+ x = 0;\r
+ }\r
+\r
+ av.setStartSeq(y);\r
+\r
+ int endSeq = y + vextent;\r
+ if (endSeq > av.getAlignment().getHeight())\r
+ {\r
+ endSeq = av.getAlignment().getHeight();\r
+ }\r
+\r
+ av.setEndSeq(endSeq);\r
+ av.setStartRes(x);\r
+ av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av\r
+ .getCharWidth())) - 1);\r
+\r
+ hscroll.setValues(x, hextent, 0, width);\r
+ vscroll.setValues(y, vextent, 0, height);\r
+\r
+ if (overviewPanel != null)\r
+ {\r
+ overviewPanel.setBoxPosition();\r
+ }\r
+ sendViewPosition();\r
+\r
+ }\r
+\r
+ public void adjustmentValueChanged(AdjustmentEvent evt)\r
+ {\r
+ int oldX = av.getStartRes();\r
+ int oldY = av.getStartSeq();\r
+\r
+ if (evt == null || evt.getSource() == apvscroll)\r
+ {\r
+ annotationPanel.setScrollOffset(apvscroll.getValue(), false);\r
+ alabels.setScrollOffset(apvscroll.getValue(), false);\r
+ // annotationPanel.image=null;\r
+ // alabels.image=null;\r
+ // alabels.repaint();\r
+ // annotationPanel.repaint();\r
+ }\r
+ if (evt == null || evt.getSource() == hscroll)\r
+ {\r
+ int x = hscroll.getValue();\r
+ av.setStartRes(x);\r
+ av.setEndRes(x + seqPanel.seqCanvas.getSize().width\r
+ / av.getCharWidth() - 1);\r
+ }\r
+\r
+ if (evt == null || evt.getSource() == vscroll)\r
+ {\r
+ int offy = vscroll.getValue();\r
+ if (av.getWrapAlignment())\r
+ {\r
+ int rowSize = seqPanel.seqCanvas\r
+ .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);\r
+ av.setStartRes(vscroll.getValue() * rowSize);\r
+ av.setEndRes((vscroll.getValue() + 1) * rowSize);\r
+ }\r
+ else\r
+ {\r
+ av.setStartSeq(offy);\r
+ av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height\r
+ / av.getCharHeight());\r
+ }\r
+ }\r
+\r
+ if (overviewPanel != null)\r
+ {\r
+ overviewPanel.setBoxPosition();\r
+ }\r
+\r
+ int scrollX = av.startRes - oldX;\r
+ int scrollY = av.startSeq - oldY;\r
+\r
+ if (av.getWrapAlignment() || !fastPaint || av.MAC)\r
+ {\r
+ repaint();\r
+ }\r
+ else\r
+ {\r
+ // Make sure we're not trying to draw a panel\r
+ // larger than the visible window\r
+ if (scrollX > av.endRes - av.startRes)\r
+ {\r
+ scrollX = av.endRes - av.startRes;\r
+ }\r
+ else if (scrollX < av.startRes - av.endRes)\r
+ {\r
+ scrollX = av.startRes - av.endRes;\r
+ }\r
+\r
+ idPanel.idCanvas.fastPaint(scrollY);\r
+ seqPanel.seqCanvas.fastPaint(scrollX, scrollY);\r
+\r
+ scalePanel.repaint();\r
+ if (av.isShowAnnotation())\r
+ {\r
+ annotationPanel.fastPaint(av.getStartRes() - oldX);\r
+ }\r
+ }\r
+ sendViewPosition();\r
+\r
+ /*\r
+ * If there is one, scroll the (Protein/cDNA) complementary alignment to\r
+ * match, unless we are ourselves doing that.\r
+ */\r
+ if (isFollowingComplementScroll())\r
+ {\r
+ setFollowingComplementScroll(false);\r
+ }\r
+ else\r
+ {\r
+ AlignmentPanel ap = getComplementPanel();\r
+ av.scrollComplementaryAlignment(ap);\r
+ }\r
+\r
+ }\r
+\r
+ /**\r
+ * A helper method to return the AlignmentPanel in the other (complementary)\r
+ * half of a SplitFrame view. Returns null if not in a SplitFrame.\r
+ * \r
+ * @return\r
+ */\r
+ private AlignmentPanel getComplementPanel()\r
+ {\r
+ AlignmentPanel ap = null;\r
+ if (alignFrame != null)\r
+ {\r
+ SplitFrame sf = alignFrame.getSplitFrame();\r
+ if (sf != null)\r
+ {\r
+ AlignFrame other = sf.getComplement(alignFrame);\r
+ if (other != null)\r
+ {\r
+ ap = other.alignPanel;\r
+ }\r
+ }\r
+ }\r
+ return ap;\r
+ }\r
+\r
+ /**\r
+ * Follow a scrolling change in the (cDNA/Protein) complementary alignment.\r
+ * The aim is to keep the two alignments 'lined up' on their centre columns.\r
+ * \r
+ * @param sr\r
+ * holds mapped region(s) of this alignment that we are scrolling\r
+ * 'to'; may be modified for sequence offset by this method\r
+ * @param seqOffset\r
+ * the number of visible sequences to show above the mapped region\r
+ */\r
+ protected void scrollToCentre(SearchResults sr, int seqOffset)\r
+ {\r
+ /*\r
+ * To avoid jumpy vertical scrolling (if some sequences are gapped or not\r
+ * mapped), we can make the scroll-to location a sequence above the one\r
+ * actually mapped.\r
+ */\r
+ SequenceI mappedTo = sr.getResultSequence(0);\r
+ List<SequenceI> seqs = av.getAlignment().getSequences();\r
+\r
+ /*\r
+ * This is like AlignmentI.findIndex(seq) but here we are matching the\r
+ * dataset sequence not the aligned sequence\r
+ */\r
+ int sequenceIndex = 0;\r
+ boolean matched = false;\r
+ for (SequenceI seq : seqs)\r
+ {\r
+ if (mappedTo == seq.getDatasetSequence())\r
+ {\r
+ matched = true;\r
+ break;\r
+ }\r
+ sequenceIndex++;\r
+ }\r
+ if (!matched)\r
+ {\r
+ return; // failsafe, shouldn't happen\r
+ }\r
+ sequenceIndex = Math.max(0, sequenceIndex - seqOffset);\r
+ sr.getResults().get(0)\r
+ .setSequence(av.getAlignment().getSequenceAt(sequenceIndex));\r
+\r
+ /*\r
+ * Scroll to position but centring the target residue. Also set a state flag\r
+ * to prevent adjustmentValueChanged performing this recursively.\r
+ */\r
+ setFollowingComplementScroll(true);\r
+ scrollToPosition(sr, true, true);\r
+ }\r
+\r
+ private void sendViewPosition()\r
+ {\r
+ StructureSelectionManager.getStructureSelectionManager(av.applet)\r
+ .sendViewPosition(this, av.startRes, av.endRes, av.startSeq,\r
+ av.endSeq);\r
+ }\r
+\r
+ /**\r
+ * Repaint the alignment and annotations, and, optionally, any overview window\r
+ */\r
+ public void paintAlignment(boolean updateOverview)\r
+ {\r
+ final AnnotationSorter sorter = new AnnotationSorter(getAlignment(),\r
+ av.isShowAutocalculatedAbove());\r
+ sorter.sort(getAlignment().getAlignmentAnnotation(),\r
+ av.getSortAnnotationsBy());\r
+ repaint();\r
+\r
+ if (updateOverview)\r
+ {\r
+ StructureSelectionManager.getStructureSelectionManager(av.applet)\r
+ .sequenceColoursChanged(this);\r
+\r
+ if (overviewPanel != null)\r
+ {\r
+ overviewPanel.updateOverviewImage();\r
+ }\r
+ }\r
+ }\r
+\r
+ public void update(Graphics g)\r
+ {\r
+ paint(g);\r
+ }\r
+\r
+ public void paint(Graphics g)\r
+ {\r
+ invalidate();\r
+ Dimension d = idPanel.idCanvas.getSize();\r
+ final int canvasHeight = seqPanel.seqCanvas.getSize().height;\r
+ if (canvasHeight != d.height)\r
+ {\r
+ idPanel.idCanvas.setSize(d.width, canvasHeight);\r
+ }\r
+\r
+ if (av.getWrapAlignment())\r
+ {\r
+ int maxwidth = av.getAlignment().getWidth();\r
+\r
+ if (av.hasHiddenColumns())\r
+ {\r
+ maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;\r
+ }\r
+\r
+ int canvasWidth = seqPanel.seqCanvas\r
+ .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);\r
+\r
+ if (canvasWidth > 0)\r
+ {\r
+ int max = maxwidth / canvasWidth;\r
+ vscroll.setMaximum(1 + max);\r
+ vscroll.setUnitIncrement(1);\r
+ vscroll.setVisibleAmount(1);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ setScrollValues(av.getStartRes(), av.getStartSeq());\r
+ }\r
+\r
+ seqPanel.seqCanvas.repaint();\r
+ idPanel.idCanvas.repaint();\r
+ if (!av.getWrapAlignment())\r
+ {\r
+ if (av.isShowAnnotation())\r
+ {\r
+ alabels.repaint();\r
+ annotationPanel.repaint();\r
+ }\r
+ scalePanel.repaint();\r
+ }\r
+\r
+ }\r
+\r
+ protected JPanel sequenceHolderPanel = new JPanel();\r
+\r
+ protected JScrollBar vscroll = new JScrollBar();\r
+\r
+ protected JScrollBar hscroll = new JScrollBar();\r
+\r
+ protected JPanel seqPanelHolder = new JPanel();\r
+\r
+ protected JPanel scalePanelHolder = new JPanel();\r
+\r
+ protected JPanel idPanelHolder = new JPanel();\r
+\r
+ protected JPanel idSpaceFillerPanel1 = new JPanel();\r
+\r
+ public JPanel annotationSpaceFillerHolder = new JPanel();\r
+\r
+ protected JPanel hscrollFillerPanel = new JPanel();\r
+\r
+ JPanel annotationPanelHolder = new JPanel();\r
+\r
+ protected JScrollBar apvscroll = new JScrollBar();\r
+\r
+ /*\r
+ * Flag set while scrolling to follow complementary cDNA/protein scroll. When\r
+ * true, suppresses invoking the same method recursively.\r
+ */\r
+ private boolean followingComplementScroll;\r
+\r
+ private void jbInit() throws Exception\r
+ {\r
+ // idPanelHolder.setPreferredSize(new Dimension(70, 10));\r
+ this.setLayout(new BorderLayout());\r
+\r
+ // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));\r
+ sequenceHolderPanel.setLayout(new BorderLayout());\r
+ seqPanelHolder.setLayout(new BorderLayout());\r
+ scalePanelHolder.setBackground(Color.white);\r
+\r
+ // scalePanelHolder.setPreferredSize(new Dimension(10, 30));\r
+ scalePanelHolder.setLayout(new BorderLayout());\r
+ idPanelHolder.setLayout(new BorderLayout());\r
+ idSpaceFillerPanel1.setBackground(Color.white);\r
+\r
+ // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));\r
+ idSpaceFillerPanel1.setLayout(new BorderLayout());\r
+ annotationSpaceFillerHolder.setBackground(Color.white);\r
+\r
+ // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));\r
+ annotationSpaceFillerHolder.setLayout(new BorderLayout());\r
+ hscroll.setOrientation(JScrollBar.HORIZONTAL);\r
+\r
+ JPanel hscrollHolder = new JPanel();\r
+ hscrollHolder.setLayout(new BorderLayout());\r
+ hscrollFillerPanel.setBackground(Color.white);\r
+ apvscroll.setOrientation(JScrollBar.VERTICAL);\r
+ apvscroll.setVisible(true);\r
+ apvscroll.addAdjustmentListener(this);\r
+\r
+ annotationPanelHolder.setBackground(Color.white);\r
+ annotationPanelHolder.setLayout(new BorderLayout());\r
+ annotationPanelHolder.add(apvscroll, BorderLayout.EAST);\r
+ // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));\r
+ hscrollHolder.setBackground(Color.white);\r
+\r
+ // annotationScroller.setPreferredSize(new Dimension(10, 80));\r
+ // this.setPreferredSize(new Dimension(220, 166));\r
+ seqPanelHolder.setBackground(Color.white);\r
+ idPanelHolder.setBackground(Color.white);\r
+ sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);\r
+ sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);\r
+ seqPanelHolder.add(vscroll, BorderLayout.EAST);\r
+\r
+ // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);\r
+ this.add(idPanelHolder, BorderLayout.WEST);\r
+ idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);\r
+ idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);\r
+ this.add(hscrollHolder, BorderLayout.SOUTH);\r
+ hscrollHolder.add(hscroll, BorderLayout.CENTER);\r
+ hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);\r
+ this.add(sequenceHolderPanel, BorderLayout.CENTER);\r
+ }\r
+\r
+ /**\r
+ * hides or shows dynamic annotation rows based on groups and av state flags\r
+ */\r
+ public void updateAnnotation()\r
+ {\r
+ updateAnnotation(false);\r
+ }\r
+\r
+ public void updateAnnotation(boolean applyGlobalSettings)\r
+ {\r
+ updateAnnotation(applyGlobalSettings, false);\r
+ }\r
+\r
+ public void updateAnnotation(boolean applyGlobalSettings,\r
+ boolean preserveNewGroupSettings)\r
+ {\r
+ av.updateGroupAnnotationSettings(applyGlobalSettings,\r
+ preserveNewGroupSettings);\r
+ adjustAnnotationHeight();\r
+ }\r
+\r
+ @Override\r
+ public AlignmentI getAlignment()\r
+ {\r
+ return av.getAlignment();\r
+ }\r
+\r
+ @Override\r
+ public String getViewName()\r
+ {\r
+ return getName();\r
+ }\r
+\r
+ @Override\r
+ public StructureSelectionManager getStructureSelectionManager()\r
+ {\r
+ return StructureSelectionManager\r
+ .getStructureSelectionManager(av.applet);\r
+ }\r
+\r
+ @Override\r
+ public void raiseOOMWarning(String string, OutOfMemoryError error)\r
+ {\r
+ // TODO: JAL-960\r
+ System.err.println("Out of memory whilst '" + string + "'");\r
+ error.printStackTrace();\r
+ }\r
+\r
+ /**\r
+ * Set a flag to say we are scrolling to follow a (cDNA/protein) complement.\r
+ * \r
+ * @param b\r
+ */\r
+ protected void setFollowingComplementScroll(boolean b)\r
+ {\r
+ this.followingComplementScroll = b;\r
+ }\r
+\r
+ protected boolean isFollowingComplementScroll()\r
+ {\r
+ return this.followingComplementScroll;\r
+ }\r
+\r
+}\r
git://source.jalview.org / jalviewjs.git / blobdiff