ggMath Mathematics

These mathematics and geometry extensions subclass the App and Sprite classes to create a framework for building apps that mimic some of the functionality of online math tools like Geogebra.

This mathapp module implements base classes for Sprite-based classes defined in this module.

These extensions are very experimental and are not fully developed!

ggMath Application

MathApp

class ggame.mathapp.MathApp(scale=200)

MathApp is a subclass of the ggame App class. It incorporates the following extensions:

• Support for zooming the display using the mouse wheel
• Support for click-dragging the display using the mouse button

• Automatic execution of step functions in all objects and sprites

  sub-classed from _MathDynamic.

Parameters:scale (float) – Optional parameter sets the initial scale of the display in units of pixels per logical unit. The default is 200. Returns:MathApp instance

view_position

Attribute is used to get or set the current logical coordinates at the center of the screen as a tuple of floats (x,y).

scale = 200

classmethod getSpritesbyClass(sclass)

Returns a list of all active sprites of a given class.

Parameters:sclass (class) – A class name (e.g. ‘Sprite’) or subclass. Returns:A (potentially empty) list of sprite references.

classmethod listenKeyEvent(eventtype, key, callback)

Register to receive keyboard events.

Parameters:

• eventtype (str) – The type of key event to receive (value is one of: ‘keydown’, ‘keyup’ or ‘keypress’).
• key (str) – Identify the keyboard key (e.g. ‘space’, ‘left arrow’, etc.) to receive events for.
• callback (function) – The function or method that will be called with the KeyEvent object when the event occurs.

Returns:

Nothing

See the source for KeyEvent for a list of key names to use with the key paramter.

classmethod listenMouseEvent(eventtype, callback)

Register to receive mouse events.

Parameters:

• eventtype (str) – The type of mouse event to receive (value is one of: ‘mousemove’, ‘mousedown’, ‘mouseup’, ‘click’, ‘dblclick’ or ‘mousewheel’).
• callback (function) – The function or method that will be called with the ggame.event.MouseEvent object when the event occurs.

Returns:

Nothing

classmethod unlistenKeyEvent(eventtype, key, callback)

Use this method to remove a registration to receive a particular keyboard event. Arguments must exactly match those used when registering for the event.

Parameters:

• eventtype (str) – The type of key event to stop receiving (value is one of: ‘keydown’, ‘keyup’ or ‘keypress’).
• key (str) – The keyboard key (e.g. ‘space’, ‘left arrow’, etc.) to stop receiving events for.
• callback (function) – The function or method that will no longer be called with the KeyEvent object when the event occurs.

Returns:

Nothing

See the source for KeyEvent for a list of key names to use with the key paramter.

classmethod unlistenMouseEvent(eventtype, callback)

Use this method to remove a registration to receive a particular mouse event. Arguments must exactly match those used when registering for the event.

Parameters:

• eventtype (str) – The type of mouse event to stop receiving events for (value is one of: ‘mousemove’, ‘mousedown’, ‘mouseup’, ‘click’, ‘dblclick’ or ‘mousewheel’).
• callback (function) – The function or method that will no longer be called with the ggame.event.MouseEvent object when the event occurs.

Returns:

Nothing

classmethod logicalToPhysical(lp)

Transform screen coordinates from logical to physical space. Output depends on the current ‘zoom’ and ‘pan’ of the screen.

Parameters:lp (tuple(float,float)) – Logical screen coordinates (x, y) Return type:tuple(float,float) Returns:Physical screen coordinates (x, y)

classmethod physicalToLogical(pp)

Transform screen coordinates from physical to logical space. Output depends on the current ‘zoom’ and ‘pan’ of the screen.

Parameters:lp (tuple(float,float)) – Physical screen coordinates (x, y) Return type:tuple(float,float) Returns:Logical screen coordinates (x, y)

classmethod translateLogicalToPhysical(pp)

Transform screen translation from logical to physical space. Output only depends on the current ‘zoom’ of the screen.

Parameters:lp (tuple(float,float)) – Logical screen translation pair (delta x, delta y) Return type:tuple(float,float) Returns:Physical screen translation ordered pair (delta x, delta y)

classmethod translatePhysicalToLogical(pp)

Transform screen translation from physical to logical space. Output only depends on the current ‘zoom’ of the screen.

