public boolean handle (Event e) { if (!(e instanceof InputEvent)) return false; InputEvent event = (InputEvent)e; switch (event.getType()) { case touchDown: actor = event.getListenerActor(); touchDownTarget = event.getTarget(); detector.touchDown(event.getStageX(), event.getStageY(), event.getPointer(), event.getButton()); actor.stageToLocalCoordinates(tmpCoords.set(event.getStageX(), event.getStageY())); touchDown(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getButton()); return true; case touchUp: if (event.isTouchFocusCancel()) { detector.reset(); return false; } this.event = event; actor = event.getListenerActor(); detector.touchUp(event.getStageX(), event.getStageY(), event.getPointer(), event.getButton()); actor.stageToLocalCoordinates(tmpCoords.set(event.getStageX(), event.getStageY())); touchUp(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getButton()); return true; case touchDragged: this.event = event; actor = event.getListenerActor(); detector.touchDragged(event.getStageX(), event.getStageY(), event.getPointer()); return true; } return false; }
public void dragStart (InputEvent event, float x, float y, int pointer) { if (activePointer != -1) { event.stop(); return; } activePointer = pointer; dragStartTime = System.currentTimeMillis(); dragSource = source; payload = source.dragStart(event, getTouchDownX(), getTouchDownY(), pointer); event.stop(); if (cancelTouchFocus && payload != null) source.getActor().getStage().cancelTouchFocusExcept(this, source.getActor()); }
public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) { event.cancel(); return false; } };
public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) { if (pressedPointer != -1) return false; if (pointer == 0 && this.button != -1 && button != this.button) return false; pressedPointer = pointer; touchDownX = x; touchDownY = y; stageTouchDownX = event.getStageX(); stageTouchDownY = event.getStageY(); return true; }
public void pan (InputEvent event, float x, float y, float deltaX, float deltaY) { event.getListenerActor().moveBy(deltaX, deltaY); if (deltaX < 0) System.out.println("panning " + deltaX + ", " + deltaY + " " + event.getTarget()); } });
/** Applies a mouse scroll event to the stage and returns true if an actor in the scene {@link Event#handle() handled} the * event. This event only occurs on the desktop. */ public boolean scrolled (int amount) { Actor target = scrollFocus == null ? root : scrollFocus; screenToStageCoordinates(tempCoords.set(mouseScreenX, mouseScreenY)); InputEvent event = Pools.obtain(InputEvent.class); event.setStage(this); event.setType(InputEvent.Type.scrolled); event.setScrollAmount(amount); event.setStageX(tempCoords.x); event.setStageY(tempCoords.y); target.fire(event); boolean handled = event.isHandled(); Pools.free(event); return handled; }
Stage stage = event.getStage(); dragActor.remove(); // Remove so it cannot be hit (Touchable.disabled isn't enough). dragActor = null; float stageX = event.getStageX() + touchOffsetX, stageY = event.getStageY() + touchOffsetY; Actor hit = event.getStage().hit(stageX, stageY, true); // Prefer touchable actors. if (hit == null) hit = event.getStage().hit(stageX, stageY, false); if (hit != null) { for (int i = 0, n = targets.size; i < n; i++) { Target target = targets.get(i); if (!target.actor.isAscendantOf(hit)) continue; newTarget = target; target.actor.stageToLocalCoordinates(tmpVector.set(stageX, stageY)); break; dragActor = actor; if (actor == null) return; stage.addActor(actor); float actorX = event.getStageX() - actor.getWidth() + dragActorX; float actorY = event.getStageY() + dragActorY; if (keepWithinStage) { if (actorX < 0) actorX = 0;
/** Applies a mouse moved event to the stage and returns true if an actor in the scene {@link Event#handle() handled} the * event. This event only occurs on the desktop. */ public boolean mouseMoved (int screenX, int screenY) { mouseScreenX = screenX; mouseScreenY = screenY; if (!isInsideViewport(screenX, screenY)) return false; screenToStageCoordinates(tempCoords.set(screenX, screenY)); InputEvent event = Pools.obtain(InputEvent.class); event.setStage(this); event.setType(Type.mouseMoved); event.setStageX(tempCoords.x); event.setStageY(tempCoords.y); Actor target = hit(tempCoords.x, tempCoords.y, true); if (target == null) target = root; target.fire(event); boolean handled = event.isHandled(); Pools.free(event); return handled; }
/** Applies a touch moved event to the stage and returns true if an actor in the scene {@link Event#handle() handled} the * event. Only {@link InputListener listeners} that returned true for touchDown will receive this event. */ public boolean touchDragged (int screenX, int screenY, int pointer) { pointerScreenX[pointer] = screenX; pointerScreenY[pointer] = screenY; mouseScreenX = screenX; mouseScreenY = screenY; if (touchFocuses.size == 0) return false; screenToStageCoordinates(tempCoords.set(screenX, screenY)); InputEvent event = Pools.obtain(InputEvent.class); event.setType(Type.touchDragged); event.setStage(this); event.setStageX(tempCoords.x); event.setStageY(tempCoords.y); event.setPointer(pointer); SnapshotArray<TouchFocus> touchFocuses = this.touchFocuses; TouchFocus[] focuses = touchFocuses.begin(); for (int i = 0, n = touchFocuses.size; i < n; i++) { TouchFocus focus = focuses[i]; if (focus.pointer != pointer) continue; if (!touchFocuses.contains(focus, true)) continue; // Touch focus already gone. event.setTarget(focus.target); event.setListenerActor(focus.listenerActor); if (focus.listener.handle(event)) event.handle(); } touchFocuses.end(); boolean handled = event.isHandled(); Pools.free(event); return handled; }
private Actor fireEnterAndExit (Actor overLast, int screenX, int screenY, int pointer) { screenToStageCoordinates(tempCoords.set(screenX, screenY)); Actor over = hit(tempCoords.x, tempCoords.y, true); if (over == overLast) return overLast; event.setStage(this); event.setStageX(tempCoords.x); event.setStageY(tempCoords.y); event.setPointer(pointer); event.setType(InputEvent.Type.exit); event.setRelatedActor(over); overLast.fire(event); Pools.free(event); event.setStage(this); event.setStageX(tempCoords.x); event.setStageY(tempCoords.y); event.setPointer(pointer); event.setType(InputEvent.Type.enter); event.setRelatedActor(overLast); over.fire(event); Pools.free(event);
public boolean touchDown (InputEvent event, float x, float y, int pointer, int button) { if (draggingPointer != -1) return false; if (pointer == 0 && button != 0) return false; getStage().setScrollFocus(ScrollPane.this); event.stop(); setScrollbarsVisible(true); if (hKnobBounds.contains(x, y)) { lastPoint.set(x, y); handlePosition = hKnobBounds.x; touchScrollH = true; event.stop(); setScrollbarsVisible(true); if (vKnobBounds.contains(x, y)) { lastPoint.set(x, y); handlePosition = vKnobBounds.y; touchScrollV = true;
public void dragStop (InputEvent event, float x, float y, int pointer) { if (pointer != activePointer) return; activePointer = -1; if (payload == null) return; if (System.currentTimeMillis() - dragStartTime < dragTime) isValidTarget = false; if (dragActor != null) dragActor.remove(); if (isValidTarget) { float stageX = event.getStageX() + touchOffsetX, stageY = event.getStageY() + touchOffsetY; target.actor.stageToLocalCoordinates(tmpVector.set(stageX, stageY)); target.drop(source, payload, tmpVector.x, tmpVector.y, pointer); } source.dragStop(event, x, y, pointer, payload, isValidTarget ? target : null); if (target != null) target.reset(source, payload); dragSource = null; payload = null; target = null; isValidTarget = false; dragActor = null; } };
/** @see #copy(Event, Event) */ public static void copy(InputEvent c, InputEvent e) { copy((Event) c, e); c.setStageX(e.getStageX()); c.setStageY(e.getStageY()); c.setButton(e.getButton()); c.setCharacter(e.getCharacter()); c.setKeyCode(e.getKeyCode()); c.setPointer(e.getPointer()); c.setType(e.getType()); c.setRelatedActor(e.getRelatedActor()); c.setScrollAmount(e.getScrollAmount()); }
switch (event.getType()) { case keyDown: return keyDown(event, event.getKeyCode()); case keyUp: return keyUp(event, event.getKeyCode()); case keyTyped: return keyTyped(event, event.getCharacter()); event.toCoordinates(event.getListenerActor(), tmpCoords); switch (event.getType()) { case touchDown: return touchDown(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getButton()); case touchUp: touchUp(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getButton()); return true; case touchDragged: touchDragged(event, tmpCoords.x, tmpCoords.y, event.getPointer()); return true; case mouseMoved: return mouseMoved(event, tmpCoords.x, tmpCoords.y); case scrolled: return scrolled(event, tmpCoords.x, tmpCoords.y, event.getScrollAmount()); case enter: enter(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getRelatedActor()); return false; case exit: exit(event, tmpCoords.x, tmpCoords.y, event.getPointer(), event.getRelatedActor()); return false;
/** Cancels touch focus for all listeners with the specified listener actor. * @see #cancelTouchFocus() */ public void cancelTouchFocus (Actor listenerActor) { InputEvent event = Pools.obtain(InputEvent.class); event.setStage(this); event.setType(InputEvent.Type.touchUp); event.setStageX(Integer.MIN_VALUE); event.setStageY(Integer.MIN_VALUE); // Cancel all current touch focuses for the specified listener, allowing for concurrent modification, and never cancel the // same focus twice. SnapshotArray<TouchFocus> touchFocuses = this.touchFocuses; TouchFocus[] items = touchFocuses.begin(); for (int i = 0, n = touchFocuses.size; i < n; i++) { TouchFocus focus = items[i]; if (focus.listenerActor != listenerActor) continue; if (!touchFocuses.removeValue(focus, true)) continue; // Touch focus already gone. event.setTarget(focus.target); event.setListenerActor(focus.listenerActor); event.setPointer(focus.pointer); event.setButton(focus.button); focus.listener.handle(event); // Cannot return TouchFocus to pool, as it may still be in use (eg if cancelTouchFocus is called from touchDragged). } touchFocuses.end(); Pools.free(event); }
public void drag (InputEvent event, float x, float y, int pointer) { event.getListenerActor().localToActorCoordinates(scroll, tmpCoords.set(x, y)); if (tmpCoords.y >= scroll.getHeight()) { scrollDown.cancel(); if (!scrollUp.isScheduled()) { startTime = System.currentTimeMillis(); Timer.schedule(scrollUp, tickSecs, tickSecs); } return; } else if (tmpCoords.y < 0) { scrollUp.cancel(); if (!scrollDown.isScheduled()) { startTime = System.currentTimeMillis(); Timer.schedule(scrollDown, tickSecs, tickSecs); } return; } scrollUp.cancel(); scrollDown.cancel(); }
@Override public void clicked(InputEvent event, float x, float y) { Gdx.app.log("XY", "[" + x + ", " + y + "]"); Gdx.app.log("Event", "[" + event.getStageX() + ", " + event.getStageY() + "]"); Gdx.app.log("Actor", "[" + button.getX() + ", " + button.getY() + "]"); Gdx.app.log("ActorStage", "[" + stageLoc.x + ", " + stageLoc.y + "]"); Vector2 zeroLoc = button.localToStageCoordinates(new Vector2()); Gdx.app.log("ZeroStage", "[" + zeroLoc.x + ", " + zeroLoc.y + "]");
if (event instanceof InputEvent) { InputEvent inputEvent = (InputEvent)event; if (inputEvent.getType() == Type.touchDown) { event.getStage().addTouchFocus(listener, this, inputEvent.getTarget(), inputEvent.getPointer(), inputEvent.getButton()); String context = toString(); throw new RuntimeException("Actor: " + context.substring(0, Math.min(context.length(), 128)), ex);
public void exit (InputEvent event, float x, float y, int pointer, Actor toActor) { if (toActor != null && toActor.isDescendantOf(event.getListenerActor())) return; hide(); }