org.andengine.input.touch.TouchEvent Java Examples

public void convertSceneTouchEventToSurfaceTouchEvent(final TouchEvent pSceneTouchEvent, final int pSurfaceWidth, final int pSurfaceHeight) {
	this.convertAxisAlignedSceneToSurfaceTouchEvent(pSceneTouchEvent, pSurfaceWidth, pSurfaceHeight);

	final float rotation = this.mRotation;
	if (rotation == 0) {
		/* Nothing. */
	} else if (rotation == 180) {
		pSceneTouchEvent.setY(pSurfaceHeight - pSceneTouchEvent.getY());
		pSceneTouchEvent.setX(pSurfaceWidth - pSceneTouchEvent.getX());
	} else {
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] = pSceneTouchEvent.getX();
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] = pSceneTouchEvent.getY();

		MathUtils.revertRotateAroundCenter(Camera.VERTICES_TMP, -rotation, pSurfaceWidth >> 1, pSurfaceHeight >> 1); // TODO Use a Transformation object instead!?!

		pSceneTouchEvent.set(Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X], Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y]);
	}
}
 

public void convertSurfaceTouchEventToSceneTouchEvent(final TouchEvent pSurfaceTouchEvent, final int pSurfaceWidth, final int pSurfaceHeight) {
	final float relativeX;
	final float relativeY;

	final float surfaceTouchEventX = pSurfaceTouchEvent.getX();
	final float surfaceTouchEventY = pSurfaceTouchEvent.getY();

	final float rotation = this.mRotation;
	if (rotation == 0) {
		relativeX = surfaceTouchEventX / pSurfaceWidth;
		relativeY = 1 - (surfaceTouchEventY / pSurfaceHeight);
	} else if (rotation == 180) {
		relativeX = 1 - (surfaceTouchEventX / pSurfaceWidth);
		relativeY = surfaceTouchEventY / pSurfaceHeight;
	} else {
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] = surfaceTouchEventX;
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] = surfaceTouchEventY;

		MathUtils.rotateAroundCenter(Camera.VERTICES_TMP, rotation, pSurfaceWidth >> 1, pSurfaceHeight >> 1); // TODO Use a Transformation object instead!?!

		relativeX = Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] / pSurfaceWidth;
		relativeY = 1 - (Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] / pSurfaceHeight);
	}

	this.convertAxisAlignedSurfaceTouchEventToSceneTouchEvent(pSurfaceTouchEvent, relativeX, relativeY);
}
 

public void convertSurfaceToSceneTouchEvent(final TouchEvent pSurfaceTouchEvent, final int pSurfaceWidth, final int pSurfaceHeight) {
	final float relativeX;
	final float relativeY;

	final float surfaceTouchEventX = pSurfaceTouchEvent.getX();
	final float surfaceTouchEventY = pSurfaceTouchEvent.getY();

	final float rotation = this.mRotation;
	if(rotation == 0) {
		relativeX = surfaceTouchEventX / pSurfaceWidth;
		relativeY = surfaceTouchEventY / pSurfaceHeight;
	} else if(rotation == 180) {
		relativeX = 1 - (surfaceTouchEventX / pSurfaceWidth);
		relativeY = 1 - (surfaceTouchEventY / pSurfaceHeight);
	} else {
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] = surfaceTouchEventX;
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] = surfaceTouchEventY;

		MathUtils.rotateAroundCenter(Camera.VERTICES_TMP, rotation, pSurfaceWidth >> 1, pSurfaceHeight >> 1);

		relativeX = Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] / pSurfaceWidth;
		relativeY = Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] / pSurfaceHeight;
	}

	this.convertAxisAlignedSurfaceToSceneTouchEvent(pSurfaceTouchEvent, relativeX, relativeY);
}
 

LevelModeCompleteScene() {

        Text levelCompleteTextShape = new Text((float) (camera.getWidth() * 0.05), (float) (camera.getHeight() * 0.05),
                resourcesManager.levelModeCompleteFont, "Level Mode\nCompleted", vbom);
        levelCompleteTextShape.setScaleCenter(0, 0);
        attachChild(levelCompleteTextShape);

        Sprite cup = new Sprite(0, 0, resourcesManager.levelModeCup, vbom);
        cup.setPosition(camera.getWidth() / 2 - cup.getWidth() / 2, camera.getHeight() * 0.4f);
        attachChild(cup);
        attachChild(new ConfettiParticleSystem(vbom, camera.getWidth()));
        setOnSceneTouchListener(new IOnSceneTouchListener() {

                @Override
                public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {

                    onBackKeyPressed();

                    return false;
                }
            });
    }
 

