def __init__ (self):
    self.GoTo(0,0)
    self.Color(0)
    self.PenUp() 
    self.SetAngle(0)

def Color(self, color):
    self.color = Color(color,1)

def GoTo(self, x, y):
    self.pos = (x,y)

def Left(self, da):
    self.angle = self.angle + da

def Move(self, d):
    next = (self.pos[0] + d*cos(self.angle), self.pos[1] + d*sin(self.angle))
    LineSegment(Point(self.pos, 0), Point(next, 0), LineStyle(1, self.color))
    self.pos = next

def PenDown(self):
    self.down = True

def PenUp(self):
    self.down = False

def Right(self, da):
    self.angle = self.angle - da

def SetAngle(self, a):
    self.angle = a

def __init__(self, *args, **kwargs):
    """
    Required Inputs
    
    * **pos** center of circle
    * **radius** radius of circle (logical) or point on circle
    
    Optional Inputs
    
    * **style** border line style (thickness, color)
    * **color** fill color
    """
    """
    Radius may be scalar or point
    """
    super().__init__(CircleAsset(0, self.defaultstyle, self.defaultcolor), *args, **kwargs)
    self._touchAsset()
    self.fxcenter = self.fycenter = 0.5

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    r = MathApp.distance(self._pcenter, ppos)
    inner = self._pradius - self.style.width/2
    outer = self._pradius + self.style.width/2
    return r <= outer and r >= inner

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, callback, *args, **kwargs):
    """
    Required Inputs
    
    * **callback** reference of a function to execute, passing this button object
    * **pos** position of point
    """        
    kwargs.setdefault('frame', Frame(0,0,100,100))
    kwargs.setdefault('qty', 2)
    super().__init__("button-round.png", callback, *args, **kwargs)
    self.scale = 0.3

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    if self._callback: self._callback(self)
    self.unselect()

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    super().unselect()

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, url, *args, **kwargs):
    """
    Required Inputs
    
    * **url** location of image file consisting of two image sprite sheet
    * **pos** position of point
    * **value** state of the indicator (True/False or integer)
    Optional Inputs
    * **frame** sub-frame location of image within file
    * **qty** number of sub-frames, when used as sprite sheet
    * **direction** one of 'horizontal' (default) or 'vertical'
    * **margin** pixels between sub-frames if sprite sheet
    """
    kwargs.setdefault('frame', None)
    kwargs.setdefault('qty', 1)
    kwargs.setdefault('direction', 'horizontal')
    kwargs.setdefault('margin', 0)
    super().__init__(
        ImageAsset(url, 
            kwargs['frame'], 
            kwargs['qty'], 
            kwargs['direction'], 
            kwargs['margin']), 
        *args, **kwargs)
    self.center = (0,0)

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, url, *args, **kwargs):
    """
    Required Inputs
    
    * **url** location of image file
    * **pos** position of point
    
    Optional Inputs
    * **frame** sub-frame location of image within file
    * **qty** number of sub-frames, when used as sprite sheet
    * **direction** one of 'horizontal' (default) or 'vertical'
    * **margin** pixels between sub-frames if sprite sheet
    """
    frame = kwargs.get('frame', None)
    qty = kwargs.get('qty', 1)
    direction = kwargs.get('direction', 'horizontal')
    margin = kwargs.get('margin', 0)
    self._imageasset = ImageAsset(url, frame, qty, direction, margin)
    super().__init__(self._imageasset, *args, **kwargs)

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, callback, *args,  **kwargs):
    """
    Required Inputs
    
    * **pos** position of button
    * **text** text of button
    * **callback** reference of a function to execute, passing this button object
    """
    super().__init__(*args, **kwargs)
    self._touchAsset()
    self._callback = callback
    self.selectable = True

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    _ppos = self.spposinputs.pos
    return (ppos[0] >= _ppos[0] and 
        ppos[0] <= _ppos[0] + self.sstdinputs.width and
        ppos[1] >= _ppos[1] and 
        ppos[1] <= _ppos[1] + self.sstdinputs.size)

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    if self._callback: self._callback(self)
    self.unselect()

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    super().unselect()

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, url, callback, *args, **kwargs):
    """
    Required Inputs
    
    * **url** location of image file
    * **callback** reference of a function to execute, passing this button object
    * **pos** position of point
    
    Optional Inputs
    * **frame** sub-frame location of image within file
    * **qty** number of sub-frames, when used as sprite sheet
    * **direction** one of 'horizontal' (default) or 'vertical'
    * **margin** pixels between sub-frames if sprite sheet
    """
    super().__init__(url, *args, **kwargs)
    self.center = (0,0)
    self._callback = callback
    self.selectable = True
    self.firstImage()
    self.mousewasdown = self.mouseisdown

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    if self._callback: self._callback(self)
    self.unselect()

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    super().unselect()

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, url, statelist, initindex, *args, **kwargs):
    """
    Required Inputs
    
    * **url** location of image file
    * **statelist** list of values to correspond with toggle states
    * **initindex** index to initial toggle state
    * **pos** position of point
    
    Optional Inputs
    * **frame** sub-frame location of image within file
    * **direction** for sprite sheet one of 'horizontal' (default) or 'vertical'
    * **margin** pixels between sub-frames if sprite sheet
    * Note the qty of images is equal to length of the statelist
    """
    self.statelist = statelist
    kwargs.setdefault('qty', len(statelist))
    super().__init__(url, *args, **kwargs)
    self.center = (0,0)
    self.selectable = True
    self.togglestate = initindex
    self.setImage(self.togglestate)

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    self.togglestate += 1
    if self.togglestate == len(self.statelist):
        self.togglestate = 0
    self.setImage(self.togglestate)
    self.unselect()

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, pos, val, **kwargs):
    """
    Required Inputs
    
    * **pos** position of button
    * **val** initial value of input
    
    Optional Keyword Input
    * **fmt** a Python format string (default is {0.2})
    """
    self._fmt = kwargs.get('fmt', '{0.2}')
    self._val = self.Eval(val)()  # initialize to simple numeric
    self._savedval = self._val
    self._updateText()
    super().__init__(pos, self._textValue, **kwargs)
    self.selectable = True

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    _ppos = self.spposinputs.pos
    return (ppos[0] >= _ppos[0] and 
        ppos[0] <= _ppos[0] + self.sstdinputs.width and
        ppos[1] >= _ppos[1] and 
        ppos[1] <= _ppos[1] + self.sstdinputs.size)

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    if event.key in "0123456789insertdelete":
        key = event.key
        if event.key == 'insert':
            key = '-'
        elif event.key == 'delete':
            key = '.'
        if self._text() == "0":
            self._text = self.Eval("")
        self._text = self.Eval(self._text() + key)
        self._touchAsset()
    elif event.key in ['enter','escape']:
        if event.key == 'enter':
            try:
                self._val = float(self._text())
            except ValueError:
                self._val = self._savedval
            self._savedval = self._val
        self.unselect()

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    self._savedval = self._val
    self._val = 0
    self._updateText()
    self._touchAsset()
    MathApp.listenKeyEvent("keypress", "*", self.processEvent)

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    super().unselect()
    self._val = self._savedval
    self._updateText()
    self._touchAsset()
    try:
        MathApp.unlistenKeyEvent("keypress", "*", self.processEvent)
    except ValueError:
        pass

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, *args, **kwargs):
    """
    Required Inputs
    
    * **pos** position of point
    * **value** state of the indicator (True/False or integer)
    """
    kwargs.setdefault('frame', Frame(0,0,600,600))
    kwargs.setdefault('qty', 2)
    super().__init__("red-led-off-on.png", *args, **kwargs)
    self.scale = 0.05

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, *args, **kwargs):
    """
    Required Inputs
    
    * **pos** position of label
    * **text** text contents of label
    """
    super().__init__(TextAsset(""), *args, **kwargs)
    self._touchAsset()

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    _ppos = self.spposinputs.pos
    return (ppos[0] >= _ppos[0] and 
        ppos[0] <= _ppos[0] + self.sstdinputs.width and
        ppos[1] >= _ppos[1] and 
        ppos[1] <= _ppos[1] + self.sstdinputs.size)

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, *args, **kwargs):
    """
    Required Inputs
    
    * **pos** start position of segment
    * **end** end position of segment
    
    Optional Inputs
    
    * **style** line style (thickness, color)
    """
    super().__init__(LineAsset(0,0, self.defaultstyle), *args, **kwargs)
    self._touchAsset()

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    return False

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    pass

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, scale=_scale):
    super().__init__()
    MathApp.width = self.width
    MathApp.height = self.height
    MathApp._scale = scale   # pixels per unit
    # register event callbacks
    self.listenMouseEvent("click", self.handleMouseClick)
    self.listenMouseEvent("mousedown", self.handleMouseDown)
    self.listenMouseEvent("mouseup", self.handleMouseUp)
    self.listenMouseEvent("mousemove", self.handleMouseMove)
    self.listenMouseEvent("wheel", self.handleMouseWheel)
    self.mouseDown = False
    self.mouseCapturedObject = None
    self.mouseStrokedObject = None
    self.mouseDownObject = None
    self.mouseX = self.mouseY = None
    self._touchAllVisuals()
    self.selectedObj = None
    MathApp.time = time()