Parameters:lp (tuple(float,float)) – Physical screen translation pair (delta x, delta y) Return type:tuple(float,float) Returns:Logical screen translation ordered pair (delta x, delta y)

classmethod distance(pos1, pos2)

Utility for calculating the distance between any two points.

Parameters:

• pos1 (tuple(float,float)) – The first point
• pos2 (tuple(float,float)) – The second point

Return type:

float

Returns:

The distance between the two points (using Pythagoras)

classmethod addViewNotification(handler)

Register a function or method to be called in the event the view position or zoom changes.

Parameters:handler (function) – The function or method to be called Returns:Nothing

classmethod removeViewNotification(handler)

Remove a function or method from the list of functions to be called in the event of a view position or zoom change.

Parameters:handler (function) – The function or method to be removed Returns:Nothing

run(userfunc=None)

Calling the run() method begins the animation process whereby the step() method is called once per animation frame.

Parameters:userfunc (function) – Any function or method which shall be called once per animation frame. Returns:Nothing

ggMath Base Class for Visual Objects

class ggame.mathapp._MathVisual(asset, *args, **kwargs)

Abstract Base Class for all visual, potentially dynamic objects.

Parameters:

• asset (Asset) – A valid ggame asset object.
• args (list) – A list of required positional or non-positional arguments as named in the _posinputsdef and _nonposinputsdef lists overridden by child classes.
• **kwargs – See below

Optional Keyword Arguments:  

• positioning (string) One of ‘logical’ or ‘physical’
• size (int) Size of the object (in pixels)
• width (int) Width of the object (in pixels)
• color (Color) Valid Color object
• style (LineStyle) Valid LineStyle object

selected = None

True if object is currently selected by the UI.

mouseisdown = None

True if object is tracking UI mouse button as down.

step()

Override in your child class to perform periodic processing.

destroy()

Prevent the sprite from being displayed or checked in collision detection. Once this is called, the sprite can no longer be displayed or used. If you only want to prevent a sprite from being displayed, set the visible attribute to False.

positioning

Whether object was created with ‘logical’ or ‘physical’ positioning.

movable

Whether object can be moved. Set-able and get-able.

selectable

Whether object can be selected by the UI. Set-able and get-able.

strokable

Whether the object supports a click-drag input from the UI mouse. Set-able and get-able.

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

unselect()

Place the object in an ‘unselected’ state.

Param:None Returns:None

mousedown()

Inform the object of a ‘mouse down’ event.

Param:None Returns:None

mouseup()

Inform the object of a ‘mouse up’ event.

Param:None Returns:None

processEvent(event)

Inform the object of a generic ggame event.

Parameters:event – The ggame event object to receive and process. Returns:None

This method is intended to be overridden.

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this object.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

This method must be overridden.

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

This method must be overridden.

stroke(ppos, pdisp)

Perform necessary processing in response to click-drag action by the mouse/UI.

Parameters:

• ppos (tuple(int,int)) – Physical coordinates of stroke start.
• pdisp (tuple(int,int)) – Translation vector of stroke action in physical screen units.

Returns:

None

This method is intended to be overridden.

canStroke(ppos)

Can the object respond to beginning a stroke action at the given position.

Parameters:ppos (tuple(int,int)) – Physical coordinates of stroke start. Return type:Boolean Returns:True if the object can respond, False otherwise.

This method is intended to be overridden.

touchAsset(force=False)

Check to see if an asset needs to be updated it and if so (or forced) call the _updateAsset() method.

MathApp classes for representing geometric points

Point Objects

These classes are subclasses of Sprite and are used to represent points in geometry and mathematics.

_Point

This is the abstract base class for all point classes.

class ggame.point._Point(asset, *args, **kwargs)

Abstract base class for all point classes.

Parameters:

• asset (Asset) – A valid ggame Asset object
• pos (tuple(float,float)) – The position (physical or logical)

step()

Perform periodic processing.

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this point.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

distanceTo(otherpoint)

Compute the distance to another _Point object.

Parameters:otherpoint (_Point) – A reference to the other _Point Return type:float Returns:The distance (in logical units) to the other point

Point

class ggame.point.Point(*args, **kwargs)

Basic point object representing any point in a geometrical sense. An instantiated Point object is callable and will return a tuple with its logical position as an (x,y) pair.

Parameters:

