private void removePagePanel(PagePanel pagePanel) {
pagePanel.removePagePanelListener(this);
remove(pagePanel);
pagePanel.dispose();
pagePanel.raisePagePanelEvent(
PagePanelEvent.createPageHidden(pagePanel, pagePanel.getPage()));
}
/**
* @param x x coordinate in PDF units
* @param y y coordinate in PDF units
* @param centre if true, centre this location in the viewport, otherwise cause it to be displayed
* at the top left of the viewport.
*/
private void ensureVisible(PDFPage page, double x, double y, boolean centre) {
PDFPage oldPage = view.getPage();
Collection<PagePanel> oldPagePanels = view.getPagePanels();
view.setPage(page, false);
Rectangle pageRect = view.getPageRectangle(page);
if (pageRect != null) {
Rectangle2D crop = PagePanel.getFullPageView(page);
int xoffset = pageRect.x, yoffset = pageRect.y;
if (x > crop.getMinX()) { // Also confirms !NaN
xoffset += pointsToPixels((float) (Math.min(crop.getMaxX(), x) - crop.getMinX()));
}
if (y < crop.getMaxY()) { // Also confirms !NaN
yoffset += pointsToPixels((float) (crop.getHeight() - Math.max(0, y - crop.getMinY())));
}
JScrollBar hsb = scrollPane.getHorizontalScrollBar();
JScrollBar vsb = scrollPane.getVerticalScrollBar();
if (centre) {
xoffset -= hsb.getVisibleAmount() / 2;
yoffset -= vsb.getVisibleAmount() / 2;
}
if (getPagePanel() != null && getPagePanel().getClip() != null) {
hsb.setValue(xoffset); // Don't want to smooth scroll if we're clipping
vsb.setValue(yoffset); // the page rectangles.
} else {
smoothScroll(xoffset, yoffset, hsb, vsb);
}
}
if (page != oldPage) {
DocumentPanel docpanel = getDocumentPanel();
if (docpanel != null) {
DocumentPanelEvent dpe = DocumentPanelEvent.createPageChanged(docpanel);
dpe.setPreviousPage(oldPage);
docpanel.raiseDocumentPanelEvent(dpe);
}
Collection<PagePanel> newPagePanels = view.getPagePanels();
for (Iterator<PagePanel> i = oldPagePanels.iterator(); i.hasNext(); ) {
PagePanel oldPagePanel = i.next();
if (!newPagePanels.contains(oldPagePanel)) {
oldPagePanel.raisePagePanelEvent(PagePanelEvent.createPageHidden(oldPagePanel, oldPage));
}
}
for (Iterator<PagePanel> i = newPagePanels.iterator(); i.hasNext(); ) {
PagePanel newPagePanel = i.next();
if (!oldPagePanels.contains(newPagePanel)) {
newPagePanel.raisePagePanelEvent(PagePanelEvent.createPageVisible(newPagePanel, page));
}
}
}
}
public void setPage(PDFPage page, double x, double y, double zoom) {
if (page.getPDF() != pdf) {
throw new IllegalArgumentException("Page is from a different PDF");
}
setZoom((float) zoom);
Rectangle2D crop = PagePanel.getFullPageView(page);
ensureVisible(page, crop.getMinX() + x, crop.getMaxY() - y, false);
}
/** @page the page to display */
private PagePanel addPagePanel(PDFPage page) {
PagePanel pagePanel = new PagePanel();
pagePanel.setViewport(DualPageDocumentViewport.this);
pagePanel.setParser(getDocumentPanel().getParser());
if (hints != null) {
pagePanel.setRenderingHints(hints);
}
pagePanel.addPagePanelListener(this);
pagePanel.addPagePanelInteractionListener(this);
pagePanel.addMouseListener(this);
pagePanel.addMouseMotionListener(this);
add(pagePanel);
pagePanel.raisePagePanelEvent(PagePanelEvent.createPageVisible(pagePanel, page));
return pagePanel;
}
public void doLayout() {
Dimension size = getSize();
if (size.width == 0 || size.height == 0) {
return;
}
Dimension viewport = getPreferredSize();
int cx = Math.max(size.width / 2, 0);
int cy = Math.max(size.height / 2, 0);
float dpi = (float) zoom * Util.getScreenResolution(this);
if (leftPage != null) {
leftPageRect.x = cx - (viewport.width / 2) + margin;
leftPageRect.y = cy - (leftPageRect.height / 2);
leftPagePanel.setBounds(leftPageRect);
leftPagePanel.setPage(leftPage, leftFullPageRect, dpi, null);
}
if (rightPage != null) {
rightPageRect.x = cx + (viewport.width / 2) - rightPageRect.width - margin;
rightPageRect.y = cy - (rightPageRect.height / 2);
rightPagePanel.setBounds(rightPageRect);
rightPagePanel.setPage(rightPage, rightFullPageRect, dpi, null);
}
}
void setRightPage(PDFPage page) {
if (rightPagePanel != null) {
removePagePanel(rightPagePanel);
}
rightPage = page;
if (page == null) {
rightPagePanel = null;
rightPageRect = null;
rightFullPageRect = null;
} else {
rightFullPageRect = (Rectangle2D.Float) PagePanel.getFullPageView(page);
rightPageRect = new Rectangle();
rightPagePanel = addPagePanel(page);
}
}
void setLeftPage(PDFPage page) {
if (leftPagePanel != null) {
removePagePanel(leftPagePanel);
}
leftPage = page;
if (page == null) {
leftPagePanel = null;
leftPageRect = null;
leftFullPageRect = null;
} else {
leftFullPageRect = (Rectangle2D.Float) PagePanel.getFullPageView(page);
leftPageRect = new Rectangle();
leftPagePanel = addPagePanel(page);
}
}
public float getTargetZoom(int zoommode, PDFPage page) {
float outzoom = zoom;
if (page != null) {
int pagenumber = page.getPageNumber() - 1;
int pagecount = pdf.getNumberOfPages();
boolean isOdd = (pagenumber % 2) == 0; // even pages have odd numbers :)
boolean onRight = handedness == ODD_PAGES_ON_RIGHT ? isOdd : !isOdd;
PDFPage leftPage, rightPage;
Rectangle2D.Float leftPageRect = null, rightPageRect = null;
if (onRight) {
leftPage = (pagenumber > 0) ? pdf.getPage(pagenumber - 1) : null;
rightPage = page;
} else {
leftPage = page;
rightPage = (pagenumber < (pagecount - 1)) ? pdf.getPage(pagenumber + 1) : null;
}
if (leftPage != null) {
leftPageRect = (Rectangle2D.Float) PagePanel.getFullPageView(leftPage);
}
if (rightPage != null) {
rightPageRect = (Rectangle2D.Float) PagePanel.getFullPageView(rightPage);
}
if (leftPageRect == null) {
leftPageRect = (Rectangle2D.Float) rightPageRect.clone();
}
if (rightPageRect == null) {
rightPageRect = (Rectangle2D.Float) leftPageRect.clone();
}
JScrollBar hsb = scrollPane.getHorizontalScrollBar();
JScrollBar vsb = scrollPane.getVerticalScrollBar();
float prw = leftPageRect.width + rightPageRect.width;
float prh = Math.max(leftPageRect.height, rightPageRect.height);
Dimension size = getSize();
float w =
(float) Math.ceil(prw * Util.getScreenResolution(this) / 72)
+ (margin * 4)
+ interpagemargin
+ vsb.getWidth();
float h =
(float) Math.ceil(prh * Util.getScreenResolution(this) / 72)
+ (margin * 2)
+ hsb.getHeight();
switch (zoommode) {
case ZOOM_FITWIDTH:
outzoom = (float) size.width / w;
break;
case ZOOM_FITHEIGHT:
outzoom = (float) size.height / h;
break;
case ZOOM_FIT:
float zw = (float) size.width / w;
float zh = (float) size.height / h;
outzoom = zw < zh ? zw : zh;
break;
default:
outzoom = zoom == 0 ? 1 : zoom;
}
}
return outzoom;
}