def handleMouseClick(self, event):
    found = False
    for obj in self._mathSelectableList:
        if obj.physicalPointTouching((event.x, event.y)):
            found = True
            if not obj.selected: 
                obj.select()
                self.selectedObj = obj
    if not found and self.selectedObj:
        self.selectedObj.unselect()
        self.selectedObj = None

def handleMouseDown(self, event):
    self.mouseDown = True
    self.mouseCapturedObject = None
    self.mouseStrokedObject = None
    for obj in self._mathSelectableList:
        if obj.physicalPointTouching((event.x, event.y)):
            obj.mousedown()
            self.mouseDownObject = obj
            break
    for obj in self._mathMovableList:
        if obj.physicalPointTouching((event.x, event.y)) and not (obj.strokable and obj.canstroke((event.x,event.y))):
            self.mouseCapturedObject = obj
            break
    if not self.mouseCapturedObject:
        for obj in self._mathStrokableList:
            if obj.canstroke((event.x, event.y)):
                self.mouseStrokedObject = obj
                break

def handleMouseMove(self, event):
    if not self.mouseX:
        self.mouseX = event.x
        self.mouseY = event.y
    dx = event.x - self.mouseX
    dy = event.y - self.mouseY
    self.mouseX = event.x
    self.mouseY = event.y
    if self.mouseDown:
        if self.mouseCapturedObject:
            self.mouseCapturedObject.translate((dx, dy))
        elif self.mouseStrokedObject:
            self.mouseStrokedObject.stroke((self.mouseX,self.mouseY), (dx,dy))
        else:
            lmove = self.translatePhysicalToLogical((dx, dy))
            MathApp._xcenter -= lmove[0]
            MathApp._ycenter -= lmove[1]
            self._touchAllVisuals()
            self._viewNotify("translate")

def handleMouseUp(self, event):
    if self.mouseDownObject:
        self.mouseDownObject.mouseup()
        self.mouseDownObject = None
    self.mouseDown = False
    self.mouseCapturedObject = None
    self.mouseStrokedObject = None

def handleMouseWheel(self, event):
    zoomfactor = event.wheelDelta/100
    zoomfactor = 1+zoomfactor if zoomfactor > 0 else 1+zoomfactor
    if zoomfactor > 1.2:
        zoomfactor = 1.2
    elif zoomfactor < 0.8:
        zoomfactor = 0.8
    MathApp._scale *= zoomfactor
    self._touchAllVisuals()
    self._viewNotify("zoom")

def run(self, userfunc = None):
    """
    Calling the `ggame.App.run` method begins the animation process whereby the 
    `ggame.App.step` method is called once per animation frame. Set `userfunc`
    to any function which shall be called once per animation frame.
    """
    self.userfunc = userfunc
    App._win.animate(self._animate)

def step(self):
    MathApp.time = time()
    for spr in self._mathDynamicList:
        spr.step()

@classmethod   
def addViewNotification(cls, handler):
    cls._viewNotificationList.append(handler)

@classmethod   
def distance(cls, pos1, pos2):
    return sqrt((pos2[0]-pos1[0])**2 + (pos2[1]-pos1[1])**2)

@classmethod
def getSpritesbyClass(cls, sclass):
    """
    Returns a list of all active sprites of a given class.
    """
    return App._spritesdict.get(sclass, [])

@classmethod
def listenKeyEvent(cls, eventtype, key, callback):
    """
    Register to receive keyboard events. The `eventtype` parameter is a 
    string that indicates what type of key event to receive (value is one
    of: `'keydown'`, `'keyup'` or `'keypress'`). The `key` parameter is a 
    string indicating which key (e.g. `'space'`, `'left arrow'`, etc.) to 
    receive events for. The `callback` parameter is a reference to a 
    function or method that will be called with the `ggame.KeyEvent` object
    when the event occurs.
    See the source for `ggame.KeyEvent.keys` for a list of key names
    to use with the `key` paramter.
    """
    evtlist = App._eventdict.get((eventtype, key), [])
    if not callback in evtlist:
        evtlist.append(callback)
    App._eventdict[(eventtype, key)] = evtlist

@classmethod
def listenMouseEvent(cls, eventtype, callback):
    """
    Register to receive mouse events. The `eventtype` parameter is
    a string that indicates what type of mouse event to receive (
    value is one of: `'mousemove'`, `'mousedown'`, `'mouseup'`, `'click'`, 
    `'dblclick'` or `'mousewheel'`). The `callback` parameter is a 
    reference to a function or method that will be called with the 
    `ggame.MouseEvent` object when the event occurs.
    """
    evtlist = App._eventdict.get(eventtype, [])
    if not callback in evtlist:
        evtlist.append(callback)
    App._eventdict[eventtype] = evtlist

@classmethod
def logicalToPhysical(cls, lp):
    xxform = lambda xvalue, xscale, xcenter, physwidth: int((xvalue-xcenter)*xscale + physwidth/2)
    yxform = lambda yvalue, yscale, ycenter, physheight: int(physheight/2 - (yvalue-ycenter)*yscale)
    try:
        return (xxform(lp[0], cls._scale, cls._xcenter, cls._win.width),
            yxform(lp[1], cls._scale, cls._ycenter, cls._win.height))
    except AttributeError:
        return lp

@classmethod
def physicalToLogical(cls, pp):
    xxform = lambda xvalue, xscale, xcenter, physwidth: (xvalue - physwidth/2)/xscale + xcenter
    yxform = lambda yvalue, yscale, ycenter, physheight: (physheight/2 - yvalue)/yscale + ycenter
    try:
        return (xxform(pp[0], cls._scale, cls._xcenter, cls._win.width),
            yxform(pp[1], cls._scale, cls._ycenter, cls._win.height))
    except AttributeError:
        return pp

@classmethod   
def removeViewNotification(cls, handler):
    cls._viewNotificationList.remove(handler)

@classmethod
def translateLogicalToPhysical(cls, pp):
    xxform = lambda xvalue, xscale: xvalue*xscale
    yxform = lambda yvalue, yscale: -yvalue*yscale
    try:
        return (xxform(pp[0], cls._scale), yxform(pp[1], cls._scale))
    except AttributeError:
        return pp

@classmethod
def translatePhysicalToLogical(cls, pp):
    xxform = lambda xvalue, xscale: xvalue/xscale
    yxform = lambda yvalue, yscale: -yvalue/yscale
    try:
        return (xxform(pp[0], cls._scale), yxform(pp[1], cls._scale))
    except AttributeError:
        return pp

