1412101829
2 2
10 libp3event 4 _0BP 12 panda3d.core 
223
228 9 get_state 0 4 451 20 AsyncTask::get_state 0 1 1 743
// Filename: asyncTask.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_state
//       Access: Published
//  Description: Returns the current state of the task.
////////////////////////////////////////////////////////////////////
57
inline AsyncTask::State AsyncTask::get_state(void) const;

229 8 is_alive 0 4 451 19 AsyncTask::is_alive 0 1 2 612
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::is_alive
//       Access: Published
//  Description: Returns true if the task is currently active or
//               sleeping on some task chain, meaning that it will be
//               executed in its turn, or false if it is not active.
//               If the task has recently been removed while it is in
//               the middle of execution, this will return false,
//               because the task will not run again once it finishes.
////////////////////////////////////////////////////////////////////
44
inline bool AsyncTask::is_alive(void) const;

230 11 get_manager 0 4 451 22 AsyncTask::get_manager 0 1 3 343
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_manager
//       Access: Published
//  Description: Returns the AsyncTaskManager that this task is active
//               on.  This will be NULL if the state is S_inactive.
////////////////////////////////////////////////////////////////////
60
inline AsyncTaskManager *AsyncTask::get_manager(void) const;

231 6 remove 0 4 451 17 AsyncTask::remove 0 1 4 436
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::remove
//       Access: Published
//  Description: Removes the task from its active manager, if any, and
//               makes the state S_inactive (or possible
//               S_servicing_removed).  This is a no-op if the state
//               is already S_inactive.
////////////////////////////////////////////////////////////////////
29
void AsyncTask::remove(void);

232 9 set_delay 0 4 451 20 AsyncTask::set_delay 0 1 5 1089
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_delay
//       Access: Published
//  Description: Specifies the amount of time, in seconds, by which
//               this task will be delayed after it has been added to
//               the AsyncTaskManager.  At least the specified amount
//               of time (and possibly more) will elapse before the
//               task begins.
//
//               You may specify a delay of 0.0 to guarantee that the
//               task will run in the next epoch following the one in
//               which it is added.
//
//               Setting this value after the task has already been
//               added will not affect the task's wake time; it will
//               only affect the task if it is re-added to the queue
//               in the future, for instance if the task returns
//               DS_again.  However, see recalc_wake_time() if you wish
//               to apply the delay effect immediately.
////////////////////////////////////////////////////////////////////
47
inline void AsyncTask::set_delay(double delay);

233 11 clear_delay 0 4 451 22 AsyncTask::clear_delay 0 1 6 472
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::clear_delay
//       Access: Published
//  Description: Removes any delay specified for the task.  The next
//               time the task is added to the queue, it will run
//               immediately.  This does not affect the task's wake
//               time if it has already been added to the queue.
////////////////////////////////////////////////////////////////////
41
inline void AsyncTask::clear_delay(void);

234 9 has_delay 0 4 451 20 AsyncTask::has_delay 0 1 7 324
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::has_delay
//       Access: Published
//  Description: Returns true if a delay has been set for this task
//               via set_delay(), or false otherwise.
////////////////////////////////////////////////////////////////////
45
inline bool AsyncTask::has_delay(void) const;

235 9 get_delay 0 4 451 20 AsyncTask::get_delay 0 1 8 301
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_delay
//       Access: Published
//  Description: Returns the delay value that has been set via
//               set_delay, if any.
////////////////////////////////////////////////////////////////////
47
inline double AsyncTask::get_delay(void) const;

236 13 get_wake_time 0 4 451 24 AsyncTask::get_wake_time 0 1 9 674
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_wake_time
//       Access: Published
//  Description: If this task has been added to an AsyncTaskManager
//               with a delay in effect, this returns the time at
//               which the task is expected to awaken.  It has no
//               meaning if the task has not yet been added to a
//               queue, or if there was no delay in effect at the time
//               the task was added.
//
//               If the task's status is not S_sleeping, this returns
//               0.0.
////////////////////////////////////////////////////////////////////
44
double AsyncTask::get_wake_time(void) const;

237 16 recalc_wake_time 0 4 451 27 AsyncTask::recalc_wake_time 0 1 10 774
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::recalc_wake_time
//       Access: Published
//  Description: If the task is currently sleeping on a task
//               chain, this resets its wake time to the current time
//               + get_delay().  It is as if the task had suddenly
//               returned DS_again.  The task will sleep for its
//               current delay seconds before running again.  This
//               method may therefore be used to make the task wake up
//               sooner or later than it would have otherwise.
//
//               If the task is not already sleeping, this method has
//               no effect.
////////////////////////////////////////////////////////////////////
39
void AsyncTask::recalc_wake_time(void);

238 14 get_start_time 0 4 451 25 AsyncTask::get_start_time 0 1 11 435
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_start_time
//       Access: Published
//  Description: Returns the time at which the task was started,
//               according to the task manager's clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
////////////////////////////////////////////////////////////////////
52
inline double AsyncTask::get_start_time(void) const;

239 16 get_elapsed_time 0 4 451 27 AsyncTask::get_elapsed_time 0 1 12 478
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_elapsed_time
//       Access: Published
//  Description: Returns the amount of time that has elapsed since
//               the task was started, according to the task manager's
//               clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
////////////////////////////////////////////////////////////////////
47
double AsyncTask::get_elapsed_time(void) const;

240 15 get_start_frame 0 4 451 26 AsyncTask::get_start_frame 0 1 13 444
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_start_frame
//       Access: Published
//  Description: Returns the frame number at which the task was
//               started, according to the task manager's clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
////////////////////////////////////////////////////////////////////
50
inline int AsyncTask::get_start_frame(void) const;

241 18 get_elapsed_frames 0 4 451 29 AsyncTask::get_elapsed_frames 0 1 14 483
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_elapsed_frames
//       Access: Published
//  Description: Returns the number of frames that have elapsed since
//               the task was started, according to the task manager's
//               clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
////////////////////////////////////////////////////////////////////
46
int AsyncTask::get_elapsed_frames(void) const;

242 8 set_name 0 4 451 19 AsyncTask::set_name 0 1 15 218
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_name
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
59
void AsyncTask::set_name(basic_string< char > const &name);

243 10 clear_name 0 4 451 21 AsyncTask::clear_name 0 1 16 250
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::clear_name
//       Access: Public
//  Description: Resets the task's name to empty.
////////////////////////////////////////////////////////////////////
40
inline void AsyncTask::clear_name(void);

244 15 get_name_prefix 0 4 451 26 AsyncTask::get_name_prefix 0 1 17 375
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_name_prefix
//       Access: Published
//  Description: Returns the initial part of the name, up to but not
//               including any trailing digits following a hyphen or
//               underscore.
////////////////////////////////////////////////////////////////////
60
basic_string< char > AsyncTask::get_name_prefix(void) const;

245 11 get_task_id 0 4 451 22 AsyncTask::get_task_id 0 1 18 329
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_task_id
//       Access: Public
//  Description: Returns a number guaranteed to be unique for each
//               different AsyncTask object in the universe.
////////////////////////////////////////////////////////////////////
51
inline long int AsyncTask::get_task_id(void) const;

246 14 set_task_chain 0 4 451 25 AsyncTask::set_task_chain 0 1 19 380
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_task_chain
//       Access: Published
//  Description: Specifies the AsyncTaskChain on which this task will
//               be running.  Each task chain runs tasks independently
//               of the others.
////////////////////////////////////////////////////////////////////
71
void AsyncTask::set_task_chain(basic_string< char > const &chain_name);

247 14 get_task_chain 0 4 451 25 AsyncTask::get_task_chain 0 1 20 378
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_task_chain
//       Access: Published
//  Description: Returns the AsyncTaskChain on which this task will
//               be running.  Each task chain runs tasks independently
//               of the others.
////////////////////////////////////////////////////////////////////
73
inline basic_string< char > const &AsyncTask::get_task_chain(void) const;

248 8 set_sort 0 4 451 19 AsyncTask::set_sort 0 1 21 823
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_sort
//       Access: Published
//  Description: Specifies a sort value for this task.  Within a given
//               AsyncTaskManager, all of the tasks with a given sort
//               value are guaranteed to be completed before any tasks
//               with a higher sort value are begun.
//
//               To put it another way, two tasks might execute in
//               parallel with each other only if they both have the
//               same sort value.  Tasks with a lower sort value are
//               executed first.
//
//               This is different from the priority, which makes no
//               such exclusion guarantees.
////////////////////////////////////////////////////////////////////
35
void AsyncTask::set_sort(int sort);

249 8 get_sort 0 4 451 19 AsyncTask::get_sort 0 1 22 291
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_sort
//       Access: Published
//  Description: Returns the task's current sort value.  See
//               set_sort().
////////////////////////////////////////////////////////////////////
43
inline int AsyncTask::get_sort(void) const;

250 12 set_priority 0 4 451 23 AsyncTask::set_priority 0 1 23 1339
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_priority
//       Access: Published
//  Description: Specifies a priority value for this task.  In
//               general, tasks with a higher priority value are
//               executed before tasks with a lower priority value
//               (but only for tasks with the same sort value).
//
//               Unlike the sort value, tasks with different
//               priorities may execute at the same time, if the
//               AsyncTaskManager has more than one thread servicing
//               tasks.
//
//               Also see AsyncTaskChain::set_timeslice_priority(),
//               which changes the meaning of this value.  In the
//               default mode, when the timeslice_priority flag is
//               false, all tasks always run once per epoch,
//               regardless of their priority values (that is, the
//               priority controls the order of the task execution
//               only, not the number of times it runs).  On the other
//               hand, if you set the timeslice_priority flag to true,
//               then changing a task's priority has an effect on the
//               number of times it runs.
////////////////////////////////////////////////////////////////////
43
void AsyncTask::set_priority(int priority);

251 12 get_priority 0 4 451 23 AsyncTask::get_priority 0 1 24 303
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_priority
//       Access: Published
//  Description: Returns the task's current priority value.  See
//               set_priority().
////////////////////////////////////////////////////////////////////
47
inline int AsyncTask::get_priority(void) const;

252 14 set_done_event 0 4 451 25 AsyncTask::set_done_event 0 1 25 529
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_done_event
//       Access: Published
//  Description: Sets the event name that will be triggered
//               when the task finishes.  This should only be called
//               before the task has been started, or after it has
//               finished and before it is about to be restarted
//               (i.e. when get_state() returns S_inactive).
////////////////////////////////////////////////////////////////////
78
inline void AsyncTask::set_done_event(basic_string< char > const &done_event);

253 14 get_done_event 0 4 451 25 AsyncTask::get_done_event 0 1 26 334
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_done_event
//       Access: Published
//  Description: Returns the event name that will be triggered
//               when the task finishes.  See set_done_event().
////////////////////////////////////////////////////////////////////
73
inline basic_string< char > const &AsyncTask::get_done_event(void) const;

254 17 set_python_object 0 4 451 28 AsyncTask::set_python_object 0 1 27 326
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_python_object
//       Access: Published
//  Description: Specifies an arbitrary Python object that will be
//               piggybacked on the task object.
////////////////////////////////////////////////////////////////////
66
inline void AsyncTask::set_python_object(PyObject *python_object);

255 17 get_python_object 0 4 451 28 AsyncTask::get_python_object 0 1 28 374
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_python_object
//       Access: Published
//  Description: Returns the Python object that was specified to
//               set_python_object(), if any, or None if no object was
//               specified.
////////////////////////////////////////////////////////////////////
58
inline PyObject *AsyncTask::get_python_object(void) const;

256 6 get_dt 0 4 451 17 AsyncTask::get_dt 0 1 29 349
// HAVE_PYTHON

// HAVE_PYTHON
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_dt
//       Access: Published
//  Description: Returns the amount of time elapsed during the task's
//               previous run cycle, in seconds.
////////////////////////////////////////////////////////////////////
44
inline double AsyncTask::get_dt(void) const;

257 10 get_max_dt 0 4 451 21 AsyncTask::get_max_dt 0 1 30 342
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_max_dt
//       Access: Published
//  Description: Returns the maximum amount of time elapsed during any
//               one of the task's previous run cycles, in seconds.
////////////////////////////////////////////////////////////////////
48
inline double AsyncTask::get_max_dt(void) const;

258 14 get_average_dt 0 4 451 25 AsyncTask::get_average_dt 0 1 31 343
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_average_dt
//       Access: Published
//  Description: Returns the average amount of time elapsed during
//               each of the task's previous run cycles, in seconds.
////////////////////////////////////////////////////////////////////
52
inline double AsyncTask::get_average_dt(void) const;

259 6 output 0 6 451 17 AsyncTask::output 0 1 32 226
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::output
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
51
virtual void AsyncTask::output(ostream &out) const;

260 14 get_class_type 0 4 451 25 AsyncTask::get_class_type 0 1 33 0
50
static TypeHandle AsyncTask::get_class_type(void);

261 19 AsyncTaskCollection 0 4 455 40 AsyncTaskCollection::AsyncTaskCollection 0 2 34 35 469
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Copy Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
122
AsyncTaskCollection::AsyncTaskCollection(void);
AsyncTaskCollection::AsyncTaskCollection(AsyncTaskCollection const &copy);

262 10 operator = 0 4 455 31 AsyncTaskCollection::operator = 0 1 36 244
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Copy Assignment Operator
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
70
void AsyncTaskCollection::operator =(AsyncTaskCollection const &copy);

263 20 ~AsyncTaskCollection 0 4 455 41 AsyncTaskCollection::~AsyncTaskCollection 0 0 725
// Filename: asyncTaskCollection.I
// Created by:  drose (16Sep08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
55
inline AsyncTaskCollection::~AsyncTaskCollection(void);

264 8 add_task 0 4 455 29 AsyncTaskCollection::add_task 0 1 37 268
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::add_task
//       Access: Published
//  Description: Adds a new AsyncTask to the collection.
////////////////////////////////////////////////////////////////////
52
void AsyncTaskCollection::add_task(AsyncTask *task);

265 11 remove_task 0 4 455 32 AsyncTaskCollection::remove_task 0 2 38 39 684
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_task
//       Access: Published
//  Description: Removes the indicated AsyncTask from the collection.
//               Returns true if the task was removed, false if it was
//               not a member of the collection.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_task
//       Access: Published
//  Description: Removes the nth AsyncTask from the collection.
////////////////////////////////////////////////////////////////////
105
bool AsyncTaskCollection::remove_task(AsyncTask *task);
void AsyncTaskCollection::remove_task(int index);

266 14 add_tasks_from 0 4 455 35 AsyncTaskCollection::add_tasks_from 0 1 40 474
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::add_tasks_from
//       Access: Published
//  Description: Adds all the AsyncTasks indicated in the other
//               collection to this task.  The other tasks are simply
//               appended to the end of the tasks in this list;
//               duplicates are not automatically removed.
////////////////////////////////////////////////////////////////////
75
void AsyncTaskCollection::add_tasks_from(AsyncTaskCollection const &other);

267 17 remove_tasks_from 0 4 455 38 AsyncTaskCollection::remove_tasks_from 0 1 41 337
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_tasks_from
//       Access: Published
//  Description: Removes from this collection all of the AsyncTasks
//               listed in the other collection.
////////////////////////////////////////////////////////////////////
78
void AsyncTaskCollection::remove_tasks_from(AsyncTaskCollection const &other);

268 22 remove_duplicate_tasks 0 4 455 43 AsyncTaskCollection::remove_duplicate_tasks 0 1 42 476
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_duplicate_tasks
//       Access: Published
//  Description: Removes any duplicate entries of the same AsyncTasks
//               on this collection.  If a AsyncTask appears multiple
//               times, the first appearance is retained; subsequent
//               appearances are removed.
////////////////////////////////////////////////////////////////////
55
void AsyncTaskCollection::remove_duplicate_tasks(void);

269 8 has_task 0 4 455 29 AsyncTaskCollection::has_task 0 1 43 330
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::has_task
//       Access: Published
//  Description: Returns true if the indicated AsyncTask appears in
//               this collection, false otherwise.
////////////////////////////////////////////////////////////////////
58
bool AsyncTaskCollection::has_task(AsyncTask *task) const;

270 5 clear 0 4 455 26 AsyncTaskCollection::clear 0 1 44 269
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::clear
//       Access: Published
//  Description: Removes all AsyncTasks from the collection.
////////////////////////////////////////////////////////////////////
38
void AsyncTaskCollection::clear(void);

271 9 find_task 0 4 455 30 AsyncTaskCollection::find_task 0 1 45 365
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::find_task
//       Access: Published
//  Description: Returns the task in the collection with the
//               indicated name, if any, or NULL if no task has
//               that name.
////////////////////////////////////////////////////////////////////
82
AsyncTask *AsyncTaskCollection::find_task(basic_string< char > const &name) const;

272 13 get_num_tasks 0 4 455 34 AsyncTaskCollection::get_num_tasks 0 1 46 285
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::get_num_tasks
//       Access: Published
//  Description: Returns the number of AsyncTasks in the collection.
////////////////////////////////////////////////////////////////////
51
int AsyncTaskCollection::get_num_tasks(void) const;

273 8 get_task 0 4 455 29 AsyncTaskCollection::get_task 0 1 47 273
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::get_task
//       Access: Published
//  Description: Returns the nth AsyncTask in the collection.
////////////////////////////////////////////////////////////////////
58
AsyncTask *AsyncTaskCollection::get_task(int index) const;

274 11 operator [] 0 4 455 32 AsyncTaskCollection::operator [] 0 1 48 393
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator []
//       Access: Published
//  Description: Returns the nth AsyncTask in the collection.  This is
//               the same as get_task(), but it may be a more
//               convenient way to access it.
////////////////////////////////////////////////////////////////////
61
AsyncTask *AsyncTaskCollection::operator [](int index) const;

275 4 size 0 4 455 25 AsyncTaskCollection::size 0 1 49 332
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::size
//       Access: Published
//  Description: Returns the number of tasks in the collection.  This
//               is the same thing as get_num_tasks().
////////////////////////////////////////////////////////////////////
42
int AsyncTaskCollection::size(void) const;

276 11 operator += 0 4 455 32 AsyncTaskCollection::operator += 0 1 50 280
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator +=
//       Access: Published
//  Description: Appends the other list onto the end of this one.
////////////////////////////////////////////////////////////////////
79
inline void AsyncTaskCollection::operator +=(AsyncTaskCollection const &other);

277 10 operator + 0 4 455 31 AsyncTaskCollection::operator + 0 1 51 326
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator +
//       Access: Published
//  Description: Returns a AsyncTaskCollection representing the
//               concatenation of the two lists.
////////////////////////////////////////////////////////////////////
99
inline AsyncTaskCollection AsyncTaskCollection::operator +(AsyncTaskCollection const &other) const;

278 6 output 0 4 455 27 AsyncTaskCollection::output 0 1 52 338
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::output
//       Access: Published
//  Description: Writes a brief one-line description of the
//               AsyncTaskCollection to the indicated output stream.
////////////////////////////////////////////////////////////////////
53
void AsyncTaskCollection::output(ostream &out) const;

279 5 write 0 4 455 26 AsyncTaskCollection::write 0 2 53 54 342
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               AsyncTaskCollection to the indicated output stream.
////////////////////////////////////////////////////////////////////
76
void AsyncTaskCollection::write(ostream &out, int indent_level = (0)) const;

280 29 upcast_to_TypedReferenceCount 0 12 456 45 AsyncTaskChain::upcast_to_TypedReferenceCount 0 1 83 49
upcast from AsyncTaskChain to TypedReferenceCount
73
TypedReferenceCount *AsyncTaskChain::upcast_to_TypedReferenceCount(void);

281 26 downcast_to_AsyncTaskChain 0 12 457 47 TypedReferenceCount::downcast_to_AsyncTaskChain 0 1 84 51
downcast from TypedReferenceCount to AsyncTaskChain
70
AsyncTaskChain *TypedReferenceCount::downcast_to_AsyncTaskChain(void);

