import java.util.Arrays;

import org.eclipse.gef4.fx.nodes.InfiniteCanvas;

import javafx.application.Application;
import javafx.geometry.Orientation;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.Separator;
import javafx.scene.control.Slider;
import javafx.scene.layout.AnchorPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.paint.CycleMethod;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

public class InfiniteCanvasFixedSizeSnippet extends Application {

	public static void main(String[] args) {
		launch();
	}

	@Override
	public void start(Stage primaryStage) throws Exception {
		// create scene
		AnchorPane root = new AnchorPane();
		Scene scene = new Scene(root, 500, 500);
		root.setStyle("-fx-font-size: 12pt;");

		// create width slider
		Label widthLabel = new Label("MaxWidth:");
		widthLabel.setStyle("-fx-text-fill: white;");
		Slider widthSlider = new Slider(100, 500, 300);
		widthSlider.setOrientation(Orientation.HORIZONTAL);
		widthSlider.setMaxWidth(Double.MAX_VALUE);
		HBox widthBox = new HBox();
		HBox.setHgrow(widthSlider, Priority.ALWAYS);
		widthBox.setMaxWidth(Double.MAX_VALUE);
		widthBox.getChildren().addAll(widthLabel, widthSlider);

		// create height sldier
		Label heightLabel = new Label("MaxHeight:");
		heightLabel.setStyle("-fx-text-fill: white;");
		Slider heightSlider = new Slider(100, 500, 300);
		heightSlider.setOrientation(Orientation.HORIZONTAL);
		heightSlider.setMaxWidth(Double.MAX_VALUE);
		HBox heightBox = new HBox();
		HBox.setHgrow(heightSlider, Priority.ALWAYS);
		heightBox.setMaxWidth(Double.MAX_VALUE);
		heightBox.getChildren().addAll(heightLabel, heightSlider);

		// assemble in controls box
		VBox controlsBox = new VBox();
		controlsBox.setMaxWidth(Double.MAX_VALUE);
		Label canvasLabel = new Label("InfiniteCanvas:");
		canvasLabel.setStyle("-fx-text-fill: white;");
		controlsBox.getChildren().addAll(widthBox, heightBox,
				new Separator(Orientation.HORIZONTAL), canvasLabel);

		// create canvas
		InfiniteCanvas canvas = new InfiniteCanvas();
		canvas.setShowGrid(false);
		canvas.setClipContent(true);
		canvas.maxWidthProperty().bind(widthSlider.valueProperty());
		canvas.maxHeightProperty().bind(heightSlider.valueProperty());
		for (int i = 0; i < 10; i++) {
			Rectangle rectangle = new Rectangle(50, 50, Color.RED);
			rectangle.setTranslateX(i * 50);
			rectangle.setTranslateY(i * 50);
			canvas.getContentGroup().getChildren().add(rectangle);
		}

		// create background
		Rectangle background = new Rectangle();
		background.setWidth(500);
		background.setHeight(500);
		background.setFill(new LinearGradient(0, 0, 1, 1, true,
				CycleMethod.REFLECT, Arrays.asList(new Stop(0d, Color.GREEN),
						new Stop(1d, Color.CYAN))));

		// arrange in root pane
		root.getChildren().addAll(background, controlsBox, canvas);

		// stretch controls
		AnchorPane.setLeftAnchor(controlsBox, 0d);
		AnchorPane.setRightAnchor(controlsBox, 0d);

		// position canvas below controls
		canvas.translateYProperty().bind(controlsBox.heightProperty());

		primaryStage.setScene(scene);
		primaryStage.sizeToScene();
		primaryStage.setTitle("InfinteCanvas Fixed Size");
		primaryStage.show();
	}

}

  @PostConstruct
  public void postConstruct(BorderPane container) {
    Injector injector = Guice.createInjector(createGuiceModule());
    FXDomain domain = injector.getInstance(FXDomain.class);
    FXViewer viewer = domain.getAdapter(FXViewer.class);
    VBox palette = new VBox();
    palette.setMaxWidth(180);
    InfiniteCanvas canvas = viewer.getCanvas();
    SplitPane sp = new SplitPane(palette, canvas);
    container.setCenter(sp);
    canvas.setClipContent(true);
    canvas.setHorizontalScrollBarPolicy(ScrollBarPolicy.ALWAYS);
    canvas.setVerticalScrollBarPolicy(ScrollBarPolicy.ALWAYS);
    canvas.sceneProperty().addListener((observable, oldValue, newValue) -> {
      if (canvas.getScene() != null) {
        domain.activate();
        try {
          viewer.getAdapter(ContentModel.class).getContents().setAll(createContents());
          canvas.setMaxHeight(map.getHeight());
          canvas.setMaxWidth(map.getWidth());
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    });
  }

import org.eclipse.gef4.fx.nodes.InfiniteCanvas;
import org.eclipse.gef4.mvc.fx.policies.FXChangeViewportPolicy;
import org.eclipse.gef4.mvc.fx.viewer.FXViewer;

import javafx.geometry.Bounds;

public class ContentRestrictedFXChangeViewportPolicy extends FXChangeViewportPolicy {

	@Override
	protected void locallyExecuteOperation() {
		// determine current translation
		double tx = getChangeViewportOperation().getNewHorizontalScrollOffset();
		double ty = getChangeViewportOperation().getNewVerticalScrollOffset();

		// determine direction of change
		double dx = tx - getChangeViewportOperation().getInitialHorizontalScrollOffset();
		double dy = ty - getChangeViewportOperation().getInitialVerticalScrollOffset();

		// determine scrollable bounds
		FXViewer viewer = (FXViewer) getHost().getRoot().getViewer();
		InfiniteCanvas canvas = viewer.getCanvas();
		Bounds scrollableBounds = canvas.getScrollableBounds();

		// compute content restricted translation range
		// XXX: Scrolling is implemented by translating the scene graph node
		// that holds all children. Therefore, scrolling to the right is
		// actually moving this node to the left, and vice versa.
		double contentRestrictedMinTranslateX = -scrollableBounds.getMinX();
		double contentRestrictedMinTranslateY = -scrollableBounds.getMinY();
		// XXX: The size of the canvas is the visible area which has to be
		// subtracted from the scrollable bounds to yield the translation range.
		double contentRestrictedMaxTranslateX = -(scrollableBounds.getMaxX() - canvas.getWidth());
		double contentRestrictedMaxTranslateY = -(scrollableBounds.getMaxY() - canvas.getHeight());

		// sort content restricted bounds numerically
		if (contentRestrictedMinTranslateX > contentRestrictedMaxTranslateX) {
			double tmp = contentRestrictedMinTranslateX;
			contentRestrictedMinTranslateX = contentRestrictedMaxTranslateX;
			contentRestrictedMaxTranslateX = tmp;
		}
		if (contentRestrictedMinTranslateY > contentRestrictedMaxTranslateY) {
			double tmp = contentRestrictedMinTranslateY;
			contentRestrictedMinTranslateY = contentRestrictedMaxTranslateY;
			contentRestrictedMaxTranslateY = tmp;
		}

		// do not allow translation when the corresponding scrollbar is
		// invisible, and otherwise restrict the translation values to the
		// scrollable bounds
		if (!canvas.getHorizontalScrollBar().isVisible()) {
			tx = getChangeViewportOperation().getInitialHorizontalScrollOffset();
		} else if (tx < contentRestrictedMinTranslateX || tx > contentRestrictedMaxTranslateX) {
			// restrict to minimum/maximum depending on direction
			if (dx < 0) {
				tx = contentRestrictedMinTranslateX;
			} else {
				tx = contentRestrictedMaxTranslateX;
			}
		}
		if (!canvas.getVerticalScrollBar().isVisible()) {
			ty = getChangeViewportOperation().getInitialVerticalScrollOffset();
		} else if (ty < contentRestrictedMinTranslateY || ty > contentRestrictedMaxTranslateY) {
			// restrict to minimum/maximum depending on direction
			if (dy < 0) {
				ty = contentRestrictedMinTranslateY;
			} else {
				ty = contentRestrictedMaxTranslateY;
			}
		}

		// change operation values
		getChangeViewportOperation().setNewHorizontalScrollOffset(tx);
		getChangeViewportOperation().setNewVerticalScrollOffset(ty);

		// execute
		super.locallyExecuteOperation();
	}

}

import org.eclipse.gef4.geometry.planar.Dimension;

import javafx.scene.input.ScrollEvent;

public class FXPanOnScrollPolicy extends FXPanOrZoomOnScrollPolicy {

	@Override
	protected Dimension computeDelta(ScrollEvent event) {
		// let base class compute delta (includes swapping of direction)
		Dimension delta = super.computeDelta(event);
		// adjust delta for diagonal movement
		if (isDiagonal(event)) {
			boolean isSwapped = isSwapDirection(event);
			if (delta.width == 0) {
				delta.width = isSwapped ? -delta.height : delta.height;
			} else if (delta.height == 0) {
				delta.width = isSwapped ? -delta.width : delta.width;
			}
		}
		return delta;
	}

	/**
	 * Returns <code>true</code> if the pan direction should be diagonal for the
	 * given {@link ScrollEvent}. Otherwise returns <code>false</code>.
	 *
	 * @param event
	 *            The {@link ScrollEvent} in question.
	 * @return <code>true</code> if panning should be diagonal for the given
	 *         event, otherwise <code>false</code>.
	 */
	protected boolean isDiagonal(ScrollEvent event) {
		// enable diagonal movement when Alt is pressed
		return event.isAltDown();
	}

	@Override
	protected boolean isPan(ScrollEvent event) {
		// only disable panning when Shift is pressed
		return !event.isShiftDown();
	}

	@Override
	protected boolean isSwapDirection(ScrollEvent event) {
		// swap direction when Ctrl is pressed
		return event.isControlDown();
	}

	@Override
	protected boolean isZoom(ScrollEvent event) {
		// disable zooming
		return false;
	}

}

    binder().bind(new TypeLiteral<IContentPartFactory<Node>>() {
    }).toInstance(new MapPartFactory());