com.badlogic.gdx.scenes.scene2d.Event Java Examples

@Override
public Actor getActor(final String settingName, VisualSettingManager visualSettingManager) {
  final SelectBox<String> selectBox = new SelectBox<String>(visualSettingManager.getSkin()) {
    @Override
    protected String toString(String s) {
      return Settings.getLocalisedSettingName(settingName + "." + s);
    }
  };
  selectBox.setItems(options);
  selectBox.setSelected(selected);
  selectBox.addListener(new EventListener() {
    @Override
    public boolean handle(Event event) {
      if (!(event instanceof SettingsMenu.SaveEvent)) return false;
      set(selectBox.getSelected());
      return true;
    }
  });
  return selectBox;
}
 

public ServerRunningMenu(Save save, int port) {
  super(Localization.get("menu.general.loading"), Localization.get("menu.server.stop"));
  this.save = save;
  this.port = port;

  addButtonListener(new EventListener() {
    @Override
    public boolean handle(Event event) {
      if (!(event instanceof ChangeListener.ChangeEvent)) return false;
      try {
        Adapter.gotoMainMenu();
      } catch (StopLoopException ignored) {
      }
      return true;
    }
  });
}
 

public FlopsyScreen(FlopsyDroidGame game, OnGlobalListener listener) {
    mStage = new Stage();

    mGlobalListener = listener;

    game.getAssetManager().load("flopsy.sprites", TextureAtlas.class);
    game.getAssetManager().finishLoading();
    mTextureAtlas = game.getAssetManager().get("flopsy.sprites", TextureAtlas.class);

    mLabelStyle = new Label.LabelStyle();
    mLabelStyle.font = new BitmapFont(Gdx.files.internal("flappyfont.fnt"),
            Gdx.files.internal("flappyfont.png"), false);

    mStage.addListener(new EventListener() {
        @Override
        public boolean handle(Event event) {

            if(event.getTarget().equals(mAndy)) {
                mGround.onDroidCollision();
                return true;
            }

            return false;
        }
    });
}
 

@Override
public void process(final LmlParser parser, LmlTag tag, final Actor actor, String rawAttributeData) {
    final String id = parser.parseString(rawAttributeData);
    // Post for one frame to let the layout to be fully parsed (target actor may be parsed after this attribute).
    actor.addAction(Actions.run(new Runnable() {
        @Override
        public void run() {
            final Actor targetActor = parser.getActorsMappedByIds().get(id);
            if (targetActor == null) {
                parser.throwErrorIfStrict("Cannot find actor for ID: " + id);
                return;
            }

            actor.addListener(new EventListener() {
                @Override
                public boolean handle(Event event) {
                    if (event instanceof InputEvent) {
                        return targetActor.notify(event, false);
                    }
                    return false;
                }
            });
        }
    }));
}
 

@Override
public boolean handle(Event event) {
    if (event instanceof CustomPropertyEvent) {
        CustomPropertyEvent newPropertyEvent = (CustomPropertyEvent) event;
        if (newPropertyEvent.result) {
            newPropertyEntered(newPropertyEvent.propertyName, newPropertyEvent.propertyType);
        } else {
            cancelled();
        }
    }
    return false;
}
 

@Override
public Actor getActor(String settingName, VisualSettingManager visualSettingManager) {
  final TextField textField = new TextField(s, visualSettingManager.getSkin());
  textField.addListener(new EventListener() {
    @Override
    public boolean handle(Event event) {
      if (!(event instanceof SettingsMenu.SaveEvent)) return false;
      set(textField.getText());
      return true;
    }
  });
  return textField;
}
 

@Override
public void render() {
  super.render();
  if (!firstRender) return;
  addButtonListener(new EventListener() {
    @Override
    public boolean handle(Event event) {
      if (!(event instanceof ChangeListener.ChangeEvent)) return false;
      Adapter.setMenu(new MainMenu());
      return true;
    }
  });
  firstRender = false;
}
 