• pos (tuple(float,float)) – Position in physical or logical units.
• **kwargs – See below

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’
• size (int) Radius of the point (in pixels)
• color (Color) Valid Color object
• style (LineStyle) Valid LineStyle object

Example:

"""
Example of using MathApp Point class.
"""
from ggame.asset import Color
from ggame.point import Point
from ggame.mathapp import MathApp

P1 = Point((0, 1), color=Color(0xFF8000, 1.0))
P1.movable = True
# An orange point that can be moved

P2 = Point(lambda: (P1()[0], P1()[1] + 1))
# A point position based on P1
P3 = Point((1, 0))
# A third, fixed point

MathApp().run()

ImagePoint

class ggame.point.ImagePoint(url, *args, **kwargs)

Point object that uses an image as its on-screen

representation.

Parameters:

• url (str) – Location of an image file (png, jpg)
• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Position in physical or logical units.

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’
• frame (Frame) The sub-frame location of image within the image file
• qty (int) The number of sub-frames, when used as a sprite sheet
• direction (str) One of ‘horizontal’ (default) or ‘vertical’
• margin (int) Pixels between sub-frames if sprite sheet

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching point’s image.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

Line objects for MathApp applications

Line Objects

This category currently only has one class: LineSegment, but will eventually be extended to include at least Line and Ray.

LineSegment

class ggame.line.LineSegment(*args, **kwargs)

Create a line segment on the screen. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Starting point of the segment, which may

  be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.

• end (tuple(float,float)) Ending point of the segment (see above)

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ or ‘physical’
• style (LineStyle) Valid LineStyle object

Example:

from ggame.point import Point
from ggame.line import LineSegment
from ggame.mathapp import MathApp

p1 = Point((2,1))
ls = LineSegment(p1, Point((1,1)))

MathApp().run()

physicalPointTouching(ppos)

This method always returns False.

translate(pdisp)

This method is not implemented.

Circle

Circle object for MathApp applications

class ggame.circle.Circle(*args, **kwargs)

Create a circle on the screen. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Center point of the circle, which may

  be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.

