View difference between Paste ID: ws8XYQn6 and Ahycv2r2

-package com.javadaemon.teaclient.ui;
+
 import com.badlogic.gdx.graphics.g2d.Batch;
 import com.badlogic.gdx.scenes.scene2d.Actor;
 import com.badlogic.gdx.scenes.scene2d.InputEvent;
 import com.badlogic.gdx.scenes.scene2d.InputListener;
 import com.badlogic.gdx.scenes.scene2d.Stage;
 import com.badlogic.gdx.scenes.scene2d.Touchable;
 import com.badlogic.gdx.scenes.scene2d.ui.Skin;
 import com.badlogic.gdx.scenes.scene2d.ui.Table;
 import com.badlogic.gdx.scenes.scene2d.utils.Align;
 import com.badlogic.gdx.scenes.scene2d.utils.Drawable;
 
 /**
  * This is very much like a regular Table, although it has some extra features.
  * It is movable on a Stage, and can be resized by dragging.
  * It can also act modal if needed, and be locked to be inside of the Stage if needed.
  *
  * This is basicly Window from scene2d.ui, with a few modifications.
  *
  * @author Mads Peter Horndrup
  */
 public class MovableTable extends Table {
 
 	/** Different flags to define different behaviors */
 	private boolean isModal, isResizable, isMovable;
 
 	/** Maximum pixels from the border where the MovableWindow can be resized */
 	private int resizeBorder = 8;
 
 	/** Are we currently resizing or moving the MovableWindow?? */
 	private boolean dragging;
 
 	/** Should we make sure the MovableWindow stays inside the Viewport?? */
 	private boolean keepWithinStage;
 
 	/** What Actors allow the MovableWindow to be dragged */
 	protected Actor[] dragActors;
 
 	private MovableTableStyle style;
 
 	/** Used to indicate that side of the MovableWindow that is being resized, and if it's being moved */
 	static private final int MOVE = 1 << 5;
 
 	public MovableTable(Skin skin) {
 		this(skin.get(MovableTableStyle.class));
 		setSkin(skin);
 	}
 
 	public MovableTable(Skin skin, String styleName) {
 		this(skin.get(styleName, MovableTableStyle.class));
 		setSkin(skin);
 	}
 
 	public MovableTable(MovableTableStyle closeableWindowStyle) {
 		setTouchable(Touchable.enabled);
 		setClip(true);
 		setStyle(closeableWindowStyle);
 		setWidth(150);
 		setHeight(150);
 		setMovable(true);
 		setResizable(false);
 		setKeepWithinStage(true);
 
 		dragActors = new Actor[1];
 		dragActors[0] = this;
 
 		addCaptureListener(new InputListener() {
 			public boolean touchDown(InputEvent event, float x, float y,
 					int pointer, int button) {
 				toFront();
 				return false;
 			}
 		});
 		addListener(new InputListener() {
 			int edge;
 			float startX, startY, lastX, lastY;
 
 			public boolean touchDown(InputEvent event, float x, float y,
 					int pointer, int button) {
 				Actor hitActor = hit(x,y,true);
 				boolean success = false;
 				for (Actor a : getDraggableRegions()) {
 					if (hitActor.equals(a)) {
 						success = true;
 					}
 				}
 				if (!success) {
 					return false;
 				}
 				if (button == Input.Buttons.LEFT) {
 					int border = resizeBorder;
 					float width = getWidth(), height = getHeight();
 					edge = 0;
 					if (isResizable) {
 						if (x < border)
 							edge |= Align.left;
 						if (x > width - border)
 							edge |= Align.right;
 						if (y < border)
 							edge |= Align.bottom;
 						if (y > height - border)
 							edge |= Align.top;
 						if (edge != 0)
 							border += 25;
 						if (x < border)
 							edge |= Align.left;
 						if (x > width - border)
 							edge |= Align.right;
 						if (y < border)
 							edge |= Align.bottom;
 						if (y > height - border)
 							edge |= Align.top;
 					}
 					if (isMovable
 							&& edge == 0 	// We are not resizing!
 							&& y <= height	// Inside the Window
 							&& y >= 0
 							&& x >= 0
 							&& x <= width)
 						edge = MOVE;
 					dragging = edge != 0;
 					startX = x;
 					startY = y;
 					lastX = x;
 					lastY = y;
 				}
 				return edge != 0 || isModal;
 			}
 
 			public void touchUp(InputEvent event, float x, float y,
 					int pointer, int button) {
 				dragging = false;
 			}
 
 			public void touchDragged(InputEvent event, float x, float y,
 					int pointer) {
 				if (!dragging)
 					return;
 				float width = getWidth(), height = getHeight();
 				float windowX = getX(), windowY = getY();
 
 				float minWidth = getMinWidth(), maxWidth = getMaxWidth();
 				float minHeight = getMinHeight(), maxHeight = getMaxHeight();
 				Stage stage = getStage();
 				boolean clampPosition = keepWithinStage
 						&& getParent() == stage.getRoot();
 
 				if ((edge & MOVE) != 0) { // We are moving!
 					float amountX = x - startX, amountY = y - startY;
 					windowX += amountX;
 					windowY += amountY;
 				}
 				if ((edge & Align.left) != 0) { // We are resizing!
 					float amountX = x - startX;
 					if (width - amountX < minWidth)
 						amountX = -(minWidth - width);
 					if (clampPosition && windowX + amountX < 0)
 						amountX = -windowX;
 					width -= amountX;
 					windowX += amountX;
 				}
 				if ((edge & Align.bottom) != 0) {
 					float amountY = y - startY;
 					if (height - amountY < minHeight)
 						amountY = -(minHeight - height);
 					if (clampPosition && windowY + amountY < 0)
 						amountY = -windowY;
 					height -= amountY;
 					windowY += amountY;
 				}
 				if ((edge & Align.right) != 0) {
 					float amountX = x - lastX;
 					if (width + amountX < minWidth)
 						amountX = minWidth - width;
 					if (clampPosition
 							&& windowX + width + amountX > stage.getWidth())
 						amountX = stage.getWidth() - windowX - width;
 					width += amountX;
 				}
 				if ((edge & Align.top) != 0) {
 					float amountY = y - lastY;
 					if (height + amountY < minHeight)
 						amountY = minHeight - height;
 					if (clampPosition
 							&& windowY + height + amountY > stage.getHeight())
 						amountY = stage.getHeight() - windowY - height;
 					height += amountY;
 				}
 				lastX = x;
 				lastY = y;
 				setBounds(Math.round(windowX), Math.round(windowY),
 						Math.round(width), Math.round(height));
 			}
 
 			public boolean mouseMoved(InputEvent event, float x, float y) {
 				return isModal;
 			}
 
 			public boolean scrolled(InputEvent event, float x, float y,
 					int amount) {
 				return isModal;
 			}
 
 			public boolean keyDown(InputEvent event, int keycode) {
 				return isModal;
 			}
 
 			public boolean keyUp(InputEvent event, int keycode) {
 				return isModal;
 			}
 
 			public boolean keyTyped(InputEvent event, char character) {
 				return isModal;
 			}
 		});
 	}
 
 	/**
 	 * Checks if the Window is within the Stage. If not, it is pushed inside.
 	 */
 	private void keepWithinStage () {
 		if (!keepWithinStage) return;
 		Stage stage = getStage();
 		if (getParent() == stage.getRoot()) {
 			float parentWidth = stage.getWidth();
 			float parentHeight = stage.getHeight();
 			if (getX() < 0) setX(0);
 			if (getRight() > parentWidth) setX(parentWidth - getWidth());
 			if (getY() < 0) setY(0);
 			if (getTop() > parentHeight) setY(parentHeight - getHeight());
 		}
 	}
 
 	/**
 	 * @return	The Actor that was hit first.
 	 */
 	public Actor hit (float x, float y, boolean touchable) {
 		Actor hit = super.hit(x, y, touchable);
 		if (hit == null && isModal && (!touchable || getTouchable() == Touchable.enabled)) return this;
 		return hit;
 	}
 
 	/**
 	 * This method is used to determine what Actors can be clicked to drag the dialog.
 	 * This is to prevent dragging inside the content of the MovableWindow.
 	 * @return	An Array of Actors that can be used to drag the MovableWindow.
 	 */
 	protected Actor[] getDraggableRegions() {
 		return dragActors;
 	}
 
 	/**
 	 * Renders the beautiful Table.
 	 */
 	public void draw(Batch batch, float parentAlpha) {
 		keepWithinStage();
 		super.draw(batch, parentAlpha);
 	}
 
 	public void setStyle(MovableTableStyle style) {
 		if (style == null) throw new IllegalArgumentException("style cannot be null.");
 		this.style = style;
 		setBackground(style.background);
 		invalidateHierarchy(); // This one is questionable!
 	}
 
 	public MovableTableStyle getStyle () {
 		return style;
 	}
 
 	public boolean isModal() {
 		return isModal;
 	}
 
 	public void setModal(boolean isModal) {
 		this.isModal = isModal;
 	}
 
 	public boolean isResizable() {
 		return isResizable;
 	}
 
 	public void setResizable(boolean isResizable) {
 		this.isResizable = isResizable;
 	}
 
 	public boolean isMovable() {
 		return isMovable;
 	}
 
 	public void setMovable(boolean isMovable) {
 		this.isMovable = isMovable;
 	}
 
 	public boolean isKeepWithinStage() {
 		return keepWithinStage;
 	}
 
 	public void setKeepWithinStage(boolean keepWithinStage) {
 		this.keepWithinStage = keepWithinStage;
 	}
 
 	static public class MovableTableStyle {
 
 		public Drawable background;
 	}
 }