@Override
public boolean onSceneTouchEvent(final TouchEvent pSceneTouchEvent) {
	if (this.mCamera == null) {
		return false;
	} else {
		this.mCamera.convertSceneTouchEventToCameraSceneTouchEvent(pSceneTouchEvent);

		final boolean handled = super.onSceneTouchEvent(pSceneTouchEvent);

		if (handled) {
			return true;
		} else {
			this.mCamera.convertCameraSceneTouchEventToSceneTouchEvent(pSceneTouchEvent);
			return false;
		}
	}
}
 

@Override
public boolean onSceneTouchEvent(final TouchEvent pSceneTouchEvent) {
	if(this.mCamera == null) {
		return false;
	} else {
		this.mCamera.convertSceneToCameraSceneTouchEvent(pSceneTouchEvent);

		final boolean handled = super.onSceneTouchEvent(pSceneTouchEvent);

		if(handled) {
			return true;
		} else {
			this.mCamera.convertCameraSceneToSceneTouchEvent(pSceneTouchEvent);
			return false;
		}
	}
}
 

protected void triggerOnHoldStarted() {
	this.mTriggering = true;

	if (this.mPointerID != TouchEvent.INVALID_POINTER_ID) {
		this.mHoldDetectorListener.onHoldStarted(this, this.mPointerID, this.mHoldX, this.mHoldY);
	}
}
 

protected void prepareHold(final TouchEvent pSceneTouchEvent) {
	final MotionEvent motionEvent = pSceneTouchEvent.getMotionEvent();
	this.mDownTimeMilliseconds = System.currentTimeMillis();
	this.mDownX = motionEvent.getX();
	this.mDownY = motionEvent.getY();
	this.mMaximumDistanceExceeded = false;
	this.mPointerID = pSceneTouchEvent.getPointerID();
	this.mHoldX = pSceneTouchEvent.getX();
	this.mHoldY = pSceneTouchEvent.getY();

	if (this.mTriggerHoldMinimumMilliseconds == 0) {
		this.triggerOnHoldStarted();
	}
}
 

protected boolean onTouchHUD(final Camera pCamera, final TouchEvent pSceneTouchEvent) {
	if(pCamera.hasHUD()) {
		return pCamera.getHUD().onSceneTouchEvent(pSceneTouchEvent);
	} else {
		return false;
	}
}
 

private void triggerOnScrollFinished(final float pDistanceX, final float pDistanceY) {
	this.mTriggering = false;

	if (this.mPointerID != TouchEvent.INVALID_POINTER_ID) {
		this.mScrollDetectorListener.onScrollFinished(this, this.mPointerID, pDistanceX, pDistanceY);
	}
}
 

@Override
public boolean onSceneTouchEvent(final Scene pScene, final TouchEvent pSceneTouchEvent) {
	if(this.mSelectedMenuItem != null) {
		this.mSelectedMenuItem.onUnselected();
		this.mSelectedMenuItem = null;
	}
	return false;
}
 

@Override
protected void convertSurfaceToSceneTouchEvent(final Camera pCamera, final TouchEvent pSurfaceTouchEvent) {
	final int surfaceWidthHalf = this.mSurfaceWidth >> 1;

	if(pCamera == this.getFirstCamera()) {
		pCamera.convertSurfaceToSceneTouchEvent(pSurfaceTouchEvent, surfaceWidthHalf, this.mSurfaceHeight);
	} else {
		pSurfaceTouchEvent.offset(-surfaceWidthHalf, 0);
		pCamera.convertSurfaceToSceneTouchEvent(pSurfaceTouchEvent, surfaceWidthHalf, this.mSurfaceHeight);
	}
}
 

protected void triggerOnHoldFinished(final long pHoldTimeMilliseconds) {
	this.mTriggering = false;

	if (this.mPointerID != TouchEvent.INVALID_POINTER_ID) {
		this.mHoldDetectorListener.onHoldFinished(this, pHoldTimeMilliseconds, this.mPointerID, this.mHoldX, this.mHoldY);
	}
}
 

@Override
protected Camera getCameraFromSurfaceTouchEvent(final TouchEvent pTouchEvent) {
	if(pTouchEvent.getX() <= this.mSurfaceWidth >> 1) {
		return this.getFirstCamera();
	} else {
		return this.getSecondCamera();
	}
}
 

