#include <CUButton.h>

Inheritance diagram for cugl::Button:

Public Types
typedef std::function< void(const std::string &name, bool down)>	Listener

Public Member Functions
	Button ()

	~Button ()

virtual void	dispose () override

virtual bool	init () override

bool	init (const std::shared_ptr< Node > &up)

bool	init (const std::shared_ptr< Node > &up, Color4 down)

bool	init (const std::shared_ptr< Node > &up, const std::shared_ptr< Node > &down)

bool	initWithData (const SceneLoader *loader, const std::shared_ptr< JsonValue > &data) override

virtual void	setColor (Color4 color) override

const Poly2 &	getPushable () const

void	setPushable (const Poly2 &bounds)

void	setPushable (const std::vector< Vec2 > &vertices)

virtual void	doLayout () override

bool	containsScreen (const Vec2 &point)

bool	containsScreen (float x, float y)

bool	isDown () const

void	setDown (bool down)

bool	isToggle () const

void	setToggle (bool value)

bool	hasListener () const

const Listener	getListener () const

void	setListener (Listener listener)

bool	removeListener ()

bool	activate (Uint32 key)

bool	deactivate ()

bool	isActive () const

Public Member Functions inherited from cugl::Node
	Node ()

	~Node ()

virtual bool	initWithPosition (const Vec2 &pos)

bool	initWithPosition (float x, float y)

virtual bool	initWithBounds (const Size &size)

bool	initWithBounds (float width, float height)

virtual bool	initWithBounds (const Rect &rect)

bool	initWithBounds (float x, float y, float width, float height)

virtual Node *	copy (Node *dst)

unsigned int	getTag () const

void	setTag (unsigned int tag)

const std::string &	getName () const

void	setName (const std::string &name)

virtual std::string	toString (bool verbose=false) const

	operator std::string () const

const Vec2 &	getPosition () const

void	setPosition (const Vec2 &position)

void	setPosition (float x, float y)

float	getPositionX (void) const

void	setPositionX (float x)

float	getPositionY (void) const

void	setPositionY (float y)

Vec2	getWorldPosition () const

const Size &	getContentSize () const

virtual void	setContentSize (const Size &size)

virtual void	setContentSize (float width, float height)

float	getContentWidth () const

void	setContentWidth (float width)

float	getContentHeight () const

void	setContentHeight (float height)

Size	getSize () const

float	getWidth () const

float	getHeight () const

Rect	getBoundingBox () const

virtual void	setAnchor (const Vec2 &anchor)

void	setAnchor (float x, float y)

const Vec2 &	getAnchor () const

Vec2	getAnchorInPixels ()

Color4	getColor () const

Color4	getAbsoluteColor ()

bool	isVisible () const

void	setVisible (bool visible)

bool	hasRelativeColor ()

void	setRelativeColor (bool flag)

const Vec2 &	getScale () const

float	getScaleX () const

float	getScaleY () const

void	setScale (float scale)

void	setScale (const Vec2 &vec)

void	setScale (float sx, float sy)

float	getAngle ()

void	setAngle (float angle)

const Mat4 &	getAlternateTransform ()

void	setAlternateTransform (const Mat4 &transform)

bool	withAlternateTransform ()

void	chooseAlternateTransform (bool active)

const Mat4 &	getNodeToParentTransform () const

Mat4	getParentToNodeTransform () const

Mat4	getNodeToWorldTransform () const

Mat4	getWorldToNodeTransform () const

Vec2	screenToNodeCoords (const Vec2 &screenPoint) const

Vec2	worldToNodeCoords (const Vec2 &worldPoint) const

Vec2	nodeToScreenCoords (const Vec2 &nodePoint) const

Vec2	nodeToWorldCoords (const Vec2 &nodePoint) const

Vec2	parentToNodeCoords (const Vec2 &parentPoint) const

Vec2	nodeToParentCoords (const Vec2 &nodePoint) const

void	setZOrder (int z)

int	getZOrder () const

bool	isZDirty () const

void	sortZOrder ()

size_t	getChildCount () const

std::shared_ptr< Node >	getChild (unsigned int pos)

const std::shared_ptr< Node > &	getChild (unsigned int pos) const