282 17 upcast_to_Namable 0 12 456 33 AsyncTaskChain::upcast_to_Namable 0 1 85 37
upcast from AsyncTaskChain to Namable
49
Namable *AsyncTaskChain::upcast_to_Namable(void);

283 26 downcast_to_AsyncTaskChain 0 12 458 35 Namable::downcast_to_AsyncTaskChain 0 1 86 39
downcast from Namable to AsyncTaskChain
58
AsyncTaskChain *Namable::downcast_to_AsyncTaskChain(void);

284 15 ~AsyncTaskChain 0 6 456 31 AsyncTaskChain::~AsyncTaskChain 0 0 234
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
46
virtual AsyncTaskChain::~AsyncTaskChain(void);

285 14 set_tick_clock 0 4 456 30 AsyncTaskChain::set_tick_clock 0 1 55 405
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_tick_clock
//       Access: Published
//  Description: Sets the tick_clock flag.  When this is true,
//               get_clock()->tick() will be called automatically at
//               each task epoch.  This is false by default.
////////////////////////////////////////////////////////////////////
53
void AsyncTaskChain::set_tick_clock(bool tick_clock);

286 14 get_tick_clock 0 4 456 30 AsyncTaskChain::get_tick_clock 0 1 56 281
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_tick_clock
//       Access: Published
//  Description: Returns the tick_clock flag.  See set_tick_clock().
////////////////////////////////////////////////////////////////////
48
bool AsyncTaskChain::get_tick_clock(void) const;

287 15 set_num_threads 0 4 456 31 AsyncTaskChain::set_num_threads 0 1 57 382
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_num_threads
//       Access: Published
//  Description: Changes the number of threads for this task chain.
//               This may require stopping the threads if they are
//               already running.
////////////////////////////////////////////////////////////////////
54
void AsyncTaskChain::set_num_threads(int num_threads);

288 15 get_num_threads 0 4 456 31 AsyncTaskChain::get_num_threads 0 1 58 376
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_threads
//       Access: Published
//  Description: Returns the number of threads that will be servicing
//               tasks for this chain.  Also see
//               get_num_running_threads().
////////////////////////////////////////////////////////////////////
48
int AsyncTaskChain::get_num_threads(void) const;

289 23 get_num_running_threads 0 4 456 39 AsyncTaskChain::get_num_running_threads 0 1 59 484
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_running_threads
//       Access: Published
//  Description: Returns the number of threads that have been created
//               and are actively running.  This will return 0 before
//               the threads have been started; it will also return 0
//               if thread support is not available.
////////////////////////////////////////////////////////////////////
56
int AsyncTaskChain::get_num_running_threads(void) const;

290 19 set_thread_priority 0 4 456 35 AsyncTaskChain::set_thread_priority 0 1 60 409
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_thread_priority
//       Access: Published
//  Description: Changes the priority associated with threads that
//               serve this task chain.  This may require stopping the
//               threads if they are already running.
////////////////////////////////////////////////////////////////////
66
void AsyncTaskChain::set_thread_priority(ThreadPriority priority);

291 19 get_thread_priority 0 4 456 35 AsyncTaskChain::get_thread_priority 0 1 61 324
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_thread_priority
//       Access: Published
//  Description: Returns the priority associated with threads that
//               serve this task chain.
////////////////////////////////////////////////////////////////////
63
ThreadPriority AsyncTaskChain::get_thread_priority(void) const;

292 16 set_frame_budget 0 4 456 32 AsyncTaskChain::set_frame_budget 0 1 62 739
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_frame_budget
//       Access: Published
//  Description: Sets the maximum amount of time per frame the tasks
//               on this chain are granted for execution.  If this is
//               less than zero, there is no limit; if it is >= 0, it
//               represents a maximum amount of time (in seconds) that
//               will be used to execute tasks.  If this time is
//               exceeded in any one frame, the task chain will stop
//               executing tasks until the next frame, as defined by
//               the TaskManager's clock.
////////////////////////////////////////////////////////////////////
59
void AsyncTaskChain::set_frame_budget(double frame_budget);

293 16 get_frame_budget 0 4 456 32 AsyncTaskChain::get_frame_budget 0 1 63 386
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_frame_budget
//       Access: Published
//  Description: Returns the maximum amount of time per frame the
//               tasks on this chain are granted for execution.  See
//               set_frame_budget().
////////////////////////////////////////////////////////////////////
52
double AsyncTaskChain::get_frame_budget(void) const;

294 14 set_frame_sync 0 4 456 30 AsyncTaskChain::set_frame_sync 0 1 64 1050
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_frame_sync
//       Access: Published
//  Description: Sets the frame_sync flag.  When this flag is true,
//               this task chain will be forced to sync with the
//               TaskManager's clock.  It will run no faster than one
//               epoch per clock frame.
//
//               When this flag is false, the default, the task chain
//               will finish all of its tasks and then immediately
//               start from the first task again, regardless of the
//               clock frame.  When it is true, the task chain will
//               finish all of its tasks and then wait for the clock
//               to tick to the next frame before resuming the first
//               task.
//
//               This only makes sense for threaded task chains.
//               Non-threaded task chains are automatically
//               synchronous.
////////////////////////////////////////////////////////////////////
53
void AsyncTaskChain::set_frame_sync(bool frame_sync);

295 14 get_frame_sync 0 4 456 30 AsyncTaskChain::get_frame_sync 0 1 65 281
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_frame_sync
//       Access: Published
//  Description: Returns the frame_sync flag.  See set_frame_sync().
////////////////////////////////////////////////////////////////////
48
bool AsyncTaskChain::get_frame_sync(void) const;

296 22 set_timeslice_priority 0 4 456 38 AsyncTaskChain::set_timeslice_priority 0 1 66 1385
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_timeslice_priority
//       Access: Published
//  Description: Sets the timeslice_priority flag.  This changes
//               the interpretation of priority, and the number of
//               times per epoch each task will run.  
//
//               When this flag is true, some tasks might not run in
//               any given epoch.  Instead, tasks with priority higher
//               than 1 will be given precedence, in proportion to the
//               amount of time they have already used.  This gives
//               higher-priority tasks more runtime than
//               lower-priority tasks.  Each task gets the amount of
//               time proportional to its priority value, so a task
//               with priority 100 will get five times as much
//               processing time as a task with priority 20.  For
//               these purposes, priority values less than 1 are
//               deemed to be equal to 1.
//
//               When this flag is false (the default), all tasks are
//               run exactly once each epoch, round-robin style.
//               Priority is only used to determine which task runs
//               first within tasks of the same sort value.
////////////////////////////////////////////////////////////////////
69
void AsyncTaskChain::set_timeslice_priority(bool timeslice_priority);

297 22 get_timeslice_priority 0 4 456 38 AsyncTaskChain::get_timeslice_priority 0 1 67 456
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_timeslice_priority
//       Access: Published
//  Description: Returns the timeslice_priority flag.  This changes
//               the interpretation of priority, and the number of
//               times per epoch each task will run.  See
//               set_timeslice_priority().
////////////////////////////////////////////////////////////////////
56
bool AsyncTaskChain::get_timeslice_priority(void) const;

298 12 stop_threads 0 4 456 28 AsyncTaskChain::stop_threads 0 1 68 477
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::stop_threads
//       Access: Published
//  Description: Stops any threads that are currently running.  If any
//               tasks are still pending and have not yet been picked
//               up by a thread, they will not be serviced unless
//               poll() or start_threads() is later called.
////////////////////////////////////////////////////////////////////
40
void AsyncTaskChain::stop_threads(void);

299 13 start_threads 0 4 456 29 AsyncTaskChain::start_threads 0 1 69 417
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::start_threads
//       Access: Published
//  Description: Starts any requested threads to service the tasks on
//               the queue.  This is normally not necessary, since
//               adding a task will start the threads automatically.
////////////////////////////////////////////////////////////////////
41
void AsyncTaskChain::start_threads(void);

300 10 is_started 0 4 456 26 AsyncTaskChain::is_started 0 1 70 962
// Filename: asyncTaskChain.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::is_started
//       Access: Published
//  Description: Returns true if the thread(s) have been started and
//               are ready to service requests, false otherwise.  If
//               this is false, the next call to add() or add_and_do()
//               will automatically start the threads.
////////////////////////////////////////////////////////////////////
51
inline bool AsyncTaskChain::is_started(void) const;

301 8 has_task 0 4 456 24 AsyncTaskChain::has_task 0 1 71 331
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::has_task
//       Access: Published
//  Description: Returns true if the indicated task has been added to
//               this AsyncTaskChain, false otherwise.
////////////////////////////////////////////////////////////////////
53
bool AsyncTaskChain::has_task(AsyncTask *task) const;

302 14 wait_for_tasks 0 4 456 30 AsyncTaskChain::wait_for_tasks 0 1 72 266
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::wait_for_tasks
//       Access: Published
//  Description: Blocks until the task list is empty.
////////////////////////////////////////////////////////////////////
42
void AsyncTaskChain::wait_for_tasks(void);

303 13 get_num_tasks 0 4 456 29 AsyncTaskChain::get_num_tasks 0 1 73 334
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_tasks
//       Access: Published
//  Description: Returns the number of tasks that are currently active
//               or sleeping within the task chain.
////////////////////////////////////////////////////////////////////
46
int AsyncTaskChain::get_num_tasks(void) const;

304 9 get_tasks 0 4 456 25 AsyncTaskChain::get_tasks 0 1 74 338
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active or sleeping
//               on the task chain, at the time of the call.
////////////////////////////////////////////////////////////////////
58
AsyncTaskCollection AsyncTaskChain::get_tasks(void) const;