@Override
protected void onRecycle() {
	super.onRecycle();
	final TouchEvent touchEvent = this.mTouchEvent;
	touchEvent.getMotionEvent().recycle();
	touchEvent.recycle();
}
 

private void triggerOnScrollFinished(final float pDistanceX, final float pDistanceY) {
	this.mTriggering = false;
	
	if(this.mPointerID != TouchEvent.INVALID_POINTER_ID) {
		this.mScrollDetectorListener.onScrollFinished(this, this.mPointerID, pDistanceX, pDistanceY);
	}
}
 

protected boolean onHandleControlBaseTouched(final TouchEvent pSceneTouchEvent, final float pTouchAreaLocalX, final float pTouchAreaLocalY) {
	final int pointerID = pSceneTouchEvent.getPointerID();

	switch(pSceneTouchEvent.getAction()) {
		case MotionEvent.ACTION_DOWN:
			if(this.mActivePointerID == INVALID_POINTER_ID) {
				this.mActivePointerID = pointerID;
				this.updateControlKnob(pTouchAreaLocalX, pTouchAreaLocalY);
				return true;
			}
			break;
		case MotionEvent.ACTION_UP:
		case MotionEvent.ACTION_CANCEL:
			if(this.mActivePointerID == pointerID) {
				this.mActivePointerID = INVALID_POINTER_ID;
				this.onHandleControlKnobReleased();
				return true;
			}
			break;
		default:
			if(this.mActivePointerID == pointerID) {
				this.updateControlKnob(pTouchAreaLocalX, pTouchAreaLocalY);
				return true;
			}
			break;
	}
	return true;
}
 

/**
 * When {@link #isHolding()} this method will call through to {@link IHoldDetectorListener#onHoldFinished(HoldDetector, long, int, float, float).
 */
@Override
public void reset() {
	if (this.mTriggering) {
		this.triggerOnHoldFinished(System.currentTimeMillis() - this.mDownTimeMilliseconds);
	}

	this.mTriggering = false;
	this.mMaximumDistanceExceeded = false;
	this.mDownTimeMilliseconds = Long.MIN_VALUE;
	this.mPointerID = TouchEvent.INVALID_POINTER_ID;
}
 

@Override
protected void applySceneToCameraSceneOffset(final TouchEvent pSceneTouchEvent) {
	final float zoomFactor = this.mZoomFactor;
	if(zoomFactor != 1) {
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X] = pSceneTouchEvent.getX();
		Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y] = pSceneTouchEvent.getY();

		MathUtils.scaleAroundCenter(Camera.VERTICES_TMP, zoomFactor, zoomFactor, this.getCenterX(), this.getCenterY()); // TODO Use a Transformation object instead!?!

		pSceneTouchEvent.set(Camera.VERTICES_TMP[Constants.VERTEX_INDEX_X], Camera.VERTICES_TMP[Constants.VERTEX_INDEX_Y]);
	}

	super.applySceneToCameraSceneOffset(pSceneTouchEvent);
}
 

@Override
protected void convertSurfaceTouchEventToSceneTouchEvent(final Camera pCamera, final TouchEvent pSurfaceTouchEvent) {
	final int surfaceWidthHalf = this.mSurfaceWidth >> 1;

	if (pCamera == this.getFirstCamera()) {
		pCamera.convertSurfaceTouchEventToSceneTouchEvent(pSurfaceTouchEvent, surfaceWidthHalf, this.mSurfaceHeight);
	} else {
		pSurfaceTouchEvent.offset(-surfaceWidthHalf, 0);
		pCamera.convertSurfaceTouchEventToSceneTouchEvent(pSurfaceTouchEvent, surfaceWidthHalf, this.mSurfaceHeight);
	}
}
 

@Override
protected Scene getSceneFromSurfaceTouchEvent(final TouchEvent pTouchEvent) {
	if (pTouchEvent.getX() <= this.mSurfaceWidth >> 1) {
		return this.getFirstScene();
	} else {
		return this.getSecondScene();
	}
}
 