template<typename T >
std::shared_ptr< T >	getChild (unsigned int pos) const

std::shared_ptr< Node >	getChildByTag (unsigned int tag) const

template<typename T >
std::shared_ptr< T >	getChildByTag (unsigned int tag) const

std::shared_ptr< Node >	getChildByName (const std::string &name) const

template<typename T >
std::shared_ptr< T >	getChildByName (const std::string &name) const

std::vector< std::shared_ptr< Node > >	getChildren ()

const std::vector< std::shared_ptr< Node > > &	getChildren () const

void	addChild (std::shared_ptr< Node > child)

virtual void	addChild (const std::shared_ptr< Node > &child, int zval)

void	addChildWithTag (const std::shared_ptr< Node > &child, unsigned int tag)

void	addChildWithTag (const std::shared_ptr< Node > &child, unsigned int tag, int zval)

void	addChildWithName (const std::shared_ptr< Node > &child, const std::string &name)

void	addChildWithName (const std::shared_ptr< Node > &child, const std::string &name, int zval)

void	swapChild (const std::shared_ptr< Node > &child1, const std::shared_ptr< Node > &child2, bool inherit=false)

Node *	getParent ()

const Node *	getParent () const

Scene *	getScene ()

const Scene *	getScene () const

void	removeFromParent ()

virtual void	removeChild (unsigned int pos)

void	removeChild (const std::shared_ptr< Node > &child)

void	removeChildByTag (unsigned int tag)

void	removeChildByName (const std::string &name)

virtual void	removeAllChildren ()

virtual void	render (const std::shared_ptr< SpriteBatch > &batch, const Mat4 &transform, Color4 tint)

virtual void	render (const std::shared_ptr< SpriteBatch > &batch)

virtual void	draw (const std::shared_ptr< SpriteBatch > &batch, const Mat4 &transform, Color4 tint)

const std::shared_ptr< Layout > &	getLayout () const

void	setLayout (const std::shared_ptr< Layout > &layout)

Static Public Member Functions
static std::shared_ptr< Button >	alloc (const std::shared_ptr< Node > &up)

static std::shared_ptr< Button >	alloc (const std::shared_ptr< Node > &up, Color4 down)

static std::shared_ptr< Button >	alloc (const std::shared_ptr< Node > &up, const std::shared_ptr< Node > &down)

static std::shared_ptr< Node >	allocWithData (const SceneLoader *loader, const std::shared_ptr< JsonValue > &data)

Static Public Member Functions inherited from cugl::Node
static std::shared_ptr< Node >	alloc ()

static std::shared_ptr< Node >	allocWithPosition (const Vec2 &pos)

static std::shared_ptr< Node >	allocWithPosition (float x, float y)

static std::shared_ptr< Node >	allocWithBounds (const Size &size)

static std::shared_ptr< Node >	allocWithBounds (float width, float height)

static std::shared_ptr< Node >	allocWithBounds (const Rect &rect)

static std::shared_ptr< Node >	allocWithBounds (float x, float y, float width, float height)

static std::shared_ptr< Node >	allocWithData (const SceneLoader *loader, const std::shared_ptr< JsonValue > &data)

Protected Attributes
bool	_down

bool	_toggle

std::shared_ptr< Node >	_upnode

std::shared_ptr< Node >	_downnode

std::shared_ptr< JsonValue >	_upform

std::shared_ptr< JsonValue >	_downform

Color4	_upcolor

Color4	_downcolor

std::string	_upchild

std::string	_downchild

Poly2	_bounds

bool	_active

bool	_mouse

Uint32	_inputkey

Listener	_listener

Protected Attributes inherited from cugl::Node
Vec2	_position

Vec2	_anchor

Size	_contentSize

Color4	_tintColor

bool	_hasParentColor

bool	_isVisible

Vec2	_scale

float	_angle

Mat4	_transform

bool	_useTransform

Mat4	_combined

std::vector< std::shared_ptr< Node > >	_children

Node *	_parent

Scene *	_graph

std::shared_ptr< Layout >	_layout

int	_childOffset

unsigned int	_tag

std::string	_name

size_t	_hashOfName

int	_zOrder

bool	_zDirty

Detailed Description

This class represents a simple clickable button