305 16 get_active_tasks 0 4 456 32 AsyncTaskChain::get_active_tasks 0 1 75 369
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_active_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active (and not
//               sleeping) on the task chain, at the time of the
//               call.
////////////////////////////////////////////////////////////////////
65
AsyncTaskCollection AsyncTaskChain::get_active_tasks(void) const;

306 18 get_sleeping_tasks 0 4 456 34 AsyncTaskChain::get_sleeping_tasks 0 1 76 371
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_sleeping_tasks
//       Access: Published
//  Description: Returns the set of tasks that are sleeping (and not
//               active) on the task chain, at the time of the
//               call.
////////////////////////////////////////////////////////////////////
67
AsyncTaskCollection AsyncTaskChain::get_sleeping_tasks(void) const;

307 4 poll 0 4 456 20 AsyncTaskChain::poll 0 1 77 697
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::poll
//       Access: Published
//  Description: Runs through all the tasks in the task list, once, if
//               the task chain is running in single-threaded mode
//               (no threads available).  This method does nothing in
//               threaded mode, so it may safely be called in either
//               case.
//
//               Normally, you would not call this function directly;
//               instead, call AsyncTaskManager::poll(), which polls
//               all of the task chains in sequence.
////////////////////////////////////////////////////////////////////
32
void AsyncTaskChain::poll(void);

308 18 get_next_wake_time 0 4 456 34 AsyncTaskChain::get_next_wake_time 0 1 78 420
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_next_wake_time
//       Access: Published
//  Description: Returns the scheduled time (on the manager's clock)
//               of the next sleeping task, on any task chain, to
//               awaken.  Returns -1 if there are no sleeping tasks.
////////////////////////////////////////////////////////////////////
54
double AsyncTaskChain::get_next_wake_time(void) const;

309 6 output 0 6 456 22 AsyncTaskChain::output 0 1 79 231
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::output
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
56
virtual void AsyncTaskChain::output(ostream &out) const;

310 5 write 0 6 456 21 AsyncTaskChain::write 0 2 80 81 230
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::write
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
79
virtual void AsyncTaskChain::write(ostream &out, int indent_level = (0)) const;

311 14 get_class_type 0 4 456 30 AsyncTaskChain::get_class_type 0 1 82 0
55
static TypeHandle AsyncTaskChain::get_class_type(void);

312 29 upcast_to_TypedReferenceCount 0 12 459 47 AsyncTaskManager::upcast_to_TypedReferenceCount 0 1 117 51
upcast from AsyncTaskManager to TypedReferenceCount
75
TypedReferenceCount *AsyncTaskManager::upcast_to_TypedReferenceCount(void);

313 28 downcast_to_AsyncTaskManager 0 12 457 49 TypedReferenceCount::downcast_to_AsyncTaskManager 0 1 118 53
downcast from TypedReferenceCount to AsyncTaskManager
74
AsyncTaskManager *TypedReferenceCount::downcast_to_AsyncTaskManager(void);

314 17 upcast_to_Namable 0 12 459 35 AsyncTaskManager::upcast_to_Namable 0 1 119 39
upcast from AsyncTaskManager to Namable
51
Namable *AsyncTaskManager::upcast_to_Namable(void);

315 28 downcast_to_AsyncTaskManager 0 12 458 37 Namable::downcast_to_AsyncTaskManager 0 1 120 41
downcast from Namable to AsyncTaskManager
62
AsyncTaskManager *Namable::downcast_to_AsyncTaskManager(void);

316 16 AsyncTaskManager 0 4 459 34 AsyncTaskManager::AsyncTaskManager 0 1 87 228
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
69
AsyncTaskManager::AsyncTaskManager(basic_string< char > const &name);

317 17 ~AsyncTaskManager 0 6 459 35 AsyncTaskManager::~AsyncTaskManager 0 0 236
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
50
virtual AsyncTaskManager::~AsyncTaskManager(void);

318 7 cleanup 0 4 459 25 AsyncTaskManager::cleanup 0 1 88 345
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::cleanup
//       Access: Published
//  Description: Stops all threads and messily empties the task list.
//               This is intended to be called on destruction only.
////////////////////////////////////////////////////////////////////
37
void AsyncTaskManager::cleanup(void);

319 9 set_clock 0 4 459 27 AsyncTaskManager::set_clock 0 1 89 1070
// Filename: asyncTaskManager.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::set_clock
//       Access: Published
//  Description: Replaces the clock pointer used within the
//               AsyncTaskManager.  This is used to control when tasks
//               with a set_delay() specified will be scheduled.  It
//               can also be ticked automatically each epoch, if
//               set_tick_clock() is true.
//
//               The default is the global clock pointer.
////////////////////////////////////////////////////////////////////
60
inline void AsyncTaskManager::set_clock(ClockObject *clock);

320 9 get_clock 0 4 459 27 AsyncTaskManager::get_clock 0 1 90 321
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_clock
//       Access: Published
//  Description: Returns the clock pointer used within the
//               AsyncTaskManager.  See set_clock().
////////////////////////////////////////////////////////////////////
54
inline ClockObject *AsyncTaskManager::get_clock(void);

321 19 get_num_task_chains 0 4 459 37 AsyncTaskManager::get_num_task_chains 0 1 91 281
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_num_task_chains
//       Access: Published
//  Description: Returns the number of different task chains.
////////////////////////////////////////////////////////////////////
54
int AsyncTaskManager::get_num_task_chains(void) const;

322 14 get_task_chain 0 4 459 32 AsyncTaskManager::get_task_chain 0 1 92 259
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_task_chain
//       Access: Published
//  Description: Returns the nth task chain.
////////////////////////////////////////////////////////////////////
62
AsyncTaskChain *AsyncTaskManager::get_task_chain(int n) const;

323 15 make_task_chain 0 4 459 33 AsyncTaskManager::make_task_chain 0 1 93 445
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::make_task_chain
//       Access: Published
//  Description: Creates a new AsyncTaskChain of the indicated name
//               and stores it within the AsyncTaskManager.  If a task
//               chain with this name already exists, returns it
//               instead.
////////////////////////////////////////////////////////////////////
84
AsyncTaskChain *AsyncTaskManager::make_task_chain(basic_string< char > const &name);

324 15 find_task_chain 0 4 459 33 AsyncTaskManager::find_task_chain 0 1 94 349
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_task_chain
//       Access: Protected
//  Description: Searches a new AsyncTaskChain of the indicated name
//               and returns it if it exists, or NULL otherwise.
////////////////////////////////////////////////////////////////////
84
AsyncTaskChain *AsyncTaskManager::find_task_chain(basic_string< char > const &name);

325 17 remove_task_chain 0 4 459 35 AsyncTaskManager::remove_task_chain 0 1 95 496
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove_task_chain
//       Access: Protected
//  Description: Removes the AsyncTaskChain of the indicated name.
//               If the chain still has tasks, this will block until
//               all tasks are finished.
//
//               Returns true if successful, or false if the chain did
//               not exist.
////////////////////////////////////////////////////////////////////
75
bool AsyncTaskManager::remove_task_chain(basic_string< char > const &name);

326 3 add 0 4 459 21 AsyncTaskManager::add 0 1 96 379
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::add
//       Access: Published
//  Description: Adds the indicated task to the active queue.  It is
//               an error if the task is already added to this or any
//               other active queue.
////////////////////////////////////////////////////////////////////
44
void AsyncTaskManager::add(AsyncTask *task);

327 8 has_task 0 4 459 26 AsyncTaskManager::has_task 0 1 97 335
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::has_task
//       Access: Published
//  Description: Returns true if the indicated task has been added to
//               this AsyncTaskManager, false otherwise.
////////////////////////////////////////////////////////////////////
55
bool AsyncTaskManager::has_task(AsyncTask *task) const;

328 9 find_task 0 4 459 27 AsyncTaskManager::find_task 0 1 98 468
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_task
//       Access: Published
//  Description: Returns the first task found with the indicated name,
//               or NULL if there is no task with the indicated name.
//
//               If there are multiple tasks with the same name,
//               returns one of them arbitrarily.
////////////////////////////////////////////////////////////////////
79
AsyncTask *AsyncTaskManager::find_task(basic_string< char > const &name) const;

329 10 find_tasks 0 4 459 28 AsyncTaskManager::find_tasks 0 1 99 301
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_tasks
//       Access: Published
//  Description: Returns the list of tasks found with the indicated
//               name.
////////////////////////////////////////////////////////////////////
89
AsyncTaskCollection AsyncTaskManager::find_tasks(basic_string< char > const &name) const;

330 19 find_tasks_matching 0 4 459 37 AsyncTaskManager::find_tasks_matching 0 1 100 350
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_tasks_matching
//       Access: Published
//  Description: Returns the list of tasks found whose name matches
//               the indicated glob pattern, e.g. "my_task_*".
////////////////////////////////////////////////////////////////////
92
AsyncTaskCollection AsyncTaskManager::find_tasks_matching(GlobPattern const &pattern) const;

331 6 remove 0 4 459 24 AsyncTaskManager::remove 0 2 101 102 718
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove
//       Access: Published
//  Description: Removes the indicated task from the active queue.
//               Returns true if the task is successfully removed, or
//               false if it wasn't there.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove
//       Access: Published
//  Description: Removes all of the tasks in the AsyncTaskCollection.
//               Returns the number of tasks removed.
////////////////////////////////////////////////////////////////////
111
bool AsyncTaskManager::remove(AsyncTask *task);
int AsyncTaskManager::remove(AsyncTaskCollection const &tasks);

332 14 wait_for_tasks 0 4 459 32 AsyncTaskManager::wait_for_tasks 0 1 103 268
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::wait_for_tasks
//       Access: Published
//  Description: Blocks until the task list is empty.
////////////////////////////////////////////////////////////////////
44
void AsyncTaskManager::wait_for_tasks(void);

333 12 stop_threads 0 4 459 30 AsyncTaskManager::stop_threads 0 1 104 479
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::stop_threads
//       Access: Published
//  Description: Stops any threads that are currently running.  If any
//               tasks are still pending and have not yet been picked
//               up by a thread, they will not be serviced unless
//               poll() or start_threads() is later called.
////////////////////////////////////////////////////////////////////
42
void AsyncTaskManager::stop_threads(void);

334 13 start_threads 0 4 459 31 AsyncTaskManager::start_threads 0 1 105 419
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::start_threads
//       Access: Published
//  Description: Starts any requested threads to service the tasks on
//               the queue.  This is normally not necessary, since
//               adding a task will start the threads automatically.
////////////////////////////////////////////////////////////////////
43
void AsyncTaskManager::start_threads(void);

335 13 get_num_tasks 0 4 459 31 AsyncTaskManager::get_num_tasks 0 1 106 338
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_num_tasks
//       Access: Published
//  Description: Returns the number of tasks that are currently active
//               or sleeping within the task manager.
////////////////////////////////////////////////////////////////////
55
inline int AsyncTaskManager::get_num_tasks(void) const;

336 9 get_tasks 0 4 459 27 AsyncTaskManager::get_tasks 0 1 107 342
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active or sleeping
//               on the task manager, at the time of the call.
////////////////////////////////////////////////////////////////////
60
AsyncTaskCollection AsyncTaskManager::get_tasks(void) const;

337 16 get_active_tasks 0 4 459 34 AsyncTaskManager::get_active_tasks 0 1 108 373
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_active_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active (and not
//               sleeping) on the task manager, at the time of the
//               call.
////////////////////////////////////////////////////////////////////
67
AsyncTaskCollection AsyncTaskManager::get_active_tasks(void) const;

338 18 get_sleeping_tasks 0 4 459 36 AsyncTaskManager::get_sleeping_tasks 0 1 109 375
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_sleeping_tasks
//       Access: Published
//  Description: Returns the set of tasks that are sleeping (and not
//               active) on the task manager, at the time of the
//               call.
////////////////////////////////////////////////////////////////////
69
AsyncTaskCollection AsyncTaskManager::get_sleeping_tasks(void) const;

339 4 poll 0 4 459 22 AsyncTaskManager::poll 0 1 110 506
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::poll
//       Access: Published
//  Description: Runs through all the tasks in the task list, once, if
//               the task manager is running in single-threaded mode
//               (no threads available).  This method does nothing in
//               threaded mode, so it may safely be called in either
//               case.
////////////////////////////////////////////////////////////////////
34
void AsyncTaskManager::poll(void);

340 18 get_next_wake_time 0 4 459 36 AsyncTaskManager::get_next_wake_time 0 1 111 422
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_next_wake_time
//       Access: Published
//  Description: Returns the scheduled time (on the manager's clock)
//               of the next sleeping task, on any task chain, to
//               awaken.  Returns -1 if there are no sleeping tasks.
////////////////////////////////////////////////////////////////////
56
double AsyncTaskManager::get_next_wake_time(void) const;

341 6 output 0 6 459 24 AsyncTaskManager::output 0 1 112 233
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::output
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
58
virtual void AsyncTaskManager::output(ostream &out) const;

342 5 write 0 6 459 23 AsyncTaskManager::write 0 2 113 114 232
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::write
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
81
virtual void AsyncTaskManager::write(ostream &out, int indent_level = (0)) const;

343 14 get_global_ptr 0 4 459 32 AsyncTaskManager::get_global_ptr 0 1 115 403
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_global_ptr
//       Access: Published
//  Description: Returns a pointer to the global AsyncTaskManager.
//               This is the AsyncTaskManager that most code should
//               use for queueing tasks and suchlike.
////////////////////////////////////////////////////////////////////
71
static inline AsyncTaskManager *AsyncTaskManager::get_global_ptr(void);

344 14 get_class_type 0 4 459 32 AsyncTaskManager::get_class_type 0 1 116 0
57
static TypeHandle AsyncTaskManager::get_class_type(void);

345 14 AsyncTaskPause 0 4 460 30 AsyncTaskPause::AsyncTaskPause 0 1 121 226
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskPause::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
45
AsyncTaskPause::AsyncTaskPause(double delay);

346 12 operator new 0 4 460 28 AsyncTaskPause::operator new 0 1 122 0
134
inline void *AsyncTaskPause::operator new(unsigned int size);
inline void *AsyncTaskPause::operator new(unsigned int size, void *ptr);

347 15 operator delete 0 4 460 31 AsyncTaskPause::operator delete 0 0 0
116
inline void AsyncTaskPause::operator delete(void *ptr);
inline void AsyncTaskPause::operator delete(void *, void *);

348 12 validate_ptr 0 4 460 28 AsyncTaskPause::validate_ptr 0 0 0
65
static inline bool AsyncTaskPause::validate_ptr(void const *ptr);

349 14 get_class_type 0 4 460 30 AsyncTaskPause::get_class_type 0 1 123 0
55
static TypeHandle AsyncTaskPause::get_class_type(void);

350 15 ~AsyncTaskPause 0 4 460 31 AsyncTaskPause::~AsyncTaskPause 0 0 0
38
AsyncTaskPause::~AsyncTaskPause(void);

351 19 upcast_to_AsyncTask 0 12 461 38 AsyncTaskSequence::upcast_to_AsyncTask 0 1 130 42
upcast from AsyncTaskSequence to AsyncTask
56
AsyncTask *AsyncTaskSequence::upcast_to_AsyncTask(void);

352 29 downcast_to_AsyncTaskSequence 0 12 451 40 AsyncTask::downcast_to_AsyncTaskSequence 0 1 131 44
downcast from AsyncTask to AsyncTaskSequence
66
AsyncTaskSequence *AsyncTask::downcast_to_AsyncTaskSequence(void);

353 29 upcast_to_AsyncTaskCollection 0 12 461 48 AsyncTaskSequence::upcast_to_AsyncTaskCollection 0 1 132 52
upcast from AsyncTaskSequence to AsyncTaskCollection
76
AsyncTaskCollection *AsyncTaskSequence::upcast_to_AsyncTaskCollection(void);

354 29 downcast_to_AsyncTaskSequence 0 12 455 50 AsyncTaskCollection::downcast_to_AsyncTaskSequence 0 1 133 54
downcast from AsyncTaskCollection to AsyncTaskSequence
76
AsyncTaskSequence *AsyncTaskCollection::downcast_to_AsyncTaskSequence(void);

355 17 AsyncTaskSequence 0 4 461 36 AsyncTaskSequence::AsyncTaskSequence 0 1 124 229
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
71
AsyncTaskSequence::AsyncTaskSequence(basic_string< char > const &name);

356 18 ~AsyncTaskSequence 0 6 461 37 AsyncTaskSequence::~AsyncTaskSequence 0 0 237
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
52
virtual AsyncTaskSequence::~AsyncTaskSequence(void);

357 12 operator new 0 4 461 31 AsyncTaskSequence::operator new 0 1 125 0
140
inline void *AsyncTaskSequence::operator new(unsigned int size);
inline void *AsyncTaskSequence::operator new(unsigned int size, void *ptr);

358 15 operator delete 0 4 461 34 AsyncTaskSequence::operator delete 0 0 0
122
inline void AsyncTaskSequence::operator delete(void *ptr);
inline void AsyncTaskSequence::operator delete(void *, void *);

359 12 validate_ptr 0 4 461 31 AsyncTaskSequence::validate_ptr 0 0 0
68
static inline bool AsyncTaskSequence::validate_ptr(void const *ptr);

360 16 set_repeat_count 0 4 461 35 AsyncTaskSequence::set_repeat_count 0 1 126 1026
// Filename: asyncTaskSequence.I
// Created by:  drose (04Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::set_repeat_count
//       Access: Published
//  Description: Sets the repeat count of the sequence.  If the count
//               is 0 or 1, the sequence will run exactly once.  If it
//               is greater than 0, it will run that number of times.
//               If it is negative, it will run forever until it is
//               explicitly removed.
////////////////////////////////////////////////////////////////////
66
inline void AsyncTaskSequence::set_repeat_count(int repeat_count);

361 16 get_repeat_count 0 4 461 35 AsyncTaskSequence::get_repeat_count 0 1 127 318
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::get_repeat_count
//       Access: Published
//  Description: Returns the repeat count of the sequence.  See
//               set_repeat_count().
////////////////////////////////////////////////////////////////////
59
inline int AsyncTaskSequence::get_repeat_count(void) const;

362 22 get_current_task_index 0 4 461 41 AsyncTaskSequence::get_current_task_index 0 1 128 403
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::get_current_task_index
//       Access: Published
//  Description: Returns the index of the task within the sequence
//               that is currently being executed (or that will be
//               executed at the next epoch).
////////////////////////////////////////////////////////////////////
65
inline int AsyncTaskSequence::get_current_task_index(void) const;

363 14 get_class_type 0 4 461 33 AsyncTaskSequence::get_class_type 0 1 129 0
58
static TypeHandle AsyncTaskSequence::get_class_type(void);

364 14 EventParameter 0 4 462 30 EventParameter::EventParameter 0 8 134 135 136 137 138 139 140 141 3323
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Default constructor
//       Access: Published
//  Description: Defines an EventParameter that stores nothing: the
//               "empty" parameter.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Pointer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a pointer to
//               any kind of TypedWritableReferenceCount object.  This
//               is the most general constructor.
//
//               This accepts a const pointer, even though it stores
//               (and eventually returns) a non-const pointer.  This
//               is just the simplest way to allow both const and
//               non-const pointers to be stored, but it does lose the
//               constness.  Be careful.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Pointer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a pointer to
//               a TypedReferenceCount object.  Note that a
//               TypedReferenceCount is not the same kind of pointer
//               as a TypedWritableReferenceCount, hence we require
//               both constructors.
//
//               This accepts a const pointer, even though it stores
//               (and eventually returns) a non-const pointer.  This
//               is just the simplest way to allow both const and
//               non-const pointers to be stored, but it does lose the
//               constness.  Be careful.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Integer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores an integer
//               value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Double constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a
//               floating-point value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::String constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a string value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Wstring constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a wstring value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Copy constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
515
inline EventParameter::EventParameter(void);
inline EventParameter::EventParameter(TypedWritableReferenceCount const *ptr);
inline EventParameter::EventParameter(TypedReferenceCount const *ptr);
inline EventParameter::EventParameter(int value);
inline EventParameter::EventParameter(double value);
inline EventParameter::EventParameter(basic_string< char > const &value);
inline EventParameter::EventParameter(basic_string< wchar_t > const &value);
inline EventParameter::EventParameter(EventParameter const &copy);

365 10 operator = 0 4 462 26 EventParameter::operator = 0 1 142 239
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Copy assignment operator
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
78
inline EventParameter &EventParameter::operator =(EventParameter const &copy);

366 15 ~EventParameter 0 4 462 31 EventParameter::~EventParameter 0 0 225
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
45
inline EventParameter::~EventParameter(void);

367 8 is_empty 0 4 462 24 EventParameter::is_empty 0 1 143 607
// These functions are conveniences to easily determine if the
// EventParameter is one of the predefined parameter types, and
// retrieve the corresponding value.  Of course, it is possible that
// the EventParameter is some user-defined type, and is none of
// these.

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_empty
//       Access: Published
//  Description: Returns true if the EventParameter is the empty
//               parameter, storing nothing, or false otherwise.
////////////////////////////////////////////////////////////////////
49
inline bool EventParameter::is_empty(void) const;

368 6 is_int 0 4 462 22 EventParameter::is_int 0 1 144 586
// These functions are conveniences to easily determine if the
// EventParameter is one of the predefined parameter types, and
// retrieve the corresponding value.  Of course, it is possible that
// the EventParameter is some user-defined type, and is none of
// these.

////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_int
//       Access: Published
//  Description: Returns true if the EventParameter stores an integer
//               value, false otherwise.
////////////////////////////////////////////////////////////////////
47
inline bool EventParameter::is_int(void) const;

369 13 get_int_value 0 4 462 29 EventParameter::get_int_value 0 1 145 382
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_int_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_int() has already
//               returned true.
////////////////////////////////////////////////////////////////////
53
inline int EventParameter::get_int_value(void) const;

370 9 is_double 0 4 462 25 EventParameter::is_double 0 1 146 331
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_double
//       Access: Published
//  Description: Returns true if the EventParameter stores a double
//               floating-point value, false otherwise.
////////////////////////////////////////////////////////////////////
50
inline bool EventParameter::is_double(void) const;

371 16 get_double_value 0 4 462 32 EventParameter::get_double_value 0 1 147 388
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_double_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_double() has already
//               returned true.
////////////////////////////////////////////////////////////////////
59
inline double EventParameter::get_double_value(void) const;

372 9 is_string 0 4 462 25 EventParameter::is_string 0 1 148 316
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_string
//       Access: Published
//  Description: Returns true if the EventParameter stores a string
//               value, false otherwise.
////////////////////////////////////////////////////////////////////
50
inline bool EventParameter::is_string(void) const;

373 16 get_string_value 0 4 462 32 EventParameter::get_string_value 0 1 149 388
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_string_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_string() has already
//               returned true.
////////////////////////////////////////////////////////////////////
73
inline basic_string< char > EventParameter::get_string_value(void) const;

374 10 is_wstring 0 4 462 26 EventParameter::is_wstring 0 1 150 318
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_wstring
//       Access: Published
//  Description: Returns true if the EventParameter stores a wstring
//               value, false otherwise.
////////////////////////////////////////////////////////////////////
51
inline bool EventParameter::is_wstring(void) const;

375 17 get_wstring_value 0 4 462 33 EventParameter::get_wstring_value 0 1 151 390
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_wstring_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_wstring() has already
//               returned true.
////////////////////////////////////////////////////////////////////
77
inline basic_string< wchar_t > EventParameter::get_wstring_value(void) const;

376 18 is_typed_ref_count 0 4 462 34 EventParameter::is_typed_ref_count 0 1 152 537
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_typed_ref_count
//       Access: Published
//  Description: Returns true if the EventParameter stores a
//               TypedReferenceCount pointer, false otherwise.  Note
//               that a TypedReferenceCount is not exactly the same
//               kind of pointer as a TypedWritableReferenceCount,
//               hence the need for this separate call.
////////////////////////////////////////////////////////////////////
59
inline bool EventParameter::is_typed_ref_count(void) const;

377 25 get_typed_ref_count_value 0 4 462 41 EventParameter::get_typed_ref_count_value 0 1 153 406
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_typed_ref_count_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_typed_ref_count()
//               has already returned true.
////////////////////////////////////////////////////////////////////
82
inline TypedReferenceCount *EventParameter::get_typed_ref_count_value(void) const;

378 7 get_ptr 0 4 462 23 EventParameter::get_ptr 0 1 154 552
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_ptr
//       Access: Published
//  Description: Retrieves a pointer to the actual value stored in the
//               parameter.  The TypeHandle of this pointer may be
//               examined to determine the actual type of parameter it
//               contains.  This is the only way to retrieve the value
//               when it is not one of the above predefined types.
////////////////////////////////////////////////////////////////////
72
inline TypedWritableReferenceCount *EventParameter::get_ptr(void) const;

379 6 output 0 4 462 22 EventParameter::output 0 1 155 222
////////////////////////////////////////////////////////////////////
//     Function: EventParameter::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
48
void EventParameter::output(ostream &out) const;

380 6 output 0 6 463 27 EventStoreValueBase::output 0 1 156 0
65
virtual void EventStoreValueBase::output(ostream &out) const = 0;

381 14 get_class_type 0 4 463 35 EventStoreValueBase::get_class_type 0 1 157 0
60
static TypeHandle EventStoreValueBase::get_class_type(void);

382 23 EventStoreTypedRefCount 0 4 465 48 EventStoreTypedRefCount::EventStoreTypedRefCount 0 1 158 236
////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
90
inline EventStoreTypedRefCount::EventStoreTypedRefCount(TypedReferenceCount const *value);

383 9 set_value 0 4 465 34 EventStoreTypedRefCount::set_value 0 1 159 417
////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::set_value
//       Access: Published
//  Description: Changes the value stored in the parameter.  It is
//               dangerous to do this for a parameter already added to
//               an event, since the parameters may be shared.
////////////////////////////////////////////////////////////////////
81
inline void EventStoreTypedRefCount::set_value(TypedReferenceCount const *value);

384 9 get_value 0 4 465 34 EventStoreTypedRefCount::get_value 0 1 160 278
////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::get_value
//       Access: Published
//  Description: Retrieves the value stored in the parameter.
////////////////////////////////////////////////////////////////////
75
inline TypedReferenceCount *EventStoreTypedRefCount::get_value(void) const;

385 14 get_class_type 0 4 465 39 EventStoreTypedRefCount::get_class_type 0 1 161 0
64
static TypeHandle EventStoreTypedRefCount::get_class_type(void);

386 5 Event 0 4 466 12 Event::Event 0 3 162 163 164 435
////////////////////////////////////////////////////////////////////
//     Function: Event::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: Event::Copy constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
127
Event::Event(basic_string< char > const &event_name, EventReceiver *receiver = ((void *)(0)));
Event::Event(Event const &copy);

387 10 operator = 0 4 466 17 Event::operator = 0 1 165 227
////////////////////////////////////////////////////////////////////
//     Function: Event::Copy Assignment Operator
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
42
void Event::operator =(Event const &copy);

388 8 set_name 0 4 466 15 Event::set_name 0 1 166 692
// Filename: event.I
// Created by:  drose (15May01)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Event::set_name
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
62
inline void Event::set_name(basic_string< char > const &name);

389 10 clear_name 0 4 466 17 Event::clear_name 0 1 167 247
////////////////////////////////////////////////////////////////////
//     Function: Event::clear_name
//       Access: Public
//  Description: Resets the Event's name to empty.
////////////////////////////////////////////////////////////////////
36
inline void Event::clear_name(void);

390 8 has_name 0 4 466 15 Event::has_name 0 1 168 307
////////////////////////////////////////////////////////////////////
//     Function: Event::has_name
//       Access: Public
//  Description: Returns true if the Event has a nonempty name set,
//               false if the name is empty.
////////////////////////////////////////////////////////////////////
40
inline bool Event::has_name(void) const;

391 8 get_name 0 4 466 15 Event::get_name 0 1 169 211
////////////////////////////////////////////////////////////////////
//     Function: Event::get_name
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
63
inline basic_string< char > const &Event::get_name(void) const;

392 13 add_parameter 0 4 466 20 Event::add_parameter 0 1 170 216
////////////////////////////////////////////////////////////////////
//     Function: Event::add_parameter
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
53
void Event::add_parameter(EventParameter const &obj);

393 18 get_num_parameters 0 4 466 25 Event::get_num_parameters 0 1 171 221
////////////////////////////////////////////////////////////////////
//     Function: Event::get_num_parameters
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
42
int Event::get_num_parameters(void) const;

394 13 get_parameter 0 4 466 20 Event::get_parameter 0 1 172 216
////////////////////////////////////////////////////////////////////
//     Function: Event::get_parameter
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
49
EventParameter Event::get_parameter(int n) const;

395 12 has_receiver 0 4 466 19 Event::has_receiver 0 1 173 215
////////////////////////////////////////////////////////////////////
//     Function: Event::has_receiver
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
37
bool Event::has_receiver(void) const;

396 12 get_receiver 0 4 466 19 Event::get_receiver 0 1 174 215
////////////////////////////////////////////////////////////////////
//     Function: Event::get_receiver
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
47
EventReceiver *Event::get_receiver(void) const;

397 12 set_receiver 0 4 466 19 Event::set_receiver 0 1 175 215
////////////////////////////////////////////////////////////////////
//     Function: Event::set_receiver
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
50
void Event::set_receiver(EventReceiver *receiver);

398 14 clear_receiver 0 4 466 21 Event::clear_receiver 0 1 176 217
////////////////////////////////////////////////////////////////////
//     Function: Event::clear_receiver
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
33
void Event::clear_receiver(void);

399 6 output 0 4 466 13 Event::output 0 1 177 209
////////////////////////////////////////////////////////////////////
//     Function: Event::output
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
39
void Event::output(ostream &out) const;

400 14 get_class_type 0 4 466 21 Event::get_class_type 0 1 178 0
46
static TypeHandle Event::get_class_type(void);

401 12 EventHandler 0 4 467 26 EventHandler::EventHandler 0 1 179 221
////////////////////////////////////////////////////////////////////
//     Function: EventHandler::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
49
EventHandler::EventHandler(EventQueue *ev_queue);

402 14 process_events 0 4 467 28 EventHandler::process_events 0 1 180 447
////////////////////////////////////////////////////////////////////
//     Function: EventHandler::process_events
//       Access: Public
//  Description: The main processing loop of the EventHandler.  This
//               function must be called periodically to service
//               events.  Walks through each pending event and calls
//               its assigned hooks.
////////////////////////////////////////////////////////////////////
40
void EventHandler::process_events(void);

403 14 dispatch_event 0 6 467 28 EventHandler::dispatch_event 0 1 181 306
////////////////////////////////////////////////////////////////////
//     Function: EventHandler::dispatch_event
//       Access: Public, Virtual
//  Description: Calls the hooks assigned to the indicated single
//               event.
////////////////////////////////////////////////////////////////////
57
virtual void EventHandler::dispatch_event(Event const *);

404 5 write 0 4 467 19 EventHandler::write 0 1 182 215
////////////////////////////////////////////////////////////////////
//     Function: EventHandler::write
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
45
void EventHandler::write(ostream &out) const;

405 24 get_global_event_handler 0 4 467 38 EventHandler::get_global_event_handler 0 2 183 184 881
// Filename: eventHandler.I
// Created by:  skyler (27Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::get_global_event_handler
//       Access: Public
//  Description: Returns a pointer to the one global EventHandler
//               object.  If the global object has not yet been
//               created, this will create it.
////////////////////////////////////////////////////////////////////
102
static inline EventHandler *EventHandler::get_global_event_handler(EventQueue *queue = ((void *)(0)));

406 14 get_class_type 0 4 467 28 EventHandler::get_class_type 0 1 185 0
53
static TypeHandle EventHandler::get_class_type(void);

407 13 ~EventHandler 0 4 467 27 EventHandler::~EventHandler 0 0 0
34
EventHandler::~EventHandler(void);

408 10 EventQueue 0 4 469 22 EventQueue::EventQueue 0 1 186 222
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
29
EventQueue::EventQueue(void);

409 11 ~EventQueue 0 4 469 23 EventQueue::~EventQueue 0 0 221
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
30
EventQueue::~EventQueue(void);

410 11 queue_event 0 4 469 23 EventQueue::queue_event 0 1 187 222
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::queue_event
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
60
void EventQueue::queue_event(ConstPointerTo< Event > event);

411 5 clear 0 4 469 17 EventQueue::clear 0 1 188 294
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::clear
//       Access: Published
//  Description: Empties all events on the queue, throwing them on the
//               floor.
////////////////////////////////////////////////////////////////////
29
void EventQueue::clear(void);

412 14 is_queue_empty 0 4 469 26 EventQueue::is_queue_empty 0 1 189 225
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::is_queue_empty
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
44
bool EventQueue::is_queue_empty(void) const;

413 13 is_queue_full 0 4 469 25 EventQueue::is_queue_full 0 1 190 306
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::is_queue_full
//       Access: Published
//  Description: This function is deprecated--the queue is never full
//               these days.
////////////////////////////////////////////////////////////////////
43
bool EventQueue::is_queue_full(void) const;

414 13 dequeue_event 0 4 469 25 EventQueue::dequeue_event 0 1 191 224
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::dequeue_event
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
56
ConstPointerTo< Event > EventQueue::dequeue_event(void);

415 22 get_global_event_queue 0 4 469 34 EventQueue::get_global_event_queue 0 1 192 874
// Filename: eventQueue.I
// Created by:  drose (05May00)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::get_global_event_queue
//       Access: Public
//  Description: Returns a pointer to the one global EventQueue
//               object.  If the global object has not yet been
//               created, this will create it.
////////////////////////////////////////////////////////////////////
67
static inline EventQueue *EventQueue::get_global_event_queue(void);

416 16 PointerEventList 0 4 470 34 PointerEventList::PointerEventList 0 1 193 951
// Filename: pointerEventList.I
// Created by: jyelon (20Sep2007)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::Copy Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
48
inline PointerEventList::PointerEventList(void);

417 14 get_num_events 0 4 470 32 PointerEventList::get_num_events 0 1 194 273
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_num_events
//       Access: Published
//  Description: Returns the number of events in the list.
////////////////////////////////////////////////////////////////////
56
inline int PointerEventList::get_num_events(void) const;

418 13 get_in_window 0 4 470 31 PointerEventList::get_in_window 0 1 195 271
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_in_window
//       Access: Published
//  Description: Get the in-window flag of the nth event.
////////////////////////////////////////////////////////////////////
57
inline bool PointerEventList::get_in_window(int n) const;

419 8 get_xpos 0 4 470 26 PointerEventList::get_xpos 0 1 196 264
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_xpos
//       Access: Published
//  Description: Get the x-coordinate of the nth event.
////////////////////////////////////////////////////////////////////
51
inline int PointerEventList::get_xpos(int n) const;

420 8 get_ypos 0 4 470 26 PointerEventList::get_ypos 0 1 197 264
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_ypos
//       Access: Published
//  Description: Get the y-coordinate of the nth event.
////////////////////////////////////////////////////////////////////
51
inline int PointerEventList::get_ypos(int n) const;

421 6 get_dx 0 4 470 24 PointerEventList::get_dx 0 1 198 262
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_dx
//       Access: Published
//  Description: Get the x-coordinate of the nth event.
////////////////////////////////////////////////////////////////////
49
inline int PointerEventList::get_dx(int n) const;

422 6 get_dy 0 4 470 24 PointerEventList::get_dy 0 1 199 262
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_dy
//       Access: Published
//  Description: Get the y-coordinate of the nth event.
////////////////////////////////////////////////////////////////////
49
inline int PointerEventList::get_dy(int n) const;

423 12 get_sequence 0 4 470 30 PointerEventList::get_sequence 0 1 200 271
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_sequence
//       Access: Published
//  Description: Get the sequence number of the nth event.
////////////////////////////////////////////////////////////////////
55
inline int PointerEventList::get_sequence(int n) const;

424 10 get_length 0 4 470 28 PointerEventList::get_length 0 1 201 260
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_length
//       Access: Published
//  Description: Get the length of the nth event.
////////////////////////////////////////////////////////////////////
56
inline double PointerEventList::get_length(int n) const;

425 13 get_direction 0 4 470 31 PointerEventList::get_direction 0 1 202 266
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_direction
//       Access: Published
//  Description: Get the direction of the nth event.
////////////////////////////////////////////////////////////////////
59
inline double PointerEventList::get_direction(int n) const;

426 12 get_rotation 0 4 470 30 PointerEventList::get_rotation 0 1 203 264
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_rotation
//       Access: Published
//  Description: Get the rotation of the nth event.
////////////////////////////////////////////////////////////////////
58
inline double PointerEventList::get_rotation(int n) const;

427 8 get_time 0 4 470 26 PointerEventList::get_time 0 1 204 261
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_time
//       Access: Published
//  Description: Get the timestamp of the nth event.
////////////////////////////////////////////////////////////////////
54
inline double PointerEventList::get_time(int n) const;

428 5 clear 0 4 470 23 PointerEventList::clear 0 1 205 257
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::clear
//       Access: Public
//  Description: Empties all the events from the list.
////////////////////////////////////////////////////////////////////
42
inline void PointerEventList::clear(void);

429 9 pop_front 0 4 470 27 PointerEventList::pop_front 0 1 206 261
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::pop_front
//       Access: Public
//  Description: Discards the first event on the list.
////////////////////////////////////////////////////////////////////
46
inline void PointerEventList::pop_front(void);

430 9 add_event 0 4 470 27 PointerEventList::add_event 0 1 207 399
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::add_event
//       Access: Published
//  Description: Adds a new event to the end of the list.
//               Automatically calculates the dx, dy, length,
//               direction, and rotation for all but the first event.
////////////////////////////////////////////////////////////////////
88
void PointerEventList::add_event(bool in_win, int xpos, int ypos, int seq, double time);

431 9 encircles 0 4 470 27 PointerEventList::encircles 0 1 208 303
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::encircles
//       Access: Published
//  Description: Returns true if the trail loops around the
//               specified point.
////////////////////////////////////////////////////////////////////
53
bool PointerEventList::encircles(int x, int y) const;

432 11 total_turns 0 4 470 29 PointerEventList::total_turns 0 1 209 555
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::total_turns
//       Access: Published
//  Description: returns the total angular deviation that the trail
//               has made in the specified time period.  A small
//               number means that the trail is moving in a relatively
//               straight line, a large number means that the trail
//               is zig-zagging or spinning.  The result is in degrees.
////////////////////////////////////////////////////////////////////
55
double PointerEventList::total_turns(double sec) const;

433 13 match_pattern 0 4 470 31 PointerEventList::match_pattern 0 1 210 912
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::match_pattern
//       Access: Published
//  Description: This function is not implemented yet.  It is a work
//               in progress.  The intent is as follows:
//
//               Returns a nonzero value if the mouse movements 
//               match the specified pattern.  The higher the value,
//               the better the match.  The pattern is a sequence
//               of compass directions (ie, "E", "NE", etc) separated
//               by spaces.  If rot is nonzero, then the pattern is
//               rotated counterclockwise by the specified amount 
//               before testing.  Seglen is the minimum length a
//               mouse movement needs to be in order to be considered
//               significant.
////////////////////////////////////////////////////////////////////
103
double PointerEventList::match_pattern(basic_string< char > const &pattern, double rot, double seglen);

434 14 get_class_type 0 4 470 32 PointerEventList::get_class_type 0 1 211 0
57
static TypeHandle PointerEventList::get_class_type(void);

435 17 ~PointerEventList 0 4 470 35 PointerEventList::~PointerEventList 0 0 0
42
PointerEventList::~PointerEventList(void);

436 10 PythonTask 0 4 471 22 PythonTask::PythonTask 0 3 212 213 214 222
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
104
PythonTask::PythonTask(PyObject *function = (Py_None), basic_string< char > const &name = ((string())));

437 12 operator new 0 4 471 24 PythonTask::operator new 0 1 215 0
126
inline void *PythonTask::operator new(unsigned int size);
inline void *PythonTask::operator new(unsigned int size, void *ptr);

438 15 operator delete 0 4 471 27 PythonTask::operator delete 0 0 0
108
inline void PythonTask::operator delete(void *ptr);
inline void PythonTask::operator delete(void *, void *);

439 12 validate_ptr 0 4 471 24 PythonTask::validate_ptr 0 0 0
61
static inline bool PythonTask::validate_ptr(void const *ptr);

440 12 set_function 0 4 471 24 PythonTask::set_function 0 1 216 365
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_function
//       Access: Published
//  Description: Replaces the function that is called when the task
//               runs.  The parameter should be a Python callable
//               object.
////////////////////////////////////////////////////////////////////
50
void PythonTask::set_function(PyObject *function);

441 12 get_function 0 4 471 24 PythonTask::get_function 0 1 217 296
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_function
//       Access: Published
//  Description: Returns the function that is called when the task
//               runs.
////////////////////////////////////////////////////////////////////
41
PyObject *PythonTask::get_function(void);

442 8 set_args 0 4 471 20 PythonTask::set_args 0 1 218 408
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_args
//       Access: Published
//  Description: Replaces the argument list that is passed to the task
//               function.  The parameter should be a tuple or list of
//               arguments, or None to indicate the empty list.
////////////////////////////////////////////////////////////////////
60
void PythonTask::set_args(PyObject *args, bool append_task);

443 8 get_args 0 4 471 20 PythonTask::get_args 0 1 219 299
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_args
//       Access: Published
//  Description: Returns the argument list that is passed to the task
//               function.
////////////////////////////////////////////////////////////////////
37
PyObject *PythonTask::get_args(void);

444 14 set_upon_death 0 4 471 26 PythonTask::set_upon_death 0 1 220 371
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_upon_death
//       Access: Published
//  Description: Replaces the function that is called when the task
//               finishes.  The parameter should be a Python callable
//               object.
////////////////////////////////////////////////////////////////////
54
void PythonTask::set_upon_death(PyObject *upon_death);

445 14 get_upon_death 0 4 471 26 PythonTask::get_upon_death 0 1 221 302
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_upon_death
//       Access: Published
//  Description: Returns the function that is called when the task
//               finishes.
////////////////////////////////////////////////////////////////////
43
PyObject *PythonTask::get_upon_death(void);

446 9 set_owner 0 4 471 21 PythonTask::set_owner 0 1 222 651
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_owner
//       Access: Published
//  Description: Specifies a Python object that serves as the "owner"
//               for the task.  This owner object must have two
//               methods: _addTask() and _clearTask(), which will be
//               called with one parameter, the task object.
//
//               owner._addTask() is called when the task is added
//               into the active task list, and owner._clearTask() is
//               called when it is removed.
////////////////////////////////////////////////////////////////////
44
void PythonTask::set_owner(PyObject *owner);

447 9 get_owner 0 4 471 21 PythonTask::get_owner 0 1 223 266
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_owner
//       Access: Published
//  Description: Returns the "owner" object.  See set_owner().
////////////////////////////////////////////////////////////////////
38
PyObject *PythonTask::get_owner(void);

448 11 __setattr__ 0 4 471 23 PythonTask::__setattr__ 0 2 224 225 1052
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__setattr__
//       Access: Published
//  Description: Maps from an expression like "task.attr_name = v".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               assigning certain values.  We also support adding
//               arbitrary data to the Task object.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__setattr__
//       Access: Published
//  Description: Maps from an expression like "del task.attr_name".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               assigning certain values.  We also support adding
//               arbitrary data to the Task object.
////////////////////////////////////////////////////////////////////
148
int PythonTask::__setattr__(basic_string< char > const &attr_name, PyObject *v);
int PythonTask::__setattr__(basic_string< char > const &attr_name);

449 11 __getattr__ 0 4 471 23 PythonTask::__getattr__ 0 1 226 520
////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__getattr__
//       Access: Published
//  Description: Maps from an expression like "task.attr_name".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               querying certain values.  We also support adding
//               arbitrary data to the Task object.
////////////////////////////////////////////////////////////////////
79
PyObject *PythonTask::__getattr__(basic_string< char > const &attr_name) const;

450 14 get_class_type 0 4 471 26 PythonTask::get_class_type 0 1 227 0
51
static TypeHandle PythonTask::get_class_type(void);

227
1 14 Dtool__0BPQ1Kp 0 6 5 454 0 14 Dtool__0BPQ1Kp 743 // Filename: asyncTask.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_state
//       Access: Published
//  Description: Returns the current state of the task.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
2 14 Dtool__0BPiwJh 0 6 6 474 0 14 Dtool__0BPiwJh 612 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::is_alive
//       Access: Published
//  Description: Returns true if the task is currently active or
//               sleeping on some task chain, meaning that it will be
//               executed in its turn, or false if it is not active.
//               If the task has recently been removed while it is in
//               the middle of execution, this will return false,
//               because the task will not run again once it finishes.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
3 14 Dtool__0BPdXJF 0 7 7 475 317 14 Dtool__0BPdXJF 343 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_manager
//       Access: Published
//  Description: Returns the AsyncTaskManager that this task is active
//               on.  This will be NULL if the state is S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
4 14 Dtool__0BPOwan 0 4 8 477 0 14 Dtool__0BPOwan 436 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::remove
//       Access: Published
//  Description: Removes the task from its active manager, if any, and
//               makes the state S_inactive (or possible
//               S_servicing_removed).  This is a no-op if the state
//               is already S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 476  
5 14 Dtool__0BPDnru 0 4 9 477 0 14 Dtool__0BPDnru 1089 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_delay
//       Access: Published
//  Description: Specifies the amount of time, in seconds, by which
//               this task will be delayed after it has been added to
//               the AsyncTaskManager.  At least the specified amount
//               of time (and possibly more) will elapse before the
//               task begins.
//
//               You may specify a delay of 0.0 to guarantee that the
//               task will run in the next epoch following the one in
//               which it is added.
//
//               Setting this value after the task has already been
//               added will not affect the task's wake time; it will
//               only affect the task if it is re-added to the queue
//               in the future, for instance if the task returns
//               DS_again.  However, see recalc_wake_time() if you wish
//               to apply the delay effect immediately.
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  5 delay 1 478  
6 14 Dtool__0BPpWTY 0 4 10 477 0 14 Dtool__0BPpWTY 472 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::clear_delay
//       Access: Published
//  Description: Removes any delay specified for the task.  The next
//               time the task is added to the queue, it will run
//               immediately.  This does not affect the task's wake
//               time if it has already been added to the queue.
//////////////////////////////////////////////////////////////////// 1 4 this 3 476  
7 14 Dtool__0BPsivV 0 6 11 474 0 14 Dtool__0BPsivV 324 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::has_delay
//       Access: Published
//  Description: Returns true if a delay has been set for this task
//               via set_delay(), or false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
8 14 Dtool__0BPAQPP 0 6 12 478 0 14 Dtool__0BPAQPP 301 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_delay
//       Access: Published
//  Description: Returns the delay value that has been set via
//               set_delay, if any.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
9 14 Dtool__0BPbUzD 0 6 13 478 0 14 Dtool__0BPbUzD 674 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_wake_time
//       Access: Published
//  Description: If this task has been added to an AsyncTaskManager
//               with a delay in effect, this returns the time at
//               which the task is expected to awaken.  It has no
//               meaning if the task has not yet been added to a
//               queue, or if there was no delay in effect at the time
//               the task was added.
//
//               If the task's status is not S_sleeping, this returns
//               0.0.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
10 14 Dtool__0BPlARI 0 4 14 477 0 14 Dtool__0BPlARI 774 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::recalc_wake_time
//       Access: Published
//  Description: If the task is currently sleeping on a task
//               chain, this resets its wake time to the current time
//               + get_delay().  It is as if the task had suddenly
//               returned DS_again.  The task will sleep for its
//               current delay seconds before running again.  This
//               method may therefore be used to make the task wake up
//               sooner or later than it would have otherwise.
//
//               If the task is not already sleeping, this method has
//               no effect.
//////////////////////////////////////////////////////////////////// 1 4 this 3 476  
11 14 Dtool__0BPk8xn 0 6 15 478 0 14 Dtool__0BPk8xn 435 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_start_time
//       Access: Published
//  Description: Returns the time at which the task was started,
//               according to the task manager's clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
12 14 Dtool__0BP3hfK 0 6 16 478 0 14 Dtool__0BP3hfK 478 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_elapsed_time
//       Access: Published
//  Description: Returns the amount of time that has elapsed since
//               the task was started, according to the task manager's
//               clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
13 14 Dtool__0BP5bqk 0 6 17 479 0 14 Dtool__0BP5bqk 444 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_start_frame
//       Access: Published
//  Description: Returns the frame number at which the task was
//               started, according to the task manager's clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
14 14 Dtool__0BPfl5u 0 6 18 479 0 14 Dtool__0BPfl5u 483 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_elapsed_frames
//       Access: Published
//  Description: Returns the number of frames that have elapsed since
//               the task was started, according to the task manager's
//               clock.
//
//               It is only valid to call this if the task's status is
//               not S_inactive.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
15 14 Dtool__0BP8zQe 0 4 19 477 0 14 Dtool__0BP8zQe 218 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_name
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  4 name 1 480  
16 14 Dtool__0BPyLRb 0 4 20 477 0 14 Dtool__0BPyLRb 250 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::clear_name
//       Access: Public
//  Description: Resets the task's name to empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 476  
17 14 Dtool__0BP94vM 0 6 21 480 0 14 Dtool__0BP94vM 375 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_name_prefix
//       Access: Published
//  Description: Returns the initial part of the name, up to but not
//               including any trailing digits following a hyphen or
//               underscore.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
18 14 Dtool__0BPi2xR 0 6 22 481 0 14 Dtool__0BPi2xR 329 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_task_id
//       Access: Public
//  Description: Returns a number guaranteed to be unique for each
//               different AsyncTask object in the universe.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
19 14 Dtool__0BP91hD 0 4 23 477 0 14 Dtool__0BP91hD 380 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_task_chain
//       Access: Published
//  Description: Specifies the AsyncTaskChain on which this task will
//               be running.  Each task chain runs tasks independently
//               of the others.
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  10 chain_name 1 480  
20 14 Dtool__0BPltnG 0 6 24 480 0 14 Dtool__0BPltnG 378 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_task_chain
//       Access: Published
//  Description: Returns the AsyncTaskChain on which this task will
//               be running.  Each task chain runs tasks independently
//               of the others.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
21 14 Dtool__0BPXkCL 0 4 25 477 0 14 Dtool__0BPXkCL 823 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_sort
//       Access: Published
//  Description: Specifies a sort value for this task.  Within a given
//               AsyncTaskManager, all of the tasks with a given sort
//               value are guaranteed to be completed before any tasks
//               with a higher sort value are begun.
//
//               To put it another way, two tasks might execute in
//               parallel with each other only if they both have the
//               same sort value.  Tasks with a lower sort value are
//               executed first.
//
//               This is different from the priority, which makes no
//               such exclusion guarantees.
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  4 sort 1 479  
22 14 Dtool__0BP1ssW 0 6 26 479 0 14 Dtool__0BP1ssW 291 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_sort
//       Access: Published
//  Description: Returns the task's current sort value.  See
//               set_sort().
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
23 14 Dtool__0BPYN6x 0 4 27 477 0 14 Dtool__0BPYN6x 1339 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_priority
//       Access: Published
//  Description: Specifies a priority value for this task.  In
//               general, tasks with a higher priority value are
//               executed before tasks with a lower priority value
//               (but only for tasks with the same sort value).
//
//               Unlike the sort value, tasks with different
//               priorities may execute at the same time, if the
//               AsyncTaskManager has more than one thread servicing
//               tasks.
//
//               Also see AsyncTaskChain::set_timeslice_priority(),
//               which changes the meaning of this value.  In the
//               default mode, when the timeslice_priority flag is
//               false, all tasks always run once per epoch,
//               regardless of their priority values (that is, the
//               priority controls the order of the task execution
//               only, not the number of times it runs).  On the other
//               hand, if you set the timeslice_priority flag to true,
//               then changing a task's priority has an effect on the
//               number of times it runs.
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  8 priority 1 479  
24 14 Dtool__0BPtIKP 0 6 28 479 0 14 Dtool__0BPtIKP 303 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_priority
//       Access: Published
//  Description: Returns the task's current priority value.  See
//               set_priority().
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
25 14 Dtool__0BPtIg_ 0 4 29 477 0 14 Dtool__0BPtIg_ 529 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_done_event
//       Access: Published
//  Description: Sets the event name that will be triggered
//               when the task finishes.  This should only be called
//               before the task has been started, or after it has
//               finished and before it is about to be restarted
//               (i.e. when get_state() returns S_inactive).
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  10 done_event 1 480  
26 14 Dtool__0BP2KmC 0 6 30 480 0 14 Dtool__0BP2KmC 334 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_done_event
//       Access: Published
//  Description: Returns the event name that will be triggered
//               when the task finishes.  See set_done_event().
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
27 14 Dtool__0BP_VH6 0 4 31 477 0 14 Dtool__0BP_VH6 326 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::set_python_object
//       Access: Published
//  Description: Specifies an arbitrary Python object that will be
//               piggybacked on the task object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 476  13 python_object 1 482  
28 14 Dtool__0BPgH_B 0 6 32 482 0 14 Dtool__0BPgH_B 374 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_python_object
//       Access: Published
//  Description: Returns the Python object that was specified to
//               set_python_object(), if any, or None if no object was
//               specified.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
29 14 Dtool__0BPLfJS 0 6 33 478 0 14 Dtool__0BPLfJS 333 // HAVE_PYTHON
////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_dt
//       Access: Published
//  Description: Returns the amount of time elapsed during the task's
//               previous run cycle, in seconds.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
30 14 Dtool__0BPzZ3e 0 6 34 478 0 14 Dtool__0BPzZ3e 342 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_max_dt
//       Access: Published
//  Description: Returns the maximum amount of time elapsed during any
//               one of the task's previous run cycles, in seconds.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
31 14 Dtool__0BPCRX9 0 6 35 478 0 14 Dtool__0BPCRX9 343 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::get_average_dt
//       Access: Published
//  Description: Returns the average amount of time elapsed during
//               each of the task's previous run cycles, in seconds.
//////////////////////////////////////////////////////////////////// 1 4 this 3 472  
32 14 Dtool__0BPHnlZ 0 4 36 477 0 14 Dtool__0BPHnlZ 226 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTask::output
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 472  3 out 1 484  
33 14 Dtool__0BPw0XF 0 7 37 487 0 14 Dtool__0BPw0XF 0 0 
34 14 Dtool__0BPSkoD 0 7 39 488 263 14 Dtool__0BPSkoD 231 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
35 14 Dtool__0BPxEl_ 0 7 39 488 263 14 Dtool__0BPxEl_ 236 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Copy Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 489  
36 14 Dtool__0BPNLwX 0 6 40 488 0 14 Dtool__0BPNLwX 244 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::Copy Assignment Operator
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  4 copy 1 489  
37 14 Dtool__0BP2nKN 0 4 42 477 0 14 Dtool__0BP2nKN 268 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::add_task
//       Access: Published
//  Description: Adds a new AsyncTask to the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  4 task 1 476  
38 14 Dtool__0BPvsJR 0 6 43 474 0 14 Dtool__0BPvsJR 404 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_task
//       Access: Published
//  Description: Removes the indicated AsyncTask from the collection.
//               Returns true if the task was removed, false if it was
//               not a member of the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  4 task 1 476  
39 14 Dtool__0BPZKrj 0 4 43 477 0 14 Dtool__0BPZKrj 278 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_task
//       Access: Published
//  Description: Removes the nth AsyncTask from the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  5 index 1 479  
40 14 Dtool__0BP0A9n 0 4 44 477 0 14 Dtool__0BP0A9n 474 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::add_tasks_from
//       Access: Published
//  Description: Adds all the AsyncTasks indicated in the other
//               collection to this task.  The other tasks are simply
//               appended to the end of the tasks in this list;
//               duplicates are not automatically removed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  5 other 1 489  
41 14 Dtool__0BPcy3Y 0 4 45 477 0 14 Dtool__0BPcy3Y 337 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_tasks_from
//       Access: Published
//  Description: Removes from this collection all of the AsyncTasks
//               listed in the other collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  5 other 1 489  
42 14 Dtool__0BP21th 0 4 46 477 0 14 Dtool__0BP21th 476 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::remove_duplicate_tasks
//       Access: Published
//  Description: Removes any duplicate entries of the same AsyncTasks
//               on this collection.  If a AsyncTask appears multiple
//               times, the first appearance is retained; subsequent
//               appearances are removed.
//////////////////////////////////////////////////////////////////// 1 4 this 3 488  
43 14 Dtool__0BPMvWB 0 6 47 474 0 14 Dtool__0BPMvWB 330 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::has_task
//       Access: Published
//  Description: Returns true if the indicated AsyncTask appears in
//               this collection, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  4 task 1 476  
44 14 Dtool__0BPUH27 0 4 48 477 0 14 Dtool__0BPUH27 269 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::clear
//       Access: Published
//  Description: Removes all AsyncTasks from the collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 488  
45 14 Dtool__0BPWzin 0 7 49 476 0 14 Dtool__0BPWzin 365 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::find_task
//       Access: Published
//  Description: Returns the task in the collection with the
//               indicated name, if any, or NULL if no task has
//               that name.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  4 name 1 480  
46 14 Dtool__0BPflYR 0 6 50 479 0 14 Dtool__0BPflYR 285 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::get_num_tasks
//       Access: Published
//  Description: Returns the number of AsyncTasks in the collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 489  
47 14 Dtool__0BP8pNb 0 7 51 476 0 14 Dtool__0BP8pNb 273 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::get_task
//       Access: Published
//  Description: Returns the nth AsyncTask in the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  5 index 1 479  
48 14 Dtool__0BPFdZy 0 7 52 476 0 14 Dtool__0BPFdZy 393 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator []
//       Access: Published
//  Description: Returns the nth AsyncTask in the collection.  This is
//               the same as get_task(), but it may be a more
//               convenient way to access it.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  5 index 1 479  
49 14 Dtool__0BPLVO4 0 6 53 479 0 14 Dtool__0BPLVO4 332 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::size
//       Access: Published
//  Description: Returns the number of tasks in the collection.  This
//               is the same thing as get_num_tasks().
//////////////////////////////////////////////////////////////////// 1 4 this 3 489  
50 14 Dtool__0BPdX4s 0 6 54 488 0 14 Dtool__0BPdX4s 280 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator +=
//       Access: Published
//  Description: Appends the other list onto the end of this one.
//////////////////////////////////////////////////////////////////// 2 4 this 3 488  5 other 1 489  
51 14 Dtool__0BPy_me 0 7 55 488 263 14 Dtool__0BPy_me 326 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::operator +
//       Access: Published
//  Description: Returns a AsyncTaskCollection representing the
//               concatenation of the two lists.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  5 other 1 489  
52 14 Dtool__0BPyZ_w 0 4 56 477 0 14 Dtool__0BPyZ_w 338 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::output
//       Access: Published
//  Description: Writes a brief one-line description of the
//               AsyncTaskCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  3 out 1 484  
53 14 Dtool__0BP8BXN 0 4 57 477 0 14 Dtool__0BP8BXN 342 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               AsyncTaskCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 3 4 this 3 489  3 out 1 484  12 indent_level 1 479  
54 14 Dtool__0BP2J5y 0 4 57 477 0 14 Dtool__0BP2J5y 342 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               AsyncTaskCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 2 4 this 3 489  3 out 1 484  
55 14 Dtool__0BPo_B5 0 4 66 477 0 14 Dtool__0BPo_B5 405 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_tick_clock
//       Access: Published
//  Description: Sets the tick_clock flag.  When this is true,
//               get_clock()->tick() will be called automatically at
//               each task epoch.  This is false by default.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  10 tick_clock 1 474  
56 14 Dtool__0BPxxSX 0 6 67 474 0 14 Dtool__0BPxxSX 281 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_tick_clock
//       Access: Published
//  Description: Returns the tick_clock flag.  See set_tick_clock().
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
57 14 Dtool__0BP9FyQ 0 4 68 477 0 14 Dtool__0BP9FyQ 382 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_num_threads
//       Access: Published
//  Description: Changes the number of threads for this task chain.
//               This may require stopping the threads if they are
//               already running.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  11 num_threads 1 479  
58 14 Dtool__0BP5gri 0 6 69 479 0 14 Dtool__0BP5gri 376 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_threads
//       Access: Published
//  Description: Returns the number of threads that will be servicing
//               tasks for this chain.  Also see
//               get_num_running_threads().
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
59 14 Dtool__0BPkFx8 0 6 70 479 0 14 Dtool__0BPkFx8 484 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_running_threads
//       Access: Published
//  Description: Returns the number of threads that have been created
//               and are actively running.  This will return 0 before
//               the threads have been started; it will also return 0
//               if thread support is not available.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
60 14 Dtool__0BPOSFL 0 4 71 477 0 14 Dtool__0BPOSFL 409 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_thread_priority
//       Access: Published
//  Description: Changes the priority associated with threads that
//               serve this task chain.  This may require stopping the
//               threads if they are already running.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  8 priority 1 494  
61 14 Dtool__0BPKEgg 0 6 72 494 0 14 Dtool__0BPKEgg 324 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_thread_priority
//       Access: Published
//  Description: Returns the priority associated with threads that
//               serve this task chain.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
62 14 Dtool__0BPoWmJ 0 4 73 477 0 14 Dtool__0BPoWmJ 739 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_frame_budget
//       Access: Published
//  Description: Sets the maximum amount of time per frame the tasks
//               on this chain are granted for execution.  If this is
//               less than zero, there is no limit; if it is >= 0, it
//               represents a maximum amount of time (in seconds) that
//               will be used to execute tasks.  If this time is
//               exceeded in any one frame, the task chain will stop
//               executing tasks until the next frame, as defined by
//               the TaskManager's clock.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  12 frame_budget 1 478  
63 14 Dtool__0BPVK3e 0 6 74 478 0 14 Dtool__0BPVK3e 386 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_frame_budget
//       Access: Published
//  Description: Returns the maximum amount of time per frame the
//               tasks on this chain are granted for execution.  See
//               set_frame_budget().
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
64 14 Dtool__0BPzPla 0 4 75 477 0 14 Dtool__0BPzPla 1050 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_frame_sync
//       Access: Published
//  Description: Sets the frame_sync flag.  When this flag is true,
//               this task chain will be forced to sync with the
//               TaskManager's clock.  It will run no faster than one
//               epoch per clock frame.
//
//               When this flag is false, the default, the task chain
//               will finish all of its tasks and then immediately
//               start from the first task again, regardless of the
//               clock frame.  When it is true, the task chain will
//               finish all of its tasks and then wait for the clock
//               to tick to the next frame before resuming the first
//               task.
//
//               This only makes sense for threaded task chains.
//               Non-threaded task chains are automatically
//               synchronous.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  10 frame_sync 1 474  
65 14 Dtool__0BPS404 0 6 76 474 0 14 Dtool__0BPS404 281 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_frame_sync
//       Access: Published
//  Description: Returns the frame_sync flag.  See set_frame_sync().
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
66 14 Dtool__0BP1xj2 0 4 77 477 0 14 Dtool__0BP1xj2 1385 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::set_timeslice_priority
//       Access: Published
//  Description: Sets the timeslice_priority flag.  This changes
//               the interpretation of priority, and the number of
//               times per epoch each task will run.  
//
//               When this flag is true, some tasks might not run in
//               any given epoch.  Instead, tasks with priority higher
//               than 1 will be given precedence, in proportion to the
//               amount of time they have already used.  This gives
//               higher-priority tasks more runtime than
//               lower-priority tasks.  Each task gets the amount of
//               time proportional to its priority value, so a task
//               with priority 100 will get five times as much
//               processing time as a task with priority 20.  For
//               these purposes, priority values less than 1 are
//               deemed to be equal to 1.
//
//               When this flag is false (the default), all tasks are
//               run exactly once each epoch, round-robin style.
//               Priority is only used to determine which task runs
//               first within tasks of the same sort value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 491  18 timeslice_priority 1 474  
67 14 Dtool__0BPe4Vk 0 6 78 474 0 14 Dtool__0BPe4Vk 456 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_timeslice_priority
//       Access: Published
//  Description: Returns the timeslice_priority flag.  This changes
//               the interpretation of priority, and the number of
//               times per epoch each task will run.  See
//               set_timeslice_priority().
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
68 14 Dtool__0BP12Qz 0 4 79 477 0 14 Dtool__0BP12Qz 477 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::stop_threads
//       Access: Published
//  Description: Stops any threads that are currently running.  If any
//               tasks are still pending and have not yet been picked
//               up by a thread, they will not be serviced unless
//               poll() or start_threads() is later called.
//////////////////////////////////////////////////////////////////// 1 4 this 3 491  
69 14 Dtool__0BPoK_0 0 4 80 477 0 14 Dtool__0BPoK_0 417 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::start_threads
//       Access: Published
//  Description: Starts any requested threads to service the tasks on
//               the queue.  This is normally not necessary, since
//               adding a task will start the threads automatically.
//////////////////////////////////////////////////////////////////// 1 4 this 3 491  
70 14 Dtool__0BP84K8 0 6 81 474 0 14 Dtool__0BP84K8 962 // Filename: asyncTaskChain.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::is_started
//       Access: Published
//  Description: Returns true if the thread(s) have been started and
//               are ready to service requests, false otherwise.  If
//               this is false, the next call to add() or add_and_do()
//               will automatically start the threads.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
71 14 Dtool__0BPU5BM 0 6 82 474 0 14 Dtool__0BPU5BM 331 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::has_task
//       Access: Published
//  Description: Returns true if the indicated task has been added to
//               this AsyncTaskChain, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 492  4 task 1 476  
72 14 Dtool__0BPB_5g 0 4 83 477 0 14 Dtool__0BPB_5g 266 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::wait_for_tasks
//       Access: Published
//  Description: Blocks until the task list is empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 491  
73 14 Dtool__0BPm2D0 0 6 84 479 0 14 Dtool__0BPm2D0 334 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_num_tasks
//       Access: Published
//  Description: Returns the number of tasks that are currently active
//               or sleeping within the task chain.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
74 14 Dtool__0BPAd9D 0 7 85 488 263 14 Dtool__0BPAd9D 338 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active or sleeping
//               on the task chain, at the time of the call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
75 14 Dtool__0BPtBbo 0 7 86 488 263 14 Dtool__0BPtBbo 369 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_active_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active (and not
//               sleeping) on the task chain, at the time of the
//               call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
76 14 Dtool__0BP8rFY 0 7 87 488 263 14 Dtool__0BP8rFY 371 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_sleeping_tasks
//       Access: Published
//  Description: Returns the set of tasks that are sleeping (and not
//               active) on the task chain, at the time of the
//               call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
77 14 Dtool__0BPeby3 0 4 88 477 0 14 Dtool__0BPeby3 697 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::poll
//       Access: Published
//  Description: Runs through all the tasks in the task list, once, if
//               the task chain is running in single-threaded mode
//               (no threads available).  This method does nothing in
//               threaded mode, so it may safely be called in either
//               case.
//
//               Normally, you would not call this function directly;
//               instead, call AsyncTaskManager::poll(), which polls
//               all of the task chains in sequence.
//////////////////////////////////////////////////////////////////// 1 4 this 3 491  
78 14 Dtool__0BPdTsN 0 6 89 478 0 14 Dtool__0BPdTsN 420 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::get_next_wake_time
//       Access: Published
//  Description: Returns the scheduled time (on the manager's clock)
//               of the next sleeping task, on any task chain, to
//               awaken.  Returns -1 if there are no sleeping tasks.
//////////////////////////////////////////////////////////////////// 1 4 this 3 492  
79 14 Dtool__0BPQv2j 0 4 90 477 0 14 Dtool__0BPQv2j 231 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::output
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 492  3 out 1 484  
80 14 Dtool__0BPInBS 0 4 91 477 0 14 Dtool__0BPInBS 230 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::write
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 3 4 this 3 492  3 out 1 484  12 indent_level 1 479  
81 14 Dtool__0BPZqzk 0 4 91 477 0 14 Dtool__0BPZqzk 230 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskChain::write
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 492  3 out 1 484  
82 14 Dtool__0BPydd7 0 7 92 487 0 14 Dtool__0BPydd7 0 0 
83 14 Dtool__0BPXMBl 0 7 60 495 0 14 Dtool__0BPXMBl 0 1 4 this 3 491  
84 14 Dtool__0BPmpui 0 7 61 491 284 14 Dtool__0BPmpui 0 1 4 this 3 495  
85 14 Dtool__0BP69cz 0 6 63 496 0 14 Dtool__0BP69cz 0 1 4 this 3 491  
86 14 Dtool__0BPIr5t 0 7 64 491 284 14 Dtool__0BPIr5t 0 1 4 this 3 496  
87 14 Dtool__0BPYMSQ 0 7 98 475 317 14 Dtool__0BPYMSQ 228 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 480  
88 14 Dtool__0BPS_5O 0 4 100 477 0 14 Dtool__0BPS_5O 345 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::cleanup
//       Access: Published
//  Description: Stops all threads and messily empties the task list.
//               This is intended to be called on destruction only.
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
89 14 Dtool__0BPHTif 0 4 101 477 0 14 Dtool__0BPHTif 1070 // Filename: asyncTaskManager.I
// Created by:  drose (23Aug06)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::set_clock
//       Access: Published
//  Description: Replaces the clock pointer used within the
//               AsyncTaskManager.  This is used to control when tasks
//               with a set_delay() specified will be scheduled.  It
//               can also be ticked automatically each epoch, if
//               set_tick_clock() is true.
//
//               The default is the global clock pointer.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  5 clock 1 497  
90 14 Dtool__0BPX24c 0 7 102 497 0 14 Dtool__0BPX24c 321 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_clock
//       Access: Published
//  Description: Returns the clock pointer used within the
//               AsyncTaskManager.  See set_clock().
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
91 14 Dtool__0BPi01B 0 6 103 479 0 14 Dtool__0BPi01B 281 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_num_task_chains
//       Access: Published
//  Description: Returns the number of different task chains.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
92 14 Dtool__0BPh4W4 0 7 104 491 284 14 Dtool__0BPh4W4 259 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_task_chain
//       Access: Published
//  Description: Returns the nth task chain.
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  1 n 1 479  
93 14 Dtool__0BPE4kq 0 7 105 491 284 14 Dtool__0BPE4kq 445 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::make_task_chain
//       Access: Published
//  Description: Creates a new AsyncTaskChain of the indicated name
//               and stores it within the AsyncTaskManager.  If a task
//               chain with this name already exists, returns it
//               instead.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  4 name 1 480  
94 14 Dtool__0BPdayw 0 7 106 491 284 14 Dtool__0BPdayw 349 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_task_chain
//       Access: Protected
//  Description: Searches a new AsyncTaskChain of the indicated name
//               and returns it if it exists, or NULL otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  4 name 1 480  
95 14 Dtool__0BPQ6mt 0 6 107 474 0 14 Dtool__0BPQ6mt 496 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove_task_chain
//       Access: Protected
//  Description: Removes the AsyncTaskChain of the indicated name.
//               If the chain still has tasks, this will block until
//               all tasks are finished.
//
//               Returns true if successful, or false if the chain did
//               not exist.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  4 name 1 480  
96 14 Dtool__0BPnnsz 0 4 108 477 0 14 Dtool__0BPnnsz 379 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::add
//       Access: Published
//  Description: Adds the indicated task to the active queue.  It is
//               an error if the task is already added to this or any
//               other active queue.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  4 task 1 476  
97 14 Dtool__0BPqAr_ 0 6 109 474 0 14 Dtool__0BPqAr_ 335 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::has_task
//       Access: Published
//  Description: Returns true if the indicated task has been added to
//               this AsyncTaskManager, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  4 task 1 476  
98 14 Dtool__0BPp_YG 0 7 110 476 0 14 Dtool__0BPp_YG 468 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_task
//       Access: Published
//  Description: Returns the first task found with the indicated name,
//               or NULL if there is no task with the indicated name.
//
//               If there are multiple tasks with the same name,
//               returns one of them arbitrarily.
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  4 name 1 480  
99 14 Dtool__0BPYL4O 0 7 111 488 263 14 Dtool__0BPYL4O 301 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_tasks
//       Access: Published
//  Description: Returns the list of tasks found with the indicated
//               name.
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  4 name 1 480  
100 14 Dtool__0BP9jZl 0 7 112 488 263 14 Dtool__0BP9jZl 350 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::find_tasks_matching
//       Access: Published
//  Description: Returns the list of tasks found whose name matches
//               the indicated glob pattern, e.g. "my_task_*".
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  7 pattern 1 501  
101 14 Dtool__0BPSc4O 0 6 113 474 0 14 Dtool__0BPSc4O 386 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove
//       Access: Published
//  Description: Removes the indicated task from the active queue.
//               Returns true if the task is successfully removed, or
//               false if it wasn't there.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  4 task 1 476  
102 14 Dtool__0BPnDvE 0 6 113 479 0 14 Dtool__0BPnDvE 330 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::remove
//       Access: Published
//  Description: Removes all of the tasks in the AsyncTaskCollection.
//               Returns the number of tasks removed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 475  5 tasks 1 489  
103 14 Dtool__0BPPAhy 0 4 114 477 0 14 Dtool__0BPPAhy 268 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::wait_for_tasks
//       Access: Published
//  Description: Blocks until the task list is empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
104 14 Dtool__0BPVy_j 0 4 115 477 0 14 Dtool__0BPVy_j 479 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::stop_threads
//       Access: Published
//  Description: Stops any threads that are currently running.  If any
//               tasks are still pending and have not yet been picked
//               up by a thread, they will not be serviced unless
//               poll() or start_threads() is later called.
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
105 14 Dtool__0BPobix 0 4 116 477 0 14 Dtool__0BPobix 419 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::start_threads
//       Access: Published
//  Description: Starts any requested threads to service the tasks on
//               the queue.  This is normally not necessary, since
//               adding a task will start the threads automatically.
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
106 14 Dtool__0BPj096 0 6 117 479 0 14 Dtool__0BPj096 338 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_num_tasks
//       Access: Published
//  Description: Returns the number of tasks that are currently active
//               or sleeping within the task manager.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
107 14 Dtool__0BPVFO_ 0 7 118 488 263 14 Dtool__0BPVFO_ 342 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active or sleeping
//               on the task manager, at the time of the call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
108 14 Dtool__0BPS10A 0 7 119 488 263 14 Dtool__0BPS10A 373 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_active_tasks
//       Access: Published
//  Description: Returns the set of tasks that are active (and not
//               sleeping) on the task manager, at the time of the
//               call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
109 14 Dtool__0BPwRzv 0 7 120 488 263 14 Dtool__0BPwRzv 375 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_sleeping_tasks
//       Access: Published
//  Description: Returns the set of tasks that are sleeping (and not
//               active) on the task manager, at the time of the
//               call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
110 14 Dtool__0BPZTnl 0 4 121 477 0 14 Dtool__0BPZTnl 506 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::poll
//       Access: Published
//  Description: Runs through all the tasks in the task list, once, if
//               the task manager is running in single-threaded mode
//               (no threads available).  This method does nothing in
//               threaded mode, so it may safely be called in either
//               case.
//////////////////////////////////////////////////////////////////// 1 4 this 3 475  
111 14 Dtool__0BPvp8z 0 6 122 478 0 14 Dtool__0BPvp8z 422 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_next_wake_time
//       Access: Published
//  Description: Returns the scheduled time (on the manager's clock)
//               of the next sleeping task, on any task chain, to
//               awaken.  Returns -1 if there are no sleeping tasks.
//////////////////////////////////////////////////////////////////// 1 4 this 3 499  
112 14 Dtool__0BPIJ3Z 0 4 123 477 0 14 Dtool__0BPIJ3Z 233 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::output
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  3 out 1 484  
113 14 Dtool__0BPNs3q 0 4 124 477 0 14 Dtool__0BPNs3q 232 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::write
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 3 4 this 3 499  3 out 1 484  12 indent_level 1 479  
114 14 Dtool__0BPQjZ0 0 4 124 477 0 14 Dtool__0BPQjZ0 232 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::write
//       Access: Published, Virtual
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 499  3 out 1 484  
115 14 Dtool__0BPx0eS 0 7 125 475 317 14 Dtool__0BPx0eS 403 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskManager::get_global_ptr
//       Access: Published
//  Description: Returns a pointer to the global AsyncTaskManager.
//               This is the AsyncTaskManager that most code should
//               use for queueing tasks and suchlike.
//////////////////////////////////////////////////////////////////// 0 
116 14 Dtool__0BPUJuq 0 7 126 487 0 14 Dtool__0BPUJuq 0 0 
117 14 Dtool__0BPdEa8 0 7 94 495 0 14 Dtool__0BPdEa8 0 1 4 this 3 475  
118 14 Dtool__0BPk75D 0 7 95 475 317 14 Dtool__0BPk75D 0 1 4 this 3 495  
119 14 Dtool__0BPL3RV 0 6 96 496 0 14 Dtool__0BPL3RV 0 1 4 this 3 475  
120 14 Dtool__0BP2o_1 0 7 97 475 317 14 Dtool__0BP2o_1 0 1 4 this 3 496  
121 14 Dtool__0BP_xTa 0 7 128 504 350 14 Dtool__0BP_xTa 226 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskPause::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 5 delay 1 478  
122 14 Dtool__0BP8w6q 0 4 129 477 0 14 Dtool__0BP8w6q 0 2 4 this 3 504  4 size 1 505  
123 14 Dtool__0BPfgXx 0 7 132 487 0 14 Dtool__0BPfgXx 0 0 
124 14 Dtool__0BPXNVH 0 7 139 506 356 14 Dtool__0BPXNVH 229 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 480  
125 14 Dtool__0BP6tux 0 4 141 477 0 14 Dtool__0BP6tux 0 2 4 this 3 506  4 size 1 505  
126 14 Dtool__0BP7KDU 0 4 144 477 0 14 Dtool__0BP7KDU 1026 // Filename: asyncTaskSequence.I
// Created by:  drose (04Oct08)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::set_repeat_count
//       Access: Published
//  Description: Sets the repeat count of the sequence.  If the count
//               is 0 or 1, the sequence will run exactly once.  If it
//               is greater than 0, it will run that number of times.
//               If it is negative, it will run forever until it is
//               explicitly removed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 506  12 repeat_count 1 479  
127 14 Dtool__0BPORsI 0 6 145 479 0 14 Dtool__0BPORsI 318 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::get_repeat_count
//       Access: Published
//  Description: Returns the repeat count of the sequence.  See
//               set_repeat_count().
//////////////////////////////////////////////////////////////////// 1 4 this 3 507  
128 14 Dtool__0BP9R5X 0 6 146 479 0 14 Dtool__0BP9R5X 403 ////////////////////////////////////////////////////////////////////
//     Function: AsyncTaskSequence::get_current_task_index
//       Access: Published
//  Description: Returns the index of the task within the sequence
//               that is currently being executed (or that will be
//               executed at the next epoch).
//////////////////////////////////////////////////////////////////// 1 4 this 3 507  
129 14 Dtool__0BPMs6L 0 7 147 487 0 14 Dtool__0BPMs6L 0 0 
130 14 Dtool__0BP_W76 0 7 135 476 0 14 Dtool__0BP_W76 0 1 4 this 3 506  
131 14 Dtool__0BPe1fT 0 7 136 506 356 14 Dtool__0BPe1fT 0 1 4 this 3 476  
132 14 Dtool__0BPMsgr 0 6 137 488 0 14 Dtool__0BPMsgr 0 1 4 this 3 506  
133 14 Dtool__0BPq_2Y 0 7 138 506 356 14 Dtool__0BPq_2Y 0 1 4 this 3 488  
134 14 Dtool__0BPEmAg 0 7 149 509 366 14 Dtool__0BPEmAg 321 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Default constructor
//       Access: Published
//  Description: Defines an EventParameter that stores nothing: the
//               "empty" parameter.
//////////////////////////////////////////////////////////////////// 0 
135 14 Dtool__0BPuMqR 0 7 149 509 366 14 Dtool__0BPuMqR 231 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Copy constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 510  
136 14 Dtool__0BPtTUl 0 7 149 509 366 14 Dtool__0BPtTUl 837 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Pointer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a pointer to
//               a TypedReferenceCount object.  Note that a
//               TypedReferenceCount is not the same kind of pointer
//               as a TypedWritableReferenceCount, hence we require
//               both constructors.
//
//               This accepts a const pointer, even though it stores
//               (and eventually returns) a non-const pointer.  This
//               is just the simplest way to allow both const and
//               non-const pointers to be stored, but it does lose the
//               constness.  Be careful.
//////////////////////////////////////////////////////////////////// 1 3 ptr 1 512  
137 14 Dtool__0BP3aRa 0 7 149 509 366 14 Dtool__0BP3aRa 725 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Pointer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a pointer to
//               any kind of TypedWritableReferenceCount object.  This
//               is the most general constructor.
//
//               This accepts a const pointer, even though it stores
//               (and eventually returns) a non-const pointer.  This
//               is just the simplest way to allow both const and
//               non-const pointers to be stored, but it does lose the
//               constness.  Be careful.
//////////////////////////////////////////////////////////////////// 1 3 ptr 1 514  
138 14 Dtool__0BPfaFB 0 7 149 509 366 14 Dtool__0BPfaFB 287 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::String constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a string value.
//////////////////////////////////////////////////////////////////// 1 5 value 1 480  
139 14 Dtool__0BPMmWI 0 7 149 509 366 14 Dtool__0BPMmWI 289 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Wstring constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a wstring value.
//////////////////////////////////////////////////////////////////// 1 5 value 1 480  
140 14 Dtool__0BPnJZK 0 7 149 509 366 14 Dtool__0BPnJZK 312 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Double constructor
//       Access: Published
//  Description: Defines an EventParameter that stores a
//               floating-point value.
//////////////////////////////////////////////////////////////////// 1 5 value 1 478  
141 14 Dtool__0BPuZZH 0 7 149 509 366 14 Dtool__0BPuZZH 307 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Integer constructor
//       Access: Published
//  Description: Defines an EventParameter that stores an integer
//               value.
//////////////////////////////////////////////////////////////////// 1 5 value 1 479  
142 14 Dtool__0BP4fZ1 0 6 150 509 0 14 Dtool__0BP4fZ1 239 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::Copy assignment operator
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 509  4 copy 1 510  
143 14 Dtool__0BPYeRx 0 6 152 474 0 14 Dtool__0BPYeRx 336 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_empty
//       Access: Published
//  Description: Returns true if the EventParameter is the empty
//               parameter, storing nothing, or false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
144 14 Dtool__0BPcncs 0 6 153 474 0 14 Dtool__0BPcncs 315 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_int
//       Access: Published
//  Description: Returns true if the EventParameter stores an integer
//               value, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
145 14 Dtool__0BPIOzj 0 6 154 479 0 14 Dtool__0BPIOzj 382 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_int_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_int() has already
//               returned true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
146 14 Dtool__0BP9jXI 0 6 155 474 0 14 Dtool__0BP9jXI 331 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_double
//       Access: Published
//  Description: Returns true if the EventParameter stores a double
//               floating-point value, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
147 14 Dtool__0BP66KS 0 6 156 478 0 14 Dtool__0BP66KS 388 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_double_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_double() has already
//               returned true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
148 14 Dtool__0BPEB1z 0 6 157 474 0 14 Dtool__0BPEB1z 316 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_string
//       Access: Published
//  Description: Returns true if the EventParameter stores a string
//               value, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
149 14 Dtool__0BPgAhB 0 6 158 480 0 14 Dtool__0BPgAhB 388 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_string_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_string() has already
//               returned true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
150 14 Dtool__0BPuy4v 0 6 159 474 0 14 Dtool__0BPuy4v 318 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_wstring
//       Access: Published
//  Description: Returns true if the EventParameter stores a wstring
//               value, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
151 14 Dtool__0BPyazl 0 6 160 480 0 14 Dtool__0BPyazl 390 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_wstring_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_wstring() has already
//               returned true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
152 14 Dtool__0BPms0H 0 6 161 474 0 14 Dtool__0BPms0H 537 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::is_typed_ref_count
//       Access: Published
//  Description: Returns true if the EventParameter stores a
//               TypedReferenceCount pointer, false otherwise.  Note
//               that a TypedReferenceCount is not exactly the same
//               kind of pointer as a TypedWritableReferenceCount,
//               hence the need for this separate call.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
153 14 Dtool__0BP1NVx 0 7 162 495 0 14 Dtool__0BP1NVx 406 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_typed_ref_count_value
//       Access: Published
//  Description: Retrieves the value stored in the EventParameter.  It
//               is only valid to call this if is_typed_ref_count()
//               has already returned true.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
154 14 Dtool__0BPaU2M 0 7 163 516 0 14 Dtool__0BPaU2M 552 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::get_ptr
//       Access: Published
//  Description: Retrieves a pointer to the actual value stored in the
//               parameter.  The TypeHandle of this pointer may be
//               examined to determine the actual type of parameter it
//               contains.  This is the only way to retrieve the value
//               when it is not one of the above predefined types.
//////////////////////////////////////////////////////////////////// 1 4 this 3 510  
155 14 Dtool__0BPevV2 0 4 164 477 0 14 Dtool__0BPevV2 222 ////////////////////////////////////////////////////////////////////
//     Function: EventParameter::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 510  3 out 1 484  
156 14 Dtool__0BPBRFe 0 4 167 477 0 14 Dtool__0BPBRFe 0 2 4 this 3 517  3 out 1 484  
157 14 Dtool__0BP6mRN 0 7 168 487 0 14 Dtool__0BP6mRN 0 0 
158 14 Dtool__0BPW9X2 0 7 170 519 0 14 Dtool__0BPW9X2 236 ////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 5 value 1 512  
159 14 Dtool__0BPE_M2 0 4 171 477 0 14 Dtool__0BPE_M2 417 ////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::set_value
//       Access: Published
//  Description: Changes the value stored in the parameter.  It is
//               dangerous to do this for a parameter already added to
//               an event, since the parameters may be shared.
//////////////////////////////////////////////////////////////////// 2 4 this 3 519  5 value 1 512  
160 14 Dtool__0BPLOtk 0 7 172 495 0 14 Dtool__0BPLOtk 278 ////////////////////////////////////////////////////////////////////
//     Function: EventStoreTypedRefCount::get_value
//       Access: Published
//  Description: Retrieves the value stored in the parameter.
//////////////////////////////////////////////////////////////////// 1 4 this 3 520  
161 14 Dtool__0BPFKgD 0 7 173 487 0 14 Dtool__0BPFKgD 0 0 
162 14 Dtool__0BPbaOf 0 7 175 524 0 14 Dtool__0BPbaOf 219 ////////////////////////////////////////////////////////////////////
//     Function: Event::Copy constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 522  
163 14 Dtool__0BP_Cqe 0 7 175 524 0 14 Dtool__0BP_Cqe 214 ////////////////////////////////////////////////////////////////////
//     Function: Event::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 10 event_name 1 480  8 receiver 1 525  
164 14 Dtool__0BPiMjT 0 7 175 524 0 14 Dtool__0BPiMjT 214 ////////////////////////////////////////////////////////////////////
//     Function: Event::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 10 event_name 1 480  
165 14 Dtool__0BPyjne 0 7 176 524 0 14 Dtool__0BPyjne 227 ////////////////////////////////////////////////////////////////////
//     Function: Event::Copy Assignment Operator
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 524  4 copy 1 522  
166 14 Dtool__0BP3_7n 0 4 177 477 0 14 Dtool__0BP3_7n 692 // Filename: event.I
// Created by:  drose (15May01)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: Event::set_name
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 524  4 name 1 480  
167 14 Dtool__0BPrUk3 0 4 178 477 0 14 Dtool__0BPrUk3 247 ////////////////////////////////////////////////////////////////////
//     Function: Event::clear_name
//       Access: Public
//  Description: Resets the Event's name to empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 524  
168 14 Dtool__0BP9bdj 0 6 179 474 0 14 Dtool__0BP9bdj 307 ////////////////////////////////////////////////////////////////////
//     Function: Event::has_name
//       Access: Public
//  Description: Returns true if the Event has a nonempty name set,
//               false if the name is empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 522  
169 14 Dtool__0BPDka7 0 6 180 480 0 14 Dtool__0BPDka7 211 ////////////////////////////////////////////////////////////////////
//     Function: Event::get_name
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 522  
170 14 Dtool__0BP6aTn 0 4 181 477 0 14 Dtool__0BP6aTn 216 ////////////////////////////////////////////////////////////////////
//     Function: Event::add_parameter
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 524  3 obj 1 510  
171 14 Dtool__0BPuadO 0 6 182 479 0 14 Dtool__0BPuadO 221 ////////////////////////////////////////////////////////////////////
//     Function: Event::get_num_parameters
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 522  
172 14 Dtool__0BPCpxs 0 7 183 509 366 14 Dtool__0BPCpxs 216 ////////////////////////////////////////////////////////////////////
//     Function: Event::get_parameter
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 522  1 n 1 479  
173 14 Dtool__0BPuqic 0 6 184 474 0 14 Dtool__0BPuqic 215 ////////////////////////////////////////////////////////////////////
//     Function: Event::has_receiver
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 522  
174 14 Dtool__0BPg9f0 0 6 185 525 0 14 Dtool__0BPg9f0 215 ////////////////////////////////////////////////////////////////////
//     Function: Event::get_receiver
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 522  
175 14 Dtool__0BPf1ch 0 4 186 477 0 14 Dtool__0BPf1ch 215 ////////////////////////////////////////////////////////////////////
//     Function: Event::set_receiver
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 524  8 receiver 1 525  
176 14 Dtool__0BPVAhd 0 4 187 477 0 14 Dtool__0BPVAhd 217 ////////////////////////////////////////////////////////////////////
//     Function: Event::clear_receiver
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 524  
177 14 Dtool__0BPYPzc 0 4 188 477 0 14 Dtool__0BPYPzc 209 ////////////////////////////////////////////////////////////////////
//     Function: Event::output
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 522  3 out 1 484  
178 14 Dtool__0BPUXdZ 0 7 189 487 0 14 Dtool__0BPUXdZ 0 0 
179 14 Dtool__0BPwhlR 0 7 192 528 407 14 Dtool__0BPwhlR 221 ////////////////////////////////////////////////////////////////////
//     Function: EventHandler::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 8 ev_queue 1 527  
180 14 Dtool__0BPIZkG 0 4 193 477 0 14 Dtool__0BPIZkG 447 ////////////////////////////////////////////////////////////////////
//     Function: EventHandler::process_events
//       Access: Public
//  Description: The main processing loop of the EventHandler.  This
//               function must be called periodically to service
//               events.  Walks through each pending event and calls
//               its assigned hooks.
//////////////////////////////////////////////////////////////////// 1 4 this 3 528  
181 14 Dtool__0BPH0sA 0 4 194 477 0 14 Dtool__0BPH0sA 306 ////////////////////////////////////////////////////////////////////
//     Function: EventHandler::dispatch_event
//       Access: Public, Virtual
//  Description: Calls the hooks assigned to the indicated single
//               event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 528  6 param0 0 522  
182 14 Dtool__0BP9LkH 0 4 195 477 0 14 Dtool__0BP9LkH 215 ////////////////////////////////////////////////////////////////////
//     Function: EventHandler::write
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 529  3 out 1 484  
183 14 Dtool__0BPcYKa 0 6 196 528 0 14 Dtool__0BPcYKa 881 // Filename: eventHandler.I
// Created by:  skyler (27Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::get_global_event_handler
//       Access: Public
//  Description: Returns a pointer to the one global EventHandler
//               object.  If the global object has not yet been
//               created, this will create it.
//////////////////////////////////////////////////////////////////// 1 5 queue 1 527  
184 14 Dtool__0BPJp0Z 0 6 196 528 0 14 Dtool__0BPJp0Z 881 // Filename: eventHandler.I
// Created by:  skyler (27Jan04)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::get_global_event_handler
//       Access: Public
//  Description: Returns a pointer to the one global EventHandler
//               object.  If the global object has not yet been
//               created, this will create it.
//////////////////////////////////////////////////////////////////// 0 
185 14 Dtool__0BPRkjs 0 7 197 487 0 14 Dtool__0BPRkjs 0 0 
186 14 Dtool__0BPJzfw 0 7 200 527 409 14 Dtool__0BPJzfw 222 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
187 14 Dtool__0BPmDd1 0 4 202 477 0 14 Dtool__0BPmDd1 222 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::queue_event
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 527  5 event 1 522  
188 14 Dtool__0BPWhuh 0 4 203 477 0 14 Dtool__0BPWhuh 294 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::clear
//       Access: Published
//  Description: Empties all events on the queue, throwing them on the
//               floor.
//////////////////////////////////////////////////////////////////// 1 4 this 3 527  
189 14 Dtool__0BPXt8W 0 6 204 474 0 14 Dtool__0BPXt8W 225 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::is_queue_empty
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
190 14 Dtool__0BPAyXu 0 6 205 474 0 14 Dtool__0BPAyXu 306 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::is_queue_full
//       Access: Published
//  Description: This function is deprecated--the queue is never full
//               these days.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
191 14 Dtool__0BPCDK_ 0 7 206 522 0 14 Dtool__0BPCDK_ 224 ////////////////////////////////////////////////////////////////////
//     Function: EventQueue::dequeue_event
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 this 3 527  
192 14 Dtool__0BPsJeO 0 6 207 527 0 14 Dtool__0BPsJeO 874 // Filename: eventQueue.I
// Created by:  drose (05May00)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: EventQueue::get_global_event_queue
//       Access: Public
//  Description: Returns a pointer to the one global EventQueue
//               object.  If the global object has not yet been
//               created, this will create it.
//////////////////////////////////////////////////////////////////// 0 
193 14 Dtool__0BPyAZp 0 7 209 533 435 14 Dtool__0BPyAZp 719 // Filename: pointerEventList.I
// Created by: jyelon (20Sep2007)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University.  All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license.  You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
194 14 Dtool__0BPPPTJ 0 6 210 479 0 14 Dtool__0BPPPTJ 273 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_num_events
//       Access: Published
//  Description: Returns the number of events in the list.
//////////////////////////////////////////////////////////////////// 1 4 this 3 534  
195 14 Dtool__0BPNqp0 0 6 211 474 0 14 Dtool__0BPNqp0 271 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_in_window
//       Access: Published
//  Description: Get the in-window flag of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
196 14 Dtool__0BP4wQA 0 6 212 479 0 14 Dtool__0BP4wQA 264 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_xpos
//       Access: Published
//  Description: Get the x-coordinate of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
197 14 Dtool__0BP0ws4 0 6 213 479 0 14 Dtool__0BP0ws4 264 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_ypos
//       Access: Published
//  Description: Get the y-coordinate of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
198 14 Dtool__0BPOwwL 0 6 214 479 0 14 Dtool__0BPOwwL 262 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_dx
//       Access: Published
//  Description: Get the x-coordinate of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
199 14 Dtool__0BPq2wZ 0 6 215 479 0 14 Dtool__0BPq2wZ 262 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_dy
//       Access: Published
//  Description: Get the y-coordinate of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
200 14 Dtool__0BP4CeO 0 6 216 479 0 14 Dtool__0BP4CeO 271 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_sequence
//       Access: Published
//  Description: Get the sequence number of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
201 14 Dtool__0BPXLTX 0 6 217 478 0 14 Dtool__0BPXLTX 260 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_length
//       Access: Published
//  Description: Get the length of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
202 14 Dtool__0BPjM86 0 6 218 478 0 14 Dtool__0BPjM86 266 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_direction
//       Access: Published
//  Description: Get the direction of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
203 14 Dtool__0BPkQxW 0 6 219 478 0 14 Dtool__0BPkQxW 264 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_rotation
//       Access: Published
//  Description: Get the rotation of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
204 14 Dtool__0BPcc7z 0 6 220 478 0 14 Dtool__0BPcc7z 261 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::get_time
//       Access: Published
//  Description: Get the timestamp of the nth event.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  1 n 1 479  
205 14 Dtool__0BP8Mi0 0 4 221 477 0 14 Dtool__0BP8Mi0 257 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::clear
//       Access: Public
//  Description: Empties all the events from the list.
//////////////////////////////////////////////////////////////////// 1 4 this 3 533  
206 14 Dtool__0BPmL1C 0 4 222 477 0 14 Dtool__0BPmL1C 261 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::pop_front
//       Access: Public
//  Description: Discards the first event on the list.
//////////////////////////////////////////////////////////////////// 1 4 this 3 533  
207 14 Dtool__0BP2VWP 0 4 223 477 0 14 Dtool__0BP2VWP 399 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::add_event
//       Access: Published
//  Description: Adds a new event to the end of the list.
//               Automatically calculates the dx, dy, length,
//               direction, and rotation for all but the first event.
//////////////////////////////////////////////////////////////////// 6 4 this 3 533  6 in_win 1 474  4 xpos 1 479  4 ypos 1 479  3 seq 1 479  4 time 1 478  
208 14 Dtool__0BPXkxP 0 6 224 474 0 14 Dtool__0BPXkxP 303 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::encircles
//       Access: Published
//  Description: Returns true if the trail loops around the
//               specified point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 534  1 x 1 479  1 y 1 479  
209 14 Dtool__0BPQQSb 0 6 225 478 0 14 Dtool__0BPQQSb 555 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::total_turns
//       Access: Published
//  Description: returns the total angular deviation that the trail
//               has made in the specified time period.  A small
//               number means that the trail is moving in a relatively
//               straight line, a large number means that the trail
//               is zig-zagging or spinning.  The result is in degrees.
//////////////////////////////////////////////////////////////////// 2 4 this 3 534  3 sec 1 478  
210 14 Dtool__0BPeTOq 0 6 226 478 0 14 Dtool__0BPeTOq 912 ////////////////////////////////////////////////////////////////////
//     Function: PointerEventList::match_pattern
//       Access: Published
//  Description: This function is not implemented yet.  It is a work
//               in progress.  The intent is as follows:
//
//               Returns a nonzero value if the mouse movements 
//               match the specified pattern.  The higher the value,
//               the better the match.  The pattern is a sequence
//               of compass directions (ie, "E", "NE", etc) separated
//               by spaces.  If rot is nonzero, then the pattern is
//               rotated counterclockwise by the specified amount 
//               before testing.  Seglen is the minimum length a
//               mouse movement needs to be in order to be considered
//               significant.
//////////////////////////////////////////////////////////////////// 4 4 this 3 533  7 pattern 1 480  3 rot 1 478  6 seglen 1 478  
211 14 Dtool__0BPYGDf 0 7 227 487 0 14 Dtool__0BPYGDf 0 0 
212 14 Dtool__0BPsKUR 0 7 230 536 0 14 Dtool__0BPsKUR 222 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 8 function 1 482  4 name 1 480  
213 14 Dtool__0BPoqzc 0 7 230 536 0 14 Dtool__0BPoqzc 222 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 8 function 1 482  
214 14 Dtool__0BPoDCR 0 7 230 536 0 14 Dtool__0BPoDCR 222 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
215 14 Dtool__0BPazlc 0 4 231 477 0 14 Dtool__0BPazlc 0 2 4 this 3 536  4 size 1 505  
216 14 Dtool__0BPLRsm 0 4 234 477 0 14 Dtool__0BPLRsm 365 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_function
//       Access: Published
//  Description: Replaces the function that is called when the task
//               runs.  The parameter should be a Python callable
//               object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 536  8 function 1 482  
217 14 Dtool__0BPXEcR 0 6 235 482 0 14 Dtool__0BPXEcR 296 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_function
//       Access: Published
//  Description: Returns the function that is called when the task
//               runs.
//////////////////////////////////////////////////////////////////// 1 4 this 3 536  
218 14 Dtool__0BPiuj1 0 4 236 477 0 14 Dtool__0BPiuj1 408 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_args
//       Access: Published
//  Description: Replaces the argument list that is passed to the task
//               function.  The parameter should be a tuple or list of
//               arguments, or None to indicate the empty list.
//////////////////////////////////////////////////////////////////// 3 4 this 3 536  4 args 1 482  11 append_task 1 474  
219 14 Dtool__0BP7tFV 0 6 237 482 0 14 Dtool__0BP7tFV 299 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_args
//       Access: Published
//  Description: Returns the argument list that is passed to the task
//               function.
//////////////////////////////////////////////////////////////////// 1 4 this 3 536  
220 14 Dtool__0BPQ0_J 0 4 238 477 0 14 Dtool__0BPQ0_J 371 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_upon_death
//       Access: Published
//  Description: Replaces the function that is called when the task
//               finishes.  The parameter should be a Python callable
//               object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 536  10 upon_death 1 482  
221 14 Dtool__0BPmj9b 0 6 239 482 0 14 Dtool__0BPmj9b 302 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_upon_death
//       Access: Published
//  Description: Returns the function that is called when the task
//               finishes.
//////////////////////////////////////////////////////////////////// 1 4 this 3 536  
222 14 Dtool__0BPwpy5 0 4 240 477 0 14 Dtool__0BPwpy5 651 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::set_owner
//       Access: Published
//  Description: Specifies a Python object that serves as the "owner"
//               for the task.  This owner object must have two
//               methods: _addTask() and _clearTask(), which will be
//               called with one parameter, the task object.
//
//               owner._addTask() is called when the task is added
//               into the active task list, and owner._clearTask() is
//               called when it is removed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 536  5 owner 1 482  
223 14 Dtool__0BPbcIu 0 6 241 482 0 14 Dtool__0BPbcIu 266 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::get_owner
//       Access: Published
//  Description: Returns the "owner" object.  See set_owner().
//////////////////////////////////////////////////////////////////// 1 4 this 3 536  
224 14 Dtool__0BPjok_ 0 6 242 479 0 14 Dtool__0BPjok_ 525 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__setattr__
//       Access: Published
//  Description: Maps from an expression like "del task.attr_name".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               assigning certain values.  We also support adding
//               arbitrary data to the Task object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 536  9 attr_name 1 480  
225 14 Dtool__0BPNuNk 0 6 242 479 0 14 Dtool__0BPNuNk 525 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__setattr__
//       Access: Published
//  Description: Maps from an expression like "task.attr_name = v".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               assigning certain values.  We also support adding
//               arbitrary data to the Task object.
//////////////////////////////////////////////////////////////////// 3 4 this 3 536  9 attr_name 1 480  1 v 1 482  
226 14 Dtool__0BPRfw9 0 6 243 482 0 14 Dtool__0BPRfw9 520 ////////////////////////////////////////////////////////////////////
//     Function: PythonTask::__getattr__
//       Access: Published
//  Description: Maps from an expression like "task.attr_name".
//               This is customized here so we can support some
//               traditional task interfaces that supported directly
//               querying certain values.  We also support adding
//               arbitrary data to the Task object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 537  9 attr_name 1 480  
227 14 Dtool__0BP6LND 0 7 244 487 0 14 Dtool__0BP6LND 0 0 
90
451 9 AsyncTask 0 75777 9 AsyncTask 9 AsyncTask 0 0 0 0 0 0 33 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 0 0 1 0 452 0 0 0 2 453 454 434
////////////////////////////////////////////////////////////////////
//       Class : AsyncTask
// Description : This class represents a concrete task performed by an
//               AsyncManager.  Normally, you would subclass from this
//               class, and override do_task(), to define the
//               functionality you wish to have the task perform.
////////////////////////////////////////////////////////////////////

452 13 AsyncTaskBase 0 2049 13 AsyncTaskBase 13 AsyncTaskBase 0 0 0 0 0 0 0 0 0 0 0 0 346
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskBase
// Description : The abstract base class for AsyncTask.  This is
//               defined here only so we can store a pointer to the
//               current task on the Thread.
////////////////////////////////////////////////////////////////////

453 10 DoneStatus 0 794624 21 AsyncTask::DoneStatus 21 AsyncTask::DoneStatus 451 0 0 0 0 0 0 0 0 0 7 7 DS_done 18 AsyncTask::DS_done 0 7 DS_cont 18 AsyncTask::DS_cont 1 8 DS_again 19 AsyncTask::DS_again 2 9 DS_pickup 20 AsyncTask::DS_pickup 3 7 DS_exit 18 AsyncTask::DS_exit 4 8 DS_pause 19 AsyncTask::DS_pause 5 12 DS_interrupt 23 AsyncTask::DS_interrupt 6 0 0

454 5 State 0 794624 16 AsyncTask::State 16 AsyncTask::State 451 0 0 0 0 0 0 0 0 0 6 10 S_inactive 21 AsyncTask::S_inactive 0 8 S_active 19 AsyncTask::S_active 1 11 S_servicing 22 AsyncTask::S_servicing 2 19 S_servicing_removed 30 AsyncTask::S_servicing_removed 3 10 S_sleeping 21 AsyncTask::S_sleeping 4 15 S_active_nested 26 AsyncTask::S_active_nested 5 0 0

455 19 AsyncTaskCollection 0 26625 19 AsyncTaskCollection 19 AsyncTaskCollection 0 0 0 1 261 263 0 17 262 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 1 541 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskCollection
// Description : A list of tasks, for instance as returned by some of
//               the AsyncTaskManager query functions.  This also
//               serves to define an AsyncTaskSequence.
//
//               TODO: None of this is thread-safe yet.
////////////////////////////////////////////////////////////////////

456 14 AsyncTaskChain 0 26625 14 AsyncTaskChain 14 AsyncTaskChain 0 0 0 0 284 0 27 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 0 0 2 3 457 280 281 3 458 282 283 0 0 1464
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskChain
// Description : The AsyncTaskChain is a subset of the
//               AsyncTaskManager.  Each chain maintains a separate
//               list of tasks, and will execute them with its own set
//               of threads.  Each chain may thereby operate
//               independently of the other chains.
//
//               The AsyncTaskChain will spawn a specified number of
//               threads (possibly 0) to serve the tasks.  If there
//               are no threads, you must call poll() from time to
//               time to serve the tasks in the main thread.  Normally
//               this is done by calling AsyncTaskManager::poll().
//
//               Each task will run exactly once each epoch.  Beyond
//               that, the tasks' sort and priority values control the
//               order in which they are run: tasks are run in
//               increasing order by sort value, and within the same
//               sort value, they are run roughly in decreasing order
//               by priority value, with some exceptions for
//               parallelism.  Tasks with different sort values are
//               never run in parallel together, but tasks with
//               different priority values might be (if there is more
//               than one thread).
////////////////////////////////////////////////////////////////////

457 19 TypedReferenceCount 0 2049 19 TypedReferenceCount 19 TypedReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 710
////////////////////////////////////////////////////////////////////
//       Class : TypedReferenceCount
// Description : A base class for things which need to inherit from
//               both TypedObject and from ReferenceCount.  It's
//               convenient to define this intermediate base class
//               instead of multiply inheriting from the two classes
//               each time they are needed, so that we can sensibly
//               pass around pointers to things which are both
//               TypedObjects and ReferenceCounters.
//               
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

458 7 Namable 0 2049 7 Namable 7 Namable 0 0 0 0 0 0 0 0 0 0 0 0 324
////////////////////////////////////////////////////////////////////
//       Class : Namable
// Description : A base class for all things which can have a name.
//               The name is either empty or nonempty, but it is never
//               NULL.
////////////////////////////////////////////////////////////////////

459 16 AsyncTaskManager 0 26625 16 AsyncTaskManager 16 AsyncTaskManager 0 0 0 1 316 317 0 27 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 1 542 0 2 3 457 312 313 3 458 314 315 0 0 1046
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskManager
// Description : A class to manage a loose queue of isolated tasks,
//               which can be performed either synchronously (in the
//               foreground thread) or asynchronously (by a background
//               thread).
//
//               The AsyncTaskManager is actually a collection of
//               AsyncTaskChains, each of which maintains a list of
//               tasks.  Each chain can be either foreground or
//               background (it may run only in the main thread, or it
//               may be serviced by one or more background threads).
//               See AsyncTaskChain for more information.
//
//               If you do not require background processing, it is
//               perfectly acceptable to create only one
//               AsyncTaskChain, which runs in the main thread.  This
//               is a common configuration.
////////////////////////////////////////////////////////////////////

460 14 AsyncTaskPause 0 141313 14 AsyncTaskPause 14 AsyncTaskPause 0 0 0 1 345 350 0 4 346 347 348 349 0 0 1 0 451 0 0 0 0 405
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskPause
// Description : A special kind of task that simple returns DS_pause,
//               to pause for a specified number of seconds and then
//               finish.  It's intended to be used within an
//               AsyncTaskSequence.
////////////////////////////////////////////////////////////////////

461 17 AsyncTaskSequence 0 26625 17 AsyncTaskSequence 17 AsyncTaskSequence 0 0 0 1 355 356 0 7 357 358 359 360 361 362 363 0 0 2 3 451 351 352 3 455 353 354 0 0 683
////////////////////////////////////////////////////////////////////
//       Class : AsyncTaskSequence
// Description : A special kind of task that serves as a list of tasks
//               internally.  Each task on the list is executed in
//               sequence, one per epoch.
//
//               This is similar to a Sequence interval, though it has
//               some slightly different abilities.  For instance,
//               although you can't start at any arbitrary point in
//               the sequence, you can construct a task sequence whose
//               duration changes during playback.
////////////////////////////////////////////////////////////////////

462 14 EventParameter 0 26625 14 EventParameter 14 EventParameter 0 0 0 1 364 366 0 14 365 367 368 369 370 371 372 373 374 375 376 377 378 379 0 0 0 0 0 671
////////////////////////////////////////////////////////////////////
//       Class : EventParameter
// Description : An optional parameter associated with an event.  Each
//               event may have zero or more of these.  Each parameter
//               stores a pointer to a TypedWritableReferenceCount
//               object, which of course could be pretty much
//               anything.  To store a simple value like a double or a
//               string, the EventParameter constructors transparently
//               use the EventStoreValue template class, defined
//               below.
////////////////////////////////////////////////////////////////////

463 19 EventStoreValueBase 0 75777 19 EventStoreValueBase 19 EventStoreValueBase 0 0 0 0 0 0 2 380 381 0 0 1 0 464 0 0 0 0 358
////////////////////////////////////////////////////////////////////
//       Class : EventStoreValueBase
// Description : A non-template base class of EventStoreValue (below),
//               which serves mainly to define the placeholder for the
//               virtual output function.
////////////////////////////////////////////////////////////////////

464 27 TypedWritableReferenceCount 0 2049 27 TypedWritableReferenceCount 27 TypedWritableReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 722
////////////////////////////////////////////////////////////////////
//       Class : TypedWritableReferenceCount
// Description : A base class for things which need to inherit from
//               both TypedWritable and from ReferenceCount.  It's
//               convenient to define this intermediate base class
//               instead of multiply inheriting from the two classes
//               each time they are needed, so that we can sensibly
//               pass around pointers to things which are both
//               TypedWritables and ReferenceCounters.
//               
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

465 23 EventStoreTypedRefCount 0 75777 23 EventStoreTypedRefCount 23 EventStoreTypedRefCount 0 0 0 1 382 0 0 3 383 384 385 0 0 1 0 463 0 0 0 0 359
////////////////////////////////////////////////////////////////////
//       Class : EventStoreTypedRefCount
// Description : A class object for storing specifically objects of
//               type TypedReferenceCount, which is different than
//               TypedWritableReferenceCount.
////////////////////////////////////////////////////////////////////

466 5 Event 0 75777 5 Event 5 Event 0 0 0 1 386 0 0 14 387 388 389 390 391 392 393 394 395 396 397 398 399 400 1 543 0 1 0 457 0 0 0 0 645
////////////////////////////////////////////////////////////////////
//       Class : Event
// Description : A named event, possibly with parameters.  Anyone in
//               any thread may throw an event at any time; there will
//               be one process responsible for reading and dispacting
//               on the events (but not necessarily immediately).
//
//               This function use to inherit from Namable, but that
//               makes it too expensive to get its name the Python
//               code.  Now it just copies the Namable interface in.
////////////////////////////////////////////////////////////////////

467 12 EventHandler 0 141313 12 EventHandler 12 EventHandler 0 0 0 1 401 407 0 5 402 403 404 405 406 0 0 1 0 468 0 0 0 0 678
////////////////////////////////////////////////////////////////////
//       Class : EventHandler
// Description : A class to monitor events from the C++ side of
//               things.  It maintains a set of "hooks", function
//               pointers assigned to event names, and calls the
//               appropriate hooks when the matching event is
//               detected.
//
//               This class is not necessary when the hooks are
//               detected and processed entirely by the scripting
//               language, e.g. via Scheme hooks or the messenger
//               in Python.
////////////////////////////////////////////////////////////////////

468 11 TypedObject 0 2049 11 TypedObject 11 TypedObject 0 0 0 0 0 0 0 0 0 0 0 0 3666
////////////////////////////////////////////////////////////////////
//       Class : TypedObject
// Description : This is an abstract class that all classes which
//               use TypeHandle, and also provide virtual functions to
//               support polymorphism, should inherit from.  Each
//               derived class should define get_type(), which should
//               return the specific type of the derived class.
//               Inheriting from this automatically provides support
//               for is_of_type() and is_exact_type().
//               
//               All classes that inherit directly or indirectly from
//               TypedObject should redefine get_type() and
//               force_init_type(), as shown below.  Some classes that
//               do not inherit from TypedObject may still declare
//               TypeHandles for themselves by defining methods called
//               get_class_type() and init_type().  Classes such as
//               these may serve as base classes, but the dynamic type
//               identification system will be limited.  Classes that
//               do not inherit from TypedObject need not define the
//               virtual functions get_type() and force_init_type()
//               (or any other virtual functions).
//               
//               There is a specific layout for defining the
//               overrides from this class.  Keeping the definitions
//               formatted just like these examples will allow
//               someone in the future to use a sed (or similar)
//               script to make global changes, if necessary.  Avoid
//               rearranging the braces or the order of the functions
//               unless you're ready to change them in every file all
//               at once.
//               
//               What follows are some examples that can be used in
//               new classes that you create.
//               
//               @par In the class definition (.h file):
//               @code
//               public:
//                 static TypeHandle get_class_type() {
//                   return _type_handle;
//                 }
//                 static void init_type() {
//                   <<<BaseClassOne>>>::init_type();
//                   <<<BaseClassTwo>>>::init_type();
//                   <<<BaseClassN>>>::init_type();
//                   register_type(_type_handle, "<<<ThisClassStringName>>>",
//                                 <<<BaseClassOne>>>::get_class_type(),
//                                 <<<BaseClassTwo>>>::get_class_type(),
//                                 <<<BaseClassN>>>::get_class_type());
//                 }
//                 virtual TypeHandle get_type() const {
//                   return get_class_type();
//                 }
//                 virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
//               
//               private:
//                 static TypeHandle _type_handle;
//               @endcode
//               
//               @par In the class .cxx file:
//               @code
//               TypeHandle <<<ThisClassStringName>>>::_type_handle;
//               @endcode
//               
//               @par In the class config_<<<PackageName>>>.cxx file:
//               @code
//               ConfigureFn(config_<<<PackageName>>>) {
//                 <<<ClassOne>>>::init_type();
//                 <<<ClassTwo>>>::init_type();
//                 <<<ClassN>>>::init_type();
//               }
//               @endcode
////////////////////////////////////////////////////////////////////

469 10 EventQueue 0 26625 10 EventQueue 10 EventQueue 0 0 0 1 408 409 0 6 410 411 412 413 414 415 0 0 0 0 0 392
////////////////////////////////////////////////////////////////////
//       Class : EventQueue
// Description : A queue of pending events.  As events are thrown,
//               they are added to this queue; eventually, they will
//               be extracted out again by an EventHandler and
//               processed.
////////////////////////////////////////////////////////////////////

470 16 PointerEventList 0 141313 16 PointerEventList 16 PointerEventList 0 0 0 1 416 435 0 18 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 0 0 1 0 463 0 0 0 0 468
////////////////////////////////////////////////////////////////////
//       Class : PointerEventList
// Description : Records a set of pointer events that happened
//               recently.  This class is usually used only in the
//               data graph, to transmit the recent pointer presses,
//               but it may be used anywhere a list of PointerEvents
//               is desired.
////////////////////////////////////////////////////////////////////

471 10 PythonTask 0 75777 10 PythonTask 10 PythonTask 0 0 0 1 436 0 0 14 437 438 439 440 441 442 443 444 445 446 447 448 449 450 0 0 1 0 451 0 0 0 0 286
////////////////////////////////////////////////////////////////////
//       Class : PythonTask
// Description : This class exists to allow association of a Python
//               function with the AsyncTaskManager.
////////////////////////////////////////////////////////////////////

472 17 AsyncTask const * 0 8576 17 AsyncTask const * 17 AsyncTask const * 0 0 473 0 0 0 0 0 0 0 0 0 0

473 15 AsyncTask const 0 8832 15 AsyncTask const 15 AsyncTask const 0 0 451 0 0 0 0 0 0 0 0 0 0

474 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

475 18 AsyncTaskManager * 0 8576 18 AsyncTaskManager * 18 AsyncTaskManager * 0 0 459 0 0 0 0 0 0 0 0 0 0

476 11 AsyncTask * 0 8576 11 AsyncTask * 11 AsyncTask * 0 0 451 0 0 0 0 0 0 0 0 0 0

477 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

478 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0

479 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

480 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

481 8 long int 0 8210 8 long int 8 long int 0 1 0 0 0 0 0 0 0 0 0 0 0

482 10 PyObject * 0 8576 10 PyObject * 10 PyObject * 0 0 483 0 0 0 0 0 0 0 0 0 0

483 8 PyObject 0 2048 8 PyObject 8 PyObject 0 0 0 0 0 0 0 0 0 0 0 0 0

484 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 485 0 0 0 0 0 0 0 0 0 0

485 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

486 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

487 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 486 0 0 0 0 0 0 0 0 0 0

488 21 AsyncTaskCollection * 0 8576 21 AsyncTaskCollection * 21 AsyncTaskCollection * 0 0 455 0 0 0 0 0 0 0 0 0 0

489 27 AsyncTaskCollection const * 0 8576 27 AsyncTaskCollection const * 27 AsyncTaskCollection const * 0 0 490 0 0 0 0 0 0 0 0 0 0

490 25 AsyncTaskCollection const 0 8832 25 AsyncTaskCollection const 25 AsyncTaskCollection const 0 0 455 0 0 0 0 0 0 0 0 0 0

491 16 AsyncTaskChain * 0 8576 16 AsyncTaskChain * 16 AsyncTaskChain * 0 0 456 0 0 0 0 0 0 0 0 0 0

492 22 AsyncTaskChain const * 0 8576 22 AsyncTaskChain const * 22 AsyncTaskChain const * 0 0 493 0 0 0 0 0 0 0 0 0 0

493 20 AsyncTaskChain const 0 8832 20 AsyncTaskChain const 20 AsyncTaskChain const 0 0 456 0 0 0 0 0 0 0 0 0 0

494 14 ThreadPriority 0 532480 14 ThreadPriority 14 ThreadPriority 0 0 0 0 0 0 0 0 0 0 4 6 TP_low 6 TP_low 0 9 TP_normal 9 TP_normal 1 7 TP_high 7 TP_high 2 9 TP_urgent 9 TP_urgent 3 0 243
////////////////////////////////////////////////////////////////////
// An enumerated type used by Thread to specify a suggested relative
// priority for a particular thread.
////////////////////////////////////////////////////////////////////

495 21 TypedReferenceCount * 0 8576 21 TypedReferenceCount * 21 TypedReferenceCount * 0 0 457 0 0 0 0 0 0 0 0 0 0

496 9 Namable * 0 8576 9 Namable * 9 Namable * 0 0 458 0 0 0 0 0 0 0 0 0 0

497 13 ClockObject * 0 8576 13 ClockObject * 13 ClockObject * 0 0 498 0 0 0 0 0 0 0 0 0 0

498 11 ClockObject 0 2048 11 ClockObject 11 ClockObject 0 0 0 0 0 0 0 0 0 0 0 0 1457
////////////////////////////////////////////////////////////////////
//       Class : ClockObject
// Description : A ClockObject keeps track of elapsed real time and
//               discrete time.  In normal mode, get_frame_time()
//               returns the time as of the last time tick() was
//               called.  This is the "discrete" time, and is usually
//               used to get the time as of, for instance, the
//               beginning of the current frame.
//
//               In other modes, as set by set_mode() or the
//               clock-mode config variable, get_frame_time() may
//               return other values to simulate different timing
//               effects, for instance to perform non-real-time
//               animation.  See set_mode().
//
//               In all modes, get_real_time() always returns the
//               elapsed real time in seconds since the ClockObject
//               was constructed, or since it was last reset.
//
//               You can create your own ClockObject whenever you want
//               to have your own local timer.  There is also a
//               default, global ClockObject intended to represent
//               global time for the application; this is normally set
//               up to tick every frame so that its get_frame_time()
//               will return the time for the current frame.
////////////////////////////////////////////////////////////////////

499 24 AsyncTaskManager const * 0 8576 24 AsyncTaskManager const * 24 AsyncTaskManager const * 0 0 500 0 0 0 0 0 0 0 0 0 0

500 22 AsyncTaskManager const 0 8832 22 AsyncTaskManager const 22 AsyncTaskManager const 0 0 459 0 0 0 0 0 0 0 0 0 0

501 19 GlobPattern const * 0 8576 19 GlobPattern const * 19 GlobPattern const * 0 0 502 0 0 0 0 0 0 0 0 0 0

502 17 GlobPattern const 0 8832 17 GlobPattern const 17 GlobPattern const 0 0 503 0 0 0 0 0 0 0 0 0 0

503 11 GlobPattern 0 2048 11 GlobPattern 11 GlobPattern 0 0 0 0 0 0 0 0 0 0 0 0 859
////////////////////////////////////////////////////////////////////
//       Class : GlobPattern
// Description : This class can be used to test for string matches
//               against standard Unix-shell filename globbing
//               conventions.  It serves as a portable standin for the
//               Posix fnmatch() call.
//
//               A GlobPattern is given a pattern string, which can
//               contain operators like *, ?, and [].  Then it can be
//               tested against any number of candidate strings; for
//               each candidate, it will indicate whether the string
//               matches the pattern or not.  It can be used, for
//               example, to scan a directory for all files matching a
//               particular pattern.
////////////////////////////////////////////////////////////////////

504 16 AsyncTaskPause * 0 8576 16 AsyncTaskPause * 16 AsyncTaskPause * 0 0 460 0 0 0 0 0 0 0 0 0 0

505 12 unsigned int 0 8198 12 unsigned int 12 unsigned int 0 1 0 0 0 0 0 0 0 0 0 0 0

506 19 AsyncTaskSequence * 0 8576 19 AsyncTaskSequence * 19 AsyncTaskSequence * 0 0 461 0 0 0 0 0 0 0 0 0 0

507 25 AsyncTaskSequence const * 0 8576 25 AsyncTaskSequence const * 25 AsyncTaskSequence const * 0 0 508 0 0 0 0 0 0 0 0 0 0

508 23 AsyncTaskSequence const 0 8832 23 AsyncTaskSequence const 23 AsyncTaskSequence const 0 0 461 0 0 0 0 0 0 0 0 0 0

509 16 EventParameter * 0 8576 16 EventParameter * 16 EventParameter * 0 0 462 0 0 0 0 0 0 0 0 0 0

510 22 EventParameter const * 0 8576 22 EventParameter const * 22 EventParameter const * 0 0 511 0 0 0 0 0 0 0 0 0 0

511 20 EventParameter const 0 8832 20 EventParameter const 20 EventParameter const 0 0 462 0 0 0 0 0 0 0 0 0 0

512 27 TypedReferenceCount const * 0 8576 27 TypedReferenceCount const * 27 TypedReferenceCount const * 0 0 513 0 0 0 0 0 0 0 0 0 0

513 25 TypedReferenceCount const 0 8832 25 TypedReferenceCount const 25 TypedReferenceCount const 0 0 457 0 0 0 0 0 0 0 0 0 0

514 35 TypedWritableReferenceCount const * 0 8576 35 TypedWritableReferenceCount const * 35 TypedWritableReferenceCount const * 0 0 515 0 0 0 0 0 0 0 0 0 0

515 33 TypedWritableReferenceCount const 0 8832 33 TypedWritableReferenceCount const 33 TypedWritableReferenceCount const 0 0 464 0 0 0 0 0 0 0 0 0 0

516 29 TypedWritableReferenceCount * 0 8576 29 TypedWritableReferenceCount * 29 TypedWritableReferenceCount * 0 0 464 0 0 0 0 0 0 0 0 0 0

517 27 EventStoreValueBase const * 0 8576 27 EventStoreValueBase const * 27 EventStoreValueBase const * 0 0 518 0 0 0 0 0 0 0 0 0 0

518 25 EventStoreValueBase const 0 8832 25 EventStoreValueBase const 25 EventStoreValueBase const 0 0 463 0 0 0 0 0 0 0 0 0 0

519 25 EventStoreTypedRefCount * 0 8576 25 EventStoreTypedRefCount * 25 EventStoreTypedRefCount * 0 0 465 0 0 0 0 0 0 0 0 0 0

520 31 EventStoreTypedRefCount const * 0 8576 31 EventStoreTypedRefCount const * 31 EventStoreTypedRefCount const * 0 0 521 0 0 0 0 0 0 0 0 0 0

521 29 EventStoreTypedRefCount const 0 8832 29 EventStoreTypedRefCount const 29 EventStoreTypedRefCount const 0 0 465 0 0 0 0 0 0 0 0 0 0

522 13 Event const * 0 8576 13 Event const * 13 Event const * 0 0 523 0 0 0 0 0 0 0 0 0 0

523 11 Event const 0 8832 11 Event const 11 Event const 0 0 466 0 0 0 0 0 0 0 0 0 0

524 7 Event * 0 8576 7 Event * 7 Event * 0 0 466 0 0 0 0 0 0 0 0 0 0

525 15 EventReceiver * 0 8576 15 EventReceiver * 15 EventReceiver * 0 0 526 0 0 0 0 0 0 0 0 0 0

526 13 EventReceiver 0 2048 13 EventReceiver 13 EventReceiver 0 0 0 0 0 0 0 0 0 0 0 0 0

527 12 EventQueue * 0 8576 12 EventQueue * 12 EventQueue * 0 0 469 0 0 0 0 0 0 0 0 0 0

528 14 EventHandler * 0 8576 14 EventHandler * 14 EventHandler * 0 0 467 0 0 0 0 0 0 0 0 0 0

529 20 EventHandler const * 0 8576 20 EventHandler const * 20 EventHandler const * 0 0 530 0 0 0 0 0 0 0 0 0 0

530 18 EventHandler const 0 8832 18 EventHandler const 18 EventHandler const 0 0 467 0 0 0 0 0 0 0 0 0 0

531 18 EventQueue const * 0 8576 18 EventQueue const * 18 EventQueue const * 0 0 532 0 0 0 0 0 0 0 0 0 0

532 16 EventQueue const 0 8832 16 EventQueue const 16 EventQueue const 0 0 469 0 0 0 0 0 0 0 0 0 0

533 18 PointerEventList * 0 8576 18 PointerEventList * 18 PointerEventList * 0 0 470 0 0 0 0 0 0 0 0 0 0

534 24 PointerEventList const * 0 8576 24 PointerEventList const * 24 PointerEventList const * 0 0 535 0 0 0 0 0 0 0 0 0 0

535 22 PointerEventList const 0 8832 22 PointerEventList const 22 PointerEventList const 0 0 470 0 0 0 0 0 0 0 0 0 0

536 12 PythonTask * 0 8576 12 PythonTask * 12 PythonTask * 0 0 471 0 0 0 0 0 0 0 0 0 0

537 18 PythonTask const * 0 8576 18 PythonTask const * 18 PythonTask const * 0 0 538 0 0 0 0 0 0 0 0 0 0

538 16 PythonTask const 0 8832 16 PythonTask const 16 PythonTask const 0 0 471 0 0 0 0 0 0 0 0 0 0

539 6 string 0 2048 20 basic_string< char > 20 basic_string< char > 0 0 0 0 0 0 0 0 0 0 0 0 0

540 7 wstring 0 2048 23 basic_string< wchar_t > 23 basic_string< wchar_t > 0 0 0 0 0 0 0 0 0 0 0 0 0

0
0
3
541 0 0 38 9 get_tasks 13 get_num_tasks 8 get_task 
542 0 0 93 15 get_task_chains 19 get_num_task_chains 14 get_task_chain 
543 0 0 174 14 get_parameters 18 get_num_parameters 13 get_parameter 