• radius [float or Point] Radius of the circle (logical units)

  or a Point on the circle.

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ or ‘physical’
• style (LineStyle) Valid LineStyle object
• color (Color) Valid Color object`

Example:

"""
Example of using MathApp Circle class.
"""
from ggame.point import Point
from ggame.circle import Circle
from ggame.mathapp import MathApp

# P1 is the center of the circle
P1 = Point((0.5, 1))
# P2 is on the perimeter
P2 = Point((1.3, 1))
# define a circle from center and perimeter points
C = Circle(P1, P2)
# allow the user to drag the perimeter point to resize the circle
P2.movable = True

MathApp().run()

center

An ordered pair (x,y) or Point that represents the (logical) circle center. This attribute is only get-able.

radius

A float that represents the radius of the circle. This attribugte is only get-able.

step()

Override in your child class to perform periodic processing.

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this object.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

This method must be overridden.

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

This method must be overridden.

Text Objects

Label

MathApp label classes for displaying text.

class ggame.label.Label(*args, **kwargs)

Create a text label on the screen. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Screen position of the label, which may

  be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.

• text (str) Text to appear in the label. This may be a literal

  string or a reference to any object or function that returns or evaluates to a string.

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ or ‘physical’
• size (int) Size of text font (in pixels)
• width (int) Width of the label (in pixels)
• color (Color) Valid Color object

Example:

"""
Example of using the Label class.
"""

from ggame.asset import Color
from ggame.label import Label
from ggame.mathapp import MathApp

L = Label(
    (20, 80),  # physical location on screen
    "Initial Speed (m/s)",  # text to display
    size=15,  # text size (pixels)
    positioning="physical",  # use physical coordinates
    color=Color(0x202000, 1.0),
)  # text color

MathApp().run()

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this object.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

This method must be overridden.

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

This method must be overridden.

Indicators

MathApp indicator classes for displaying two-state or boolean values.

ImageIndicator

class ggame.indicator.ImageIndicator(url, *args, **kwargs)

Use a sprite sheet image to indicate integer or boolean values.

Required Inputs

Parameters:

• url (str) – Location of image file consisting of a multi-image sprite sheet.
• pos ((float,float)) – Position in physical or logical units. May be a ggame.point.Point instance, a literal (x,y) pair, or a function that returns an (x,y) pair.
• value (int) – The state of the indicator. May be a function that returns a suitable (integer) value.
• **kwargs – See below

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’

• frame (:class:`ggame.asset.Frame`) Sub-frame location of sub-image within

  the main image.

• qty (int) The number of sub-frames, when used as sprite sheet.
• direction (str) One of ‘horizontal’ (default) or ‘vertical’.
• margin (int) Number of pixels between sub-frames if sprite sheet.

Example:

"""
Example of using ImageIndicator class.
"""

from ggame.mathapp import MathApp
from ggame.indicator import ImageIndicator
from ggame.inputpoint import InputImageButton
from ggame.asset import Frame

BUTTON = InputImageButton(
    "images/button-round.png",
    None,
    (40, 105),
    positioning="physical",
    frame=Frame(0, 0, 100, 100),
    qty=2,
)
BUTTON.scale = 0.5

LIGHT = ImageIndicator(
    "images/red-led-off-on.png",
    (100, 100),
    BUTTON,  # button object supplies the indicator state.
    positioning="physical",
    frame=Frame(0, 0, 600, 600),
    qty=2,
)
LIGHT.scale = 0.1

MathApp().run()

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this object.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

This method must be overridden.

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

This method must be overridden.

LEDIndicator

class ggame.indicator.LEDIndicator(*args, **kwargs)

Subclass of ImageIndicator using a red LED on/off image.

Required Inputs

Parameters:

• pos ((float,float)) – Position in physical or logical units. May be a ggame.point.Point instance, a literal (x,y) pair, or a function that returns an (x,y) pair.
• value (int) – The state of the indicator. May be a function that returns a suitable (integer) value.
• **kwargs – See below

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’

Example:

"""
Example of using MathApp LEDIndicator class.
"""
from ggame.mathapp import MathApp
from ggame.indicator import LEDIndicator
from ggame.inputpoint import MetalToggle

TOGGLE = MetalToggle(0, (-1, 0))

SWITCH = LEDIndicator((-1, 0.5), TOGGLE)

MathApp().run()

Input Controls

Slider

MathApp input class for accepting user numeric input with a “slider” control.

class ggame.slider.Slider(*args, **kwargs)

Create a ‘slider’ style numeric input control on the screen. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Screen position of the slider, which may

  be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.

• minval (float) The minimum value of the slider
• maxval (float) The maximum value of the slider
• initial (float) The initial value of the slider

Optional Keyword Arguments:  

• steps (int) Number of steps between minval and maxval (default 50)

• leftkey (str) Name of a keyboard key that will make the

  slider control step down (move left) (default None). See KeyEvent for a list of names.

• rightkey (str) Name of a keyboard key that will make the slider

  control step up (move right) (default None)

• centerkey (str) Name of a keyboard key that will make the slider

  move to its center position (default None)

• positioning (str) One of ‘logical’ or ‘physical’
• size (int) Width of the slider (in pixels)
• color (Color) Valid Color object
• style (LineStyle) Valid LineStyle object

Example:

"""
Example of using Slider class.
"""

from ggame.slider import Slider
from ggame.mathapp import MathApp

S = Slider(
    (100, 150),  # screen position
    0,  # minimum value
    250,  # maximum value
    125,  # initial value
    positioning="physical",  # use physical coordinates for position
    steps=10,
)  # 10 steps between 125 and 250

MathApp().run()

value

Report value of the slider. Attribute is get-able and set-able.

step()

Override in your child class to perform periodic processing.

increment(step)

Increment the slider value.

Parameters:step (float) – The amount by which the slider control should be adjusted. Returns:None

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

unselect()

Place the object in an ‘unselected’ state.

Param:None Returns:None

canstroke(ppos)

Function returns true if the given physical position corresponds with a part of the slider that can be dragged (i.e. the thumb).

Parameters:ppos ((float,float)) – Physical screen coordinates. Returns:True if the position represents a draggable part of the control. Return type:boolean

stroke(ppos, pdisp)

Function performs the action of stroking or click-dragging on the slider control (i.e. dragging the thumb).

Parameters:

• float) ppos ((float,) – Physical screen coordinates.
• float) pdisp ((float,) – Physical displacement vector.

Returns:

None

physicalPointTouching(ppos)

Determine if a physical point is considered to be touching this object.

Parameters:ppos (tuple(int,int)) – Physical screen coordinates. Return type:boolean Returns:True if touching, False otherwise.

This method must be overridden.

physicalPointTouchingThumb(ppos)

Determine if a physical screen location is touching the slider “thumb”.

Parameters:float) ppos ((float,) – Physical screen coordinates. Returns:True if touching, False otherwise. Return type:boolean

translate(pdisp)

Perform necessary processing in response to being moved by the mouse/UI.

Parameters:pdisp (tuple(int,int)) – Translation vector (x,y) in physical screen units. Returns:None

This method must be overridden.

destroy()

Prevent the sprite from being displayed or checked in collision detection. Once this is called, the sprite can no longer be displayed or used. If you only want to prevent a sprite from being displayed, set the visible attribute to False.

InputNumeric

MathApp input classes for accepting user numeric and pushbutton input.

class ggame.input.InputNumeric(pos, val, **kwargs)

Create a Label that can be selected to accept new numeric input from the keyboard. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• pos (tuple(float,float)) – Screen position of the control, which may be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.
• val (float) – Initial value of the input text
• **kwargs – See below

Optional Keyword Arguments:  

• fmt (str) a Python format string (default is {0:.2f})
• positioning (str) One of ‘logical’ or ‘physical’
• size (int) Size of text font (in pixels)
• width (int) Width of the label (in pixels)
• color (Color) Valid Color object

Example:

"""
Example of using InputNumeric class.
"""

from ggame.input import InputNumeric
from ggame.mathapp import MathApp

P = InputNumeric(
    (300, 275),  # screen coordinates of input
    3.14,  # initial value
    positioning="physical",
)  # use physical coordinates

MathApp().run()

processEvent(event)

Inform the object of a generic ggame event.

Parameters:event – The ggame event object to receive and process. Returns:None

This method is intended to be overridden.

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

unselect()

Place the object in an ‘unselected’ state.

Param:None Returns:None

InputButton

class ggame.input.InputButton(callback, *args, **kwargs)

Create a Label that can be clicked with a mouse to execute a user-defined function. This is a subclass of Sprite and _MathVisual but most of the inherited members are of little use and are not shown in the documentation.

Parameters:

• callback (function) – A reference to a function to execute, passing this button object, when the button is clicked
• pos (tuple(float,float)) – Screen position of the control, which may be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.
• val (float) – Initial value of the input text
• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Screen position of the button, which may

  be a literal tuple of floats, or a reference to any object or function that returns or evaluates to a tuple of floats.

• text (str) Text to appear in the button. This may be a literal

  string or a reference to any object or function that returns or evaluates to a string.

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ or ‘physical’
• size (int) Size of text font (in pixels)
• width (int) Width of the label (in pixels)
• color (Color) Valid Color object

Example:

"""
Example of using MathApp InputButton class.
"""
from ggame.input import InputButton
from ggame.mathapp import MathApp


def pressbutton(_button):
    """
    Callback function executed when button is pressed.
    """
    print("InputButton pressed!")


InputButton(
    pressbutton,  # reference to handler
    (20, 80),  # physical location on screen
    "Press Me",  # text to display
    size=15,  # text size (pixels)
    positioning="physical",
)  # use physical coordinates

MathApp().run()

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

MathApp GUI input pushbutton and toggle controls.

InputImageButton

class ggame.inputpoint.InputImageButton(url, callback, *args, **kwargs)

ImagePoint object that uses an image as its on-screen and

activates a callback function when pressed.

Required Arguments:   Parameters:

• url (str) – Location of an image file (png, jpg)
• callback (function) – Reference to a function to execute, passing this button object.
• *args – See below
• **kwargs – See below

Required Arguments:  

• pos (tuple(float,float)) Position in physical or logical units.

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’
• frame (Frame) The sub-frame location of image within the image file
• qty (int) The number of sub-frames, when used as a sprite sheet
• direction (str) One of ‘horizontal’ (default) or ‘vertical’
• margin (int) Pixels between sub-frames if sprite sheet

Example:

"""
Example of using the InputImageButton class.
"""
from ggame.inputpoint import InputImageButton
from ggame.mathapp import MathApp
from ggame.asset import Frame


def pressbutton(_button):
    """
    Callback function executed when button is pressed.
    """
    print("Button Pressed!")


BUTTON = InputImageButton(
    "images/button-round.png", pressbutton, (0, 0), frame=Frame(0, 0, 100, 100), qty=2
)
BUTTON.scale = 0.5

MathApp().run()

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

InputImageToggle

class ggame.inputpoint.InputImageToggle(url, statelist, initindex, *args, **kwargs)

Spritesheet-based input control that toggles through a set of states with each mouseclick.

Required Inputs:   Parameters:

• url (str) – Location of image file consisting of a multi-image sprite sheet.
• statelist (list) – List of values to correspond with toggle states.
• initindex (int) – Index to initial toggle state.
• pos ((float,float)) – Position in physical or logical units. May be a ggame.point.Point instance, a literal (x,y) pair, or a function that returns an (x,y) pair.
• **kwargs – See below

Optional Keyword Arguments:  

• positioning (str) One of ‘logical’ (default) or ‘physical’

• frame (:class:`ggame.asset.Frame`) Sub-frame location of sub-image within

  the main image.

• direction (str) One of ‘horizontal’ (default) or ‘vertical’.
• margin (int) Number of pixels between sub-frames if sprite sheet.

select()

Place the object in a ‘selected’ state.

Param:None Returns:None

MetalToggle

class ggame.inputpoint.MetalToggle(initindex, *args, **kwargs)

Metal toggle input control that toggles through two states with each mouseclick.

Required Inputs:   Parameters:

• initindex (int) – Index to initial toggle state (0 or 1).
• pos ((float,float)) – Position in physical or logical units. May be a ggame.point.Point instance, a literal (x,y) pair, or a function that returns an (x,y) pair.

Example:

"""
Example of using MathApp LEDIndicator class.
"""
from ggame.mathapp import MathApp
from ggame.indicator import LEDIndicator
from ggame.inputpoint import MetalToggle

TOGGLE = MetalToggle(0, (-1, 0))

SWITCH = LEDIndicator((-1, 0.5), TOGGLE)

MathApp().run()

GlassButton

class ggame.inputpoint.GlassButton(callback, *args, **kwargs)

Glass button input control that triggers a callback when clicked.

Required Inputs:   Parameters:

• callback (function) – Reference to a function to execute, passing this button object as an argument.
• pos ((float,float)) – Position in physical or logical units. May be a ggame.point.Point instance, a literal (x,y) pair, or a function that returns an (x,y) pair.

Example:

"""
Example of using GlassButton class.
"""
from ggame.inputpoint import GlassButton
from ggame.mathapp import MathApp


def pressbutton(_button):
    """
    Callback function executed when button is pressed.
    """
    print("Button Pressed!")


BUTTON = GlassButton(pressbutton, (0, 0))

MathApp().run()

Time Utility

MathApp class for creating periodic and timed callbacks.

Timer

class ggame.timer.Timer

The Timer class instantiates an object whose basic function is to report the number of seconds since its creation by calling the object as a function with an empty argument list.

The Timer class accepts no arguments during creation.

Example of use:

"""
Example of using the Timer class.
"""

from ggame.timer import Timer
from ggame.mathapp import MathApp


def timercallback(t):
    """
    Callback function to receive notification of timer expiration.
    """
    print("time's up at", t.time, "seconds!")


TIMER = Timer()
# Execute timercallback after 5 seconds
TIMER.callAfter(5, timercallback)

MathApp().run()

reset()

Set the reference time to the MathApp current time. If the timer is reset before the app initializes then do nothing.

Returns:None

time

Attribute is always updated with the number of seconds since the timer was created.

step()

Override in your child class to perform periodic processing.

callAfter(delay, callback, periodic=False)

Set a callback to occur either once or periodically. The callback function should accept a single parameter which will be a reference to the timer object that called it.

Parameters:

• delay (float) – The number of seconds to wait before executing the callback function
• callback (function) – The callback function to call on timer expiration
• periodic (boolean) – Set True if the callback function should be executed periodically

Returns:

None

callAt(calltime, callback)

Set a callback to occur at a specific time (seconds since the Timer object was created or since its reset() method was called.

Parameters:

• time (float) – The time to wait since timer creation or reset before calling the callback function.
• callback (function) – The callback function to call

Returns:

None

callEvery(period, callback)

Set a callback to occur periodically. The callback function should accept a single parameter which will be a reference to the timer object that called it.

Parameters:

• period (float) – The number of seconds to wait before each execution of the callback function
• callback (function) – The callback function to call on timer expiration

Returns:

None