com.badlogic.gdx.scenes.scene2d.Event Maven / Gradle / Ivy
/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.badlogic.gdx.scenes.scene2d;
import com.badlogic.gdx.utils.Pool.Poolable;
/** The base class for all events.
*
* By default an event will "bubble" up through an actor's parent's handlers (see {@link #setBubbles(boolean)}).
*
* An actor's capture listeners can {@link #stop()} an event to prevent child actors from seeing it.
*
* An Event may be marked as "handled" which will end its propagation outside of the Stage (see {@link #handle()}). The default
* {@link Actor#fire(Event)} will mark events handled if an {@link EventListener} returns true.
*
* A cancelled event will be stopped and handled. Additionally, many actors will undo the side-effects of a canceled event. (See
* {@link #cancel()}.)
*
* @see InputEvent
* @see Actor#fire(Event) */
public class Event implements Poolable {
private Stage stage;
private Actor targetActor;
private Actor listenerActor;
private boolean capture; // true means event occurred during the capture phase
private boolean bubbles = true; // true means propagate to target's parents
private boolean handled; // true means the event was handled (the stage will eat the input)
private boolean stopped; // true means event propagation was stopped
private boolean cancelled; // true means propagation was stopped and any action that this event would cause should not happen
/** Marks this event as handled. This does not affect event propagation inside scene2d, but causes the {@link Stage} event
* methods to return false, which will eat the event so it is not passed on to the application under the stage. */
public void handle () {
handled = true;
}
/** Marks this event cancelled. This {@link #handle() handles} the event and {@link #stop() stops} the event propagation. It
* also cancels any default action that would have been taken by the code that fired the event. Eg, if the event is for a
* checkbox being checked, cancelling the event could uncheck the checkbox. */
public void cancel () {
cancelled = true;
stopped = true;
handled = true;
}
/** Marks this event has being stopped. This halts event propagation. Any other listeners on the {@link #getListenerActor()
* listener actor} are notified, but after that no other listeners are notified. */
public void stop () {
stopped = true;
}
public void reset () {
stage = null;
targetActor = null;
listenerActor = null;
capture = false;
bubbles = true;
handled = false;
stopped = false;
cancelled = false;
}
/** Returns the actor that the event originated from. */
public Actor getTarget () {
return targetActor;
}
public void setTarget (Actor targetActor) {
this.targetActor = targetActor;
}
/** Returns the actor that this listener is attached to. */
public Actor getListenerActor () {
return listenerActor;
}
public void setListenerActor (Actor listenerActor) {
this.listenerActor = listenerActor;
}
public boolean getBubbles () {
return bubbles;
}
/** If true, after the event is fired on the target actor, it will also be fired on each of the parent actors, all the way to
* the root. */
public void setBubbles (boolean bubbles) {
this.bubbles = bubbles;
}
/** {@link #handle()} */
public boolean isHandled () {
return handled;
}
/** @see #stop() */
public boolean isStopped () {
return stopped;
}
/** @see #cancel() */
public boolean isCancelled () {
return cancelled;
}
public void setCapture (boolean capture) {
this.capture = capture;
}
/** If true, the event was fired during the capture phase.
* @see Actor#fire(Event) */
public boolean isCapture () {
return capture;
}
public void setStage (Stage stage) {
this.stage = stage;
}
/** The stage for the actor the event was fired on. */
public Stage getStage () {
return stage;
}
}