A button is either two nodes (one for up, one for down) that swap whenever the button is pressed, or a single node that changes color on a press. The nodes are typically either images (e.g PolygonNode or instances of class Label. These nodes are stored as children of this button, which in turn should be part of a larger scene graph.

The button can track its own state, via the activate(Uint32) method, relieving you of having to manually check mouse presses/touches. However, the appropriate input device must be active before you can activate the button, as it needs to attach internal listeners.

When a button tracks its own state, it is classified as either a normal or a toggle button. A normal button is down only when it is pressed. A toggle button changes state when pressed, and retains that state until the next press.

The user can define the clickable region to be any arbitrary polygon. This allows the click response to better match complex images.

Member Typedef Documentation

cugl::Button::Listener

This type represents a listener for state change in the Button class.

In CUGL, listeners are implemented as a set of callback functions, not as objects. This allows each listener to implement as much or as little functionality as it wants. For simplicity, Button nodes only support a single listener. If you wish for more than one listener, then your listener should handle its own dispatch.

The function type is equivalent to

 std::function<void(const std::string& name, bool down)>

Parameters

name	The button name
clicks	Whether the button is now down

Constructor & Destructor Documentation

cugl::Button::Button ( )

Creates an uninitialized button with no size or texture information.

You must initialize this button before use.

NEVER USE A CONSTRUCTOR WITH NEW. If you want to allocate a Node on the heap, use one of the static constructors instead.

cugl::Button::~Button ( )

inline

Deletes this button, disposing all resources

Member Function Documentation

bool cugl::Button::activate ( Uint32 key )

Activates this button to listen for mouse/touch events.

This method attaches a listener to either the Mouse or Touchscreen inputs to monitor when the button is pressed and/or released. The button will favor the mouse, but will use the touch screen if no mouse input is active. If neither input is active, this method will fail.

When active, the button will change its state on its own, without requiring the user to use setDown(bool). If there is a Listener attached, it will call that function upon any state changes.

Parameters

key	The listener key for the input device

Returns: true if the button was successfully activated

static std::shared_ptr<Button> cugl::Button::alloc ( const std::shared_ptr< Node > & up )

inlinestatic

Returns a newly allocated button with the given up node.

The button will look exactly like the given node when it is not pressed. When pressed, it will darken the up node a bit.

Parameters

up	The button when it is not pressed

Returns: a newly allocated button with the given up node.

static std::shared_ptr<Button> cugl::Button::alloc	(	const std::shared_ptr< Node > &	up,
		Color4	down
	)

inlinestatic

Returns a newly allocated button with the given node and color

The button will look exactly like the given node when it is not pressed. When pressed, it will tint the up node by the specified color.

Parameters

up	The button when it is not pressed
down	The button tint when it is pressed

Returns: a newly allocated button with the given node and color

static std::shared_ptr<Button> cugl::Button::alloc	(	const std::shared_ptr< Node > &	up,
		const std::shared_ptr< Node > &	down
	)

inlinestatic

Returns a newly allocated button with the given nodes

The button will look exactly like the up node when it is not pressed. It will look like the down node when it is pressed. The size of this button is the size of the larger of the two nodes.

Parameters

up	The button when it is not pressed
down	The button when it is pressed

Returns: a newly allocated button with the given nodes

static std::shared_ptr<Node> cugl::Button::allocWithData	(	const SceneLoader *	loader,
		const std::shared_ptr< JsonValue > &	data
	)

inlinestatic

Returns a newly allocated node with the given JSON specificaton.

This initializer is designed to receive the "data" object from the JSON passed to SceneLoader. This JSON format supports all of the attribute values of its parent class. In addition, it supports the following additional attributes:

 "up":       A JSON object defining a scene graph node
 "down":     A JSON object defining a scene graph node OR
             a 4-element integer array with values from 0..255
 "pushable": An even array of polygon vertices (numbers)

The attribute 'up' is REQUIRED. All other attributes are optional.

Parameters

loader	The scene loader passing this JSON file
data	The JSON object specifying the node

Returns: a newly allocated node with the given JSON specificaton.

bool cugl::Button::containsScreen ( const Vec2 & point )

Returns true if this button contains the given screen point

This method is used to manually check for mouse presses/touches. It converts a point in screen coordinates to the node coordinates and checks if it is in the bounds of the button.

Parameters

point The point in screen coordinates

Returns: true if this button contains the given screen point

bool cugl::Button::containsScreen	(	float	x,
		float	y
	)

inline

Returns true if this button contains the given screen point

This method is used to manually check for mouse presses/touches. It converts a point in screen coordinates to the node coordinates and checks if it is in the bounds of the button.

Parameters

x	The x-value in screen coordinates
y	The y-value in screen coordinates

Returns: true if this button contains the given screen point

bool cugl::Button::deactivate ( )

Deactivates this button, ignoring future mouse/touch events.

This method removes its internal listener from either the Mouse or Touchscreen inputs to monitor when the button is pressed and/or released. The input affected is the one that received the listener upon activation.

When deactivated, the button will no longer change its state on its own. However, the user can still change the state manually with the setDown(bool) method. In addition, any Listener attached will still respond to manual state changes.

Returns: true if the button was successfully deactivated

virtual void cugl::Button::dispose ( )

overridevirtual

Disposes all of the resources used by this node.

A disposed button can be safely reinitialized. Any children owned by this node will be released. They will be deleted if no other object owns them.

It is unsafe to call this on a button that is still currently inside of a scene graph.

Reimplemented from cugl::Node.

virtual void cugl::Button::doLayout ( )

overridevirtual

Arranges the child of this node using the layout manager.

This process occurs recursively and top-down. A layout manager may end up resizing the children. That is why the parent must finish its layout before we can apply a layout manager to the children.

Reimplemented from cugl::Node.

const Listener cugl::Button::getListener ( ) const

inline

Returns the listener (if any) for this button

This listener is invoked when the button state changes (up or down).

A button may only have one listener at a time. If there is no listener, this method returns nullptr.

Returns: the listener (if any) for this button

const Poly2& cugl::Button::getPushable ( ) const

inline

Returns the region responding to mouse clicks.

The pushable region is the area of this node that responds to mouse clicks. By allowing it to be an arbitrary polygon, we are capable of defining buttons with complex shapes. The polygon must have SOLID type.

Returns: the region responding to mouse clicks.

bool cugl::Button::hasListener ( ) const

inline

Returns true if this button has a listener

This listener is invoked when the button state changes (up or down).

A button may only have one listener at a time.

Returns: true if this button has a listener

virtual bool cugl::Button::init ( )

inlineoverridevirtual

Deactivates the default initializer.

This initializer may not be used for a button. A button must have a child node for the up state at the very minimum.

Returns: false

Reimplemented from cugl::Node.

bool cugl::Button::init ( const std::shared_ptr< Node > & up )

inline

Initializes a button with the given up node.

The button will look exactly like the given node when it is not pressed. When pressed, it will darken the up node a bit.

Parameters

up	The button when it is not pressed

Returns: true if the button is initialized properly, false otherwise.

bool cugl::Button::init	(	const std::shared_ptr< Node > &	up,
		Color4	down
	)

Initializes a button with the given node and color

The button will look exactly like the given node when it is not pressed. When pressed, it will tint the up node by the specified color.

Parameters

up	The button when it is not pressed
down	The button tint when it is pressed

Returns: true if the button is initialized properly, false otherwise.

bool cugl::Button::init	(	const std::shared_ptr< Node > &	up,
		const std::shared_ptr< Node > &	down
	)

Initializes a button with the given nodes

The button will look exactly like the up node when it is not pressed. It will look like the down node when it is pressed. The size of this button is the size of the larger of the two nodes.

Parameters

up	The button when it is not pressed
down	The button when it is pressed

Returns: true if the button is initialized properly, false otherwise.

bool cugl::Button::initWithData	(	const SceneLoader *	loader,
		const std::shared_ptr< JsonValue > &	data
	)

overridevirtual

Initializes a node with the given JSON specificaton.

This initializer is designed to receive the "data" object from the JSON passed to SceneLoader. This JSON format supports all of the attribute values of its parent class. In addition, it supports the following additional attributes:

 "up":       A JSON object defining a scene graph node
 "down":     A JSON object defining a scene graph node OR
             a 4-element integer array with values from 0..255
 "pushable": An even array of polygon vertices (numbers)

The attribute 'up' is REQUIRED. All other attributes are optional.

Parameters

loader	The scene loader passing this JSON file
data	The JSON object specifying the node

Returns: true if initialization was successful.

Reimplemented from cugl::Node.

bool cugl::Button::isActive ( ) const

inline

Returns true if this button has been activated.

Returns: true if this button has been activated.

bool cugl::Button::isDown ( ) const

inline

Return true if this button is currently down.

Buttons only have two states: up and down. The default state is up.

Changing this value will change how the button is displayed on the screen. It will also invoke the Listener if one is currently attached.

Returns: true if this button is currently down.

bool cugl::Button::isToggle ( ) const

inline

Returns true if this is a toggle button

A normal button is down only when it is pressed. A toggle button changes state when pressed, and retains that state until the next press.

This attribute is only relevant for activated buttons

Returns: true if this is a toggle button

bool cugl::Button::removeListener ( )

Removes the listener for this button.

This listener is invoked when the button state changes (up or down).

A button may only have one listener at a time. If this button does not have a listener, this method will fail.

Returns: true if the listener was succesfully removed

virtual void cugl::Button::setColor ( Color4 color )

overridevirtual

Sets the color tinting this node.

This color will be multiplied with the parent (this node on top) if hasRelativeColor() is true.

The default color is white, which means that all children have their natural color.

Parameters

color the color tinting this node.

Reimplemented from cugl::Node.

void cugl::Button::setDown ( bool down )

Sets whether this button is currently down.

Buttons only have two states: up and down. The default state is up.

Changing this value will change how the button is displayed on the screen. It will also invoke the Listener if one is currently attached.

Parameters

down	Whether this button is currently down.

void cugl::Button::setListener ( Listener listener )

inline

Sets the listener for this button.

This listener is invoked when the button state changes (up or down).

A button may only have one listener at a time. If this button already has a listener, this method will replace it for the once specified.

Parameters

listener The listener to use

void cugl::Button::setPushable ( const Poly2 & bounds )

Sets the region responding to mouse clicks.

The pushable region is the area of this node that responds to mouse clicks. By allowing it to be an arbitrary polygon, we are capable of defining buttons with complex shapes. The polygon must have SOLID type.

Parameters

bounds The region responding to mouse clicks.

void cugl::Button::setPushable ( const std::vector< Vec2 > & vertices )

Sets the region responding to mouse clicks.

The pushable region is the area of this node that responds to mouse clicks. By allowing it to be an arbitrary polygon, we are capable of defining buttons with complex shapes. The vertices will be converted into a polygon using SimpleTriangulator.

Parameters

vertices The region responding to mouse clicks.

void cugl::Button::setToggle ( bool value )

inline

Sets whether this is a toggle button

A normal button is down only when it is pressed. A toggle button changes state when pressed, and retains that state until the next press.

This attribute is only relevant for activated buttons

Parameters

value whether this is a toggle button

Member Data Documentation

bool cugl::Button::_active

protected

Whether the button is actively checking for state changes

Poly2 cugl::Button::_bounds

protected

The button bounds (for rounder buttons)

bool cugl::Button::_down

protected

Whether or not the button is currently down

Color4 cugl::Button::_downcolor

protected

The button color when the button is down

std::shared_ptr<JsonValue> cugl::Button::_downform

protected

Layout information for the down button

std::shared_ptr<Node> cugl::Button::_downnode

protected

The node representing the button when it is down (may be null)

Uint32 cugl::Button::_inputkey

protected

The listener key when the button is checking for state changes

Listener cugl::Button::_listener

protected

The listener callback for state changes

bool cugl::Button::_mouse

protected

Whether we are using the mouse (as opposed to the touch screen)

std::string cugl::Button::_upchild

protected

Keys

Color4 cugl::Button::_upcolor

protected

The button color when the button is up

std::shared_ptr<JsonValue> cugl::Button::_upform

protected

Layout information for the up button

std::shared_ptr<Node> cugl::Button::_upnode

protected

The node representing the button when it is up (cannot be null)

The documentation for this class was generated from the following file:

include/cugl/2d/CUButton.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation