Panda3D

- Main Page
- Packages
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Public Attributes | Static Public Attributes

# MetaInterval Class Reference

Inheritance diagram for MetaInterval:

List of all members.

## Public Member Functions
def | __init__
def | __add__
def | __delitem__
def | __delslice__
def | __getitem__
def | __getslice__
def | __iadd__
def | __len__
def | __repr__
def | __setitem__
def | __setslice__
def | __str__
def | addInterval
def | addParallel
def | addParallelEndTogether
def | addSequence
def | addTrack
def | append
def | applyIvals
def | clearIntervals
def | clearToInitial
def | count
def | extend
def | finish
def | getDuration
def | getIntervalStartTime
def | getManager
def | index
def | insert
def | loop
def | pause
def | pop
def | privDoEvent
def | privPostEvent
def | remove
def | resume
def | resumeUntil
def | reverse
def | setIntervalStartTime
def | setManager
def | setPlayRate
def | setT
def | sort
def | start
def | timeline
def | validateComponent
def | validateComponents
## Public Attributes
| inPython
| ivals
| phonyDuration
| pname
| pstats
| pythonIvals
## Static Public Attributes
tuple | notify = directNotify.newCategory("MetaInterval")
int | SequenceNum = 1

## Constructor & Destructor Documentation

def __init__ | ( |  | self,
|  |  | ivals,
|  |  | kw
| ) |  |

## Member Function Documentation

def __add__ | ( |  | self,
|  |  | other
| ) |  |

def __delitem__ | ( |  | self,
|  |  | index
| ) |  |

def __delslice__ | ( |  | self,
|  |  | i,
|  |  | j
| ) |  |

def __getitem__ | ( |  | self,
|  |  | index
| ) |  |

def __getslice__ | ( |  | self,
|  |  | i,
|  |  | j
| ) |  |

def __iadd__ | ( |  | self,
|  |  | other
| ) |  |

def __len__ | ( |  | self | ) |

def __repr__ | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

def __setitem__ | ( |  | self,
|  |  | index,
|  |  | value
| ) |  |

def __setslice__ | ( |  | self,
|  |  | i,
|  |  | j,
|  |  | s
| ) |  |

def __str__ | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

def addInterval | ( |  | self,
|  |  | ival,
|  |  | relTime,
|  |  | relTo
| ) |  |

def addParallel | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration
| ) |  |

def addParallelEndTogether | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration
| ) |  |

def addSequence | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration
| ) |  |

def addTrack | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration
| ) |  |

def append | ( |  | self,
|  |  | ival
| ) |  |

def applyIvals | ( |  | self,
|  |  | meta,
|  |  | relTime,
|  |  | relTo
| ) |  |

Reimplemented in Sequence, Parallel, ParallelEndTogether, and Track.

def clearIntervals | ( |  | self | ) |

def clearToInitial | ( |  | self | ) |

def count | ( |  | self,
|  |  | ival
| ) |  |

def extend | ( |  | self,
|  |  | ivals
| ) |  |

def finish | ( |  | self | ) |

def getDuration | ( |  | self | ) |

def getIntervalStartTime | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

def getManager | ( |  | self | ) |

def index | ( |  | self,
|  |  | ival
| ) |  |

def insert | ( |  | self,
|  |  | index,
|  |  | ival
| ) |  |

def loop | ( |  | self,
|  |  | startT = `0.0`,
|  |  | endT = `-1.0`,
|  |  | playRate = `1.0`
| ) |  |

def pause | ( |  | self | ) |

def pop | ( |  | self,
|  |  | index = `None`
| ) |  |

def privDoEvent | ( |  | self,
|  |  | t,
|  |  | event
| ) |  |

def privPostEvent | ( |  | self | ) |

def remove | ( |  | self,
|  |  | ival
| ) |  |

def resume | ( |  | self,
|  |  | startT = `None`
| ) |  |

def resumeUntil | ( |  | self,
|  |  | endT
| ) |  |

def reverse | ( |  | self | ) |

def setIntervalStartTime | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

def setManager | ( |  | self,
|  |  | manager
| ) |  |

def setPlayRate | ( |  | self,
|  |  | playRate
| ) |  |

    Changes the play rate of the interval.  If the interval is
    already started, this changes its speed on-the-fly.  Note that
    since playRate is a parameter to start() and loop(), the next
    call to start() or loop() will reset this parameter.

def setT | ( |  | self,
|  |  | t
| ) |  |

def sort | ( |  | self,
|  |  | cmpfunc = `None`
| ) |  |

def start | ( |  | self,
|  |  | startT = `0.0`,
|  |  | endT = `-1.0`,
|  |  | playRate = `1.0`
| ) |  |

def timeline | ( |  | self,
|  |  | out = `None`
| ) |  |

def validateComponent | ( |  | self,
|  |  | component
| ) |  |

Reimplemented in Track.

def validateComponents | ( |  | self,
|  |  | components
| ) |  |

## Member Data Documentation

inPython

ivals

tuple notify = directNotify.newCategory("MetaInterval")`[static]`

phonyDuration

pname

pstats

pythonIvals

int SequenceNum = 1`[static]`

All Classes Namespaces Functions Variables Enumerations Enumerator Properties