@classmethod
def unlistenKeyEvent(cls, 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.
    """
    App._eventdict[(eventtype,key)].remove(callback)

@classmethod
def unlistenMouseEvent(cls, 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.
    """
    App._eventdict[eventtype].remove(callback)

def __init__(self, initindex, *args, **kwargs):
    """
    Required Inputs
    
    * **initindex** index to initial toggle state
    * **pos** position of toggle
    """
    kwargs.setdefault('frame', Frame(0,0,110,150))
    super().__init__("toggle-up-down.png", [True, False], initindex, *args, **kwargs)
    self.scale = 0.4

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    self._setExtents()  # ensure xmin, xmax are correct
    x, y = ppos
    return x >= self.xmin and x < self.xmax and y >= self.ymin and y <= self.ymax

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    self.togglestate += 1
    if self.togglestate == len(self.statelist):
        self.togglestate = 0
    self.setImage(self.togglestate)
    self.unselect()

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, *args, **kwargs):
    """
    Required Inputs
    
    * **pos** position of point
    """
    super().__init__(CircleAsset(self.defaultsize, 
        self.defaultstyle, self.defaultcolor), *args, **kwargs)

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return False

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def distanceTo(self, otherpoint):
    try:
        pos = self.posinputs.pos
        opos = otherpoint.posinputs.pos
        return MathApp.distance(pos, opos())
    except AttributeError:
        return otherpoint  # presumably a scalar - use this distance

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    return MathApp.distance(ppos, self.pposinputs.pos) < self.sstdinputs.size

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    self.selected = True

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def step(self):
    pass  # FIXME
    self._touchAsset()

def stroke(self, ppos, pdisp):
    pass

def translate(self, pdisp):
    ldisp = MathApp.translatePhysicalToLogical(pdisp)
    pos = self.posinputs.pos()
    self.posinputs = self.posinputs._replace(pos=self.Eval((pos[0] + ldisp[0], pos[1] + ldisp[1])))
    self._touchAsset()

def unselect(self):
    self.selected = False

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self, *args, **kwargs):
    super().__init__(
        RectangleAsset(1, 1), *args, **kwargs)
    self._val = self.nposinputs.initial()
    self._steps = kwargs.get('steps', 50)
    self._step = (self.nposinputs.maxval()-self.nposinputs.minval())/self._steps
    self._leftctrl = kwargs.get('leftkey', None)
    self._rightctrl = kwargs.get('rightkey', None)
    self._centerctrl = kwargs.get('centerkey', None)
    self.selectable = True  # must be after super init!
    self.strokable = True  # this enables grabbing/slideing the thumb
    self.thumbcaptured = False
    self._thumbwidth = max(self.stdinputs.width()/40, 1)
    self.thumb = Sprite(RectangleAsset(self._thumbwidth, 
        self.stdinputs.size()-2, LineStyle(1, self.stdinputs.color()), self.stdinputs.color()), 
        self.thumbXY())
    self._touchAsset()
    if self._leftctrl:
        MathApp.listenKeyEvent("keydown", self._leftctrl, self.moveLeft)
    if self._rightctrl:
        MathApp.listenKeyEvent("keydown", self._rightctrl, self.moveRight)
    if self._centerctrl:
        MathApp.listenKeyEvent("keydown", self._centerctrl, self.moveCenter)

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def canstroke(self, ppos):
    return self.physicalPointTouchingThumb(ppos)

def circularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def collidingPolyWithPoly(self, obj):
    return True