public IconTextButton(Button.ButtonStyle style, String text, FontTBL.BitmapFont font) {
  add(button = new Button(style)).fill(false).pad(2).padLeft(1).padTop(3);
  add(label = new LabelButton(text, font)).grow().spaceLeft(25).row();
  setTouchable(Touchable.enabled);
  addListener(new InputListener() {
    @Override
    public boolean handle(Event e) {
      button.getClickListener().handle(e);
      label.clickListener.handle(e);
      return true;
    }
  });
}
 

public static void showStageEvents(final Stage stage) {
    EventListener listener = new EventListener() {
        private final Vector2 tmp = new Vector2();
        private Actor actor = new Actor() {
            @Override public void draw(Batch batch, float parentAlpha) {
                if (target == null)
                    return;
                batch.end();
                Config.shapeRenderer.begin(ShapeRenderer.ShapeType.Line);
                Config.shapeRenderer.setProjectionMatrix(stage.getCamera().combined);
                Gdx.gl.glLineWidth(6);
                Config.shapeRenderer.setColor(Color.ORANGE);
                Vector2 pos = target.localToStageCoordinates(tmp.set(0, 0));
                float x = pos.x, y = pos.y;
                Vector2 top = target.localToStageCoordinates(tmp.set(target.getWidth(), target.getHeight()));
                float maxX = top.x, maxY = top.y;
                Config.shapeRenderer.rect(x, y, maxX - x, maxY - y);

                Config.shapeRenderer.end();
                batch.begin();
            }
        };

        {
            stage.addActor(actor);
        }

        public Actor target;

        @Override public boolean handle(Event event) {
            target = event.getTarget();
            return false;
        }
    };
    stage.addListener(listener);
}
 

@Override public final boolean handle(Event event) {
    if (event instanceof WindowEvent) {
        WindowEvent windowEvent = (WindowEvent) event;
        return notify(windowEvent);
    }
    return false;
}
 

@Override public boolean handle(Event event) {
    if (event instanceof ResizeEvent) {
        resize();
        return true;
    }
    return false;
}
 

@Override public boolean handle(Event event) {
    if (event instanceof AnimationEvent) {
        onAnimationEvent((AnimationEvent) event);
        return true;
    }
    return false;
}
 

@Override public final boolean handle(Event event) {
    if (event == RefreshEvent.INSTANCE) {
        refreshed();
        return true;
    }
    return false;
}
 

@Override public boolean handle(Event event) {
    if (event instanceof Bought) {
        bought();
        return true;
    }
    return false;
}
 

@Override
public boolean handle(Event event) {
    if (event instanceof StageResizeEvent) {
        StageResizeEvent sEvent = (StageResizeEvent) event;
        resized(sEvent.getWidth(), sEvent.getHeight());
    }
    
    return false;
}
 

@Override
public boolean handle(Event event) {
    if (event instanceof DialogTenPatchSettingsEvent) {
        settingsUpdated((DialogTenPatchSettingsEvent) event);
    }
    return false;
}
 

@Override
default boolean handle(Event event) {
    if (event instanceof DialogEvent) {
        var dialogEvent = (DialogEvent) event;
        if (dialogEvent.type == DialogEvent.Type.OPEN) {
            opened();
        } else if (dialogEvent.type == DialogEvent.Type.CLOSE) {
            closed();
        }
        
        return true;
    }
    
    return false;
}
 

@Override public boolean notify(Event event, boolean capture) {
    return super.notify(event, capture);
}
 

@Override public boolean handle(Event event) {
    return event instanceof PaneEvent && notify((PaneEvent) event);
}
 

@Override
public boolean handle(Event event) {
    return changeListener.handle(event) || focusListener.handle(event);
}
 

@Override
public boolean handle (Event event) {
	if (event instanceof WindowResizeEvent == false) return false;
	resize();
	return false;
}
 

@Override public boolean handle(Event event) {
    if (event instanceof IngredientReplaced) {
        onIngredientReplaced(((IngredientReplaced) event).icon.item);
    }
    return false;
}