private Boolean onAreaTouchEvent(final TouchEvent pSceneTouchEvent, final float sceneTouchEventX, final float sceneTouchEventY, final ITouchArea touchArea) {
	final float[] touchAreaLocalCoordinates = touchArea.convertSceneToLocalCoordinates(sceneTouchEventX, sceneTouchEventY);
	final float touchAreaLocalX = touchAreaLocalCoordinates[Constants.VERTEX_INDEX_X];
	final float touchAreaLocalY = touchAreaLocalCoordinates[Constants.VERTEX_INDEX_Y];

	final boolean handledSelf = touchArea.onAreaTouched(pSceneTouchEvent, touchAreaLocalX, touchAreaLocalY);
	if(handledSelf) {
		return Boolean.TRUE;
	} else if(this.mOnAreaTouchListener != null) {
		return this.mOnAreaTouchListener.onAreaTouched(pSceneTouchEvent, touchArea, touchAreaLocalX, touchAreaLocalY);
	} else {
		return null;
	}
}
 

@Override
protected Camera getCameraFromSurfaceTouchEvent(final TouchEvent pTouchEvent) {
	if(pTouchEvent.getX() <= this.mSurfaceWidth >> 1) {
		return this.getFirstCamera();
	} else {
		return this.getSecondCamera();
	}
}
 

@Override
protected Camera getCameraFromSurfaceTouchEvent(final TouchEvent pTouchEvent) {
	if (pTouchEvent.getX() <= this.mSurfaceWidth >> 1) {
		return this.getFirstCamera();
	} else {
		return this.getSecondCamera();
	}
}
 

protected boolean onTouchScene(final Scene pScene, final TouchEvent pSceneTouchEvent) {
	if (pScene != null) {
		return pScene.onSceneTouchEvent(pSceneTouchEvent);
	} else {
		return false;
	}
}
 

@Override
public boolean onTouchEvent(final TouchEvent pSurfaceTouchEvent) {
	/* Let the engine determine which scene and camera this event should be handled by. */
	final Scene scene = this.getSceneFromSurfaceTouchEvent(pSurfaceTouchEvent);
	final Camera camera = this.getCameraFromSurfaceTouchEvent(pSurfaceTouchEvent);

	this.convertSurfaceTouchEventToSceneTouchEvent(camera, pSurfaceTouchEvent);

	if (this.onTouchHUD(camera, pSurfaceTouchEvent)) {
		return true;
	} else {
		/* If HUD didn't handle it, Scene may handle it. */
		return this.onTouchScene(scene, pSurfaceTouchEvent);
	}
}
 

protected void prepareHold(final TouchEvent pSceneTouchEvent) {
	final MotionEvent motionEvent = pSceneTouchEvent.getMotionEvent();
	this.mDownTimeMilliseconds = System.currentTimeMillis();
	this.mDownX = motionEvent.getX();
	this.mDownY = motionEvent.getY();
	this.mMaximumDistanceExceeded = false;
	this.mPointerID = pSceneTouchEvent.getPointerID();
	this.mHoldX = pSceneTouchEvent.getX();
	this.mHoldY = pSceneTouchEvent.getY();

	if(this.mTriggerHoldMinimumMilliseconds == 0) {
		this.triggerOnHoldStarted();
	}
}
 

private void convertAxisAlignedSceneToSurfaceTouchEvent(final TouchEvent pSceneTouchEvent, final int pSurfaceWidth, final int pSurfaceHeight) {
	final float xMin = this.getXMin();
	final float xMax = this.getXMax();
	final float yMin = this.getYMin();
	final float yMax = this.getYMax();

	final float relativeX = (pSceneTouchEvent.getX() - xMin) / (xMax - xMin);
	final float relativeY = 1 - (pSceneTouchEvent.getY() - yMin) / (yMax - yMin);

	final float x = relativeX * pSurfaceWidth;
	final float y = relativeY * pSurfaceHeight;

	pSceneTouchEvent.set(x, y);
}
 

@Override
protected void onRecycle() {
	super.onRecycle();
	final TouchEvent touchEvent = this.mTouchEvent;
	touchEvent.getMotionEvent().recycle();
	touchEvent.recycle();
}
 

private void convertAxisAlignedSceneToSurfaceTouchEvent(final TouchEvent pSceneTouchEvent, final int pSurfaceWidth, final int pSurfaceHeight) {
	final float xMin = this.getXMin();
	final float xMax = this.getXMax();
	final float yMin = this.getYMin();
	final float yMax = this.getYMax();

	final float relativeX = (pSceneTouchEvent.getX() - xMin) / (xMax - xMin);
	final float relativeY = (pSceneTouchEvent.getY() - yMin) / (yMax - yMin);

	pSceneTouchEvent.set(relativeX * pSurfaceWidth, relativeY * pSurfaceHeight);
}