def collidingWith(self, obj):
    """
    Return a boolean True if this sprite is currently overlapping the sprite 
    referenced by `obj`. Returns False if checking for collision with 
    itself. Returns False if extents of object make it impossible for
    collision to occur. Returns True if sprite's `edgedef` parameter overlaps
    with other sprite's `edgedef` parameter, taking into consideration both
    sprites' center, rotation and scale settings.
    """
    if self is obj:
        return False
    else:
        self._setExtents()
        obj._setExtents()
        # Gross check for overlap will usually rule out a collision
        if (self.xmin > obj.xmax
            or self.xmax < obj.xmin
            or self.ymin > obj.ymax
            or self.ymax < obj.ymin):
            return False
        # Otherwise, perform a careful overlap determination
        elif type(self.asset) is CircleAsset:
            if type(obj.asset) is CircleAsset:
                # two circles .. check distance between
                sx = (self.xmin + self.xmax) / 2
                sy = (self.ymin + self.ymax) / 2
                ox = (obj.xmin + obj.xmax) / 2
                oy = (obj.ymin + obj.ymax) / 2
                d = math.sqrt((sx-ox)**2 + (sy-oy)**2)
                return d <= self.width/2 + obj.width/2
            else:
                return self.collidingCircleWithPoly(self, obj)
        else:
            if type(obj.asset) is CircleAsset:
                return self.collidingCircleWithPoly(obj, self)
            else:
                return self.collidingPolyWithPoly(obj)

def collidingWithSprites(self, sclass = None):
    """
    Return a list of sprite objects identified by the `sclass` parameter
    that are currently colliding with (that is, with which the `ggame.Sprite.collidingWith`
    method returns True) this sprite. If `sclass` is set to `None` (default), then
    all other sprites are checked for collision, otherwise, only sprites whose
    class matches `sclass` are checked.
    """
    if sclass is None:
        slist = App.spritelist
    else:
        slist = App.getSpritesbyClass(sclass)
    return list(filter(self.collidingWith, slist))

def destroy(self):
    MathApp._removeVisual(self)
    MathApp._removeMovable(self)
    MathApp._removeStrokable(self)
    _MathDynamic.destroy(self)
    Sprite.destroy(self)

def firstImage(self):
    """
    Select and display the *first* image used by this sprite.
    """
    self.GFX.texture = self.asset[0]

def increment(self, step):
    self._setval(self._val + step)

def lastImage(self):
    """
    Select and display the *last* image used by this sprite.
    """
    self.GFX.texture = self.asset[-1]

def mouseClick(self, event):
    if self.physicalPointTouching((event.x, event.y)):
        if event.x > self.thumb.x + self._thumbwidth:
            self.moveRight(event)
        elif event.x < self.thumb.x:
            self.moveLeft(event)

def mousedown(self):
    self.mouseisdown = True

def mouseup(self):
    self.mouseisdown = False

def moveCenter(self, event):
    self._val = (self.snposinputs.minval + self.snposinputs.maxval)/2
    self.setThumb()

def moveLeft(self, event):
    self.increment(-self._step)

def moveRight(self, event):
    self.increment(self._step)

def nextImage(self, wrap = False):
    """
    Select and display the *next* image used by this sprite.
    If the current image is already the *last* image, then
    the image is not advanced.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.nextImage` on the last image will cause the *first*
    image to be loaded.
    """
    self._index += 1
    if self._index >= len(self.asset):
        if wrap:
            self._index = 0
        else:
            self._index = len(self.asset)-1
    self.GFX.texture = self.asset[self._index]

def physicalPointTouching(self, ppos):
    _ppos = self.spposinputs.pos
    return (ppos[0] >= _ppos[0] and 
        ppos[0] <= _ppos[0] + self.sstdinputs.width and
        ppos[1] >= _ppos[1] and 
        ppos[1] <= _ppos[1] + self.sstdinputs.size)

def physicalPointTouchingThumb(self, ppos):
    thumbpos = self.thumbXY()
    return (ppos[0] >= thumbpos[0] and 
        ppos[0] <= thumbpos[0] + self._thumbwidth + 2 and
        ppos[1] >= thumbpos[1] and 
        ppos[1] <= thumbpos[1] + self.sstdinputs.size - 2)

def prevImage(self, wrap = False):
    """
    Select and display the *previous* image used by this sprite.
    If the current image is already the *first* image, then
    the image is not changed.
    If the optional `wrap` parameter is set to `True`, then calling
    `ggame.Sprite.prevImage` on the first image will cause the *last*
    image to be loaded.
    """
    self._index -= 1
    if self._index < 0:
        if wrap:
            self._index = len(self.asset)-1
        else:
            self._index = 0
    self.GFX.texture = self.asset[self._index]

def processEvent(self, event):
    pass

def rectangularCollisionModel(self):
    """
    Obsolete. No op.
    """
    pass

def select(self):
    super().select()
    if not self._leftctrl:
        MathApp.listenKeyEvent("keydown", "left arrow", self.moveLeft)
    if not self._rightctrl:
        MathApp.listenKeyEvent("keydown", "right arrow", self.moveRight)
    MathApp.listenMouseEvent("click", self.mouseClick)

def setImage(self, index=0):
    """
    Select the image to display by giving its `index`, where an index
    of zero represents the *first* image in the asset.
    This is equivalent to setting the `ggame.Sprite.index` property
    directly.
    """
    self.index = index

def setThumb(self):
    self.thumb.position = self.thumbXY()

def step(self):
    pass

def stroke(self, ppos, pdisp):
    _ppos = self.spposinputs.pos
    minval = self.snposinputs.minval
    maxval = self.snposinputs.maxval
    xpos = ppos[0] + pdisp[0]
    self.value = (xpos - _ppos[0])*(maxval-minval)/self.sstdinputs.width + minval

def thumbXY(self):
    minval = self.nposinputs.minval()
    maxval = self.nposinputs.maxval()
    return (self.spposinputs.pos[0]+(self._val-minval)*
            (self.sstdinputs.width-self._thumbwidth)/(maxval-minval),
            self.spposinputs.pos[1]+1)

def translate(self, pdisp):
    pass

def unselect(self):
    super().unselect()
    try:
        if not self._leftctrl:
            MathApp.unlistenKeyEvent("keydown", "left arrow", self.moveLeft)
        if not self._rightctrl:
            MathApp.unlistenKeyEvent("keydown", "right arrow", self.moveRight)
        MathApp.unlistenMouseEvent("click", self.mouseClick)
    except ValueError:
        pass

@classmethod
def collidingCircleWithPoly(cls, circ, poly):
    return True

def __init__(self):
    super().__init__()
    self.once = []
    self.callbacks = {}
    self.reset()
    self.step()
    self._start = self._reset  #first time
    self.next = None
    MathApp._addDynamic(self)  # always dynamically defined

def Eval(self, val):
    if callable(val):
        self._setDynamic() # dynamically defined .. must step
        return val
    else:
        return lambda : val  

def callAfter(self, delay, callback, periodic=False):
    key = (MathApp.time + delay, delay if periodic else 0)
    self.once.append(key)
    callbacklist = self.callbacks.get(key, [])
    callbacklist.append(callback)
    self.callbacks[key] = callbacklist
    self.once.sort()

def callAt(self, time, callback):
    self.callAfter(time-self.time, callback)

def callEvery(self, period, callback):
    self.callAfter(period, callback, True)

def destroy(self):
    MathApp._removeDynamic(self)

def reset(self):
    self._reset = MathApp.time

def step(self):
    nexttimers = []
    calllist = []
    self.time = MathApp.time - self._reset
    while self.once and self.once[0][0] <= MathApp.time:
        tickinfo = self.once.pop(0)
        if tickinfo[1]:  # periodic?
            nexttimers.append((tickinfo[1], self.callbacks[tickinfo][0]))  # delay, callback
        calllist.append(self.callbacks[tickinfo].pop(0)) # remove callback and queue it
        if not self.callbacks[tickinfo]: # if the callback list is empty
            del self.callbacks[tickinfo] # remove the dictionary entry altogether
    for tickadd in nexttimers:
        self.callAfter(tickadd[0], tickadd[1], True)  # keep it going
    for call in calllist:
        call(self)