Initializes a new, empty, timed event queue.

Flushes the queue and deallocates memory allocated by the object.

Adds the specified event to the queue.

RETURN CODES

For each event in the queue matching the specified parameters, the hook function is called. The context pointer is passed through to the hook function, and may point to anything your hook function requires.

This provides a means for you to scan through the queue and perform a particular act on every node (or all nodes of a certain type, or that occur at certain times). If you want to process all events, you can specify a time of B_INFINITE_TIMEOUT and a direction of B_BEFORE_TIME.

The hook function should return a queue_action value.

queue_action MyHook(media_timed_event* event, void* context) {
   if (event->data == 0) {
      /* countdown finished, do something */
      return BTimedEventQueue::B_REMOVE_EVENT;
   }
   event->data--;
   return BTimedEventQueue::B_NO_ACTION;
}

In this example, the hook function processes the event (and indicates on return that it should be removed from the queue) if the data field of the event structure is zero; otherwise data is decremented and the event is left alone.

RETURN CODES

Returns the number of events in the queue.

Searches the event queue for the first event matching the given specifications. The search begins at the time specified by eventTime, and progresses in the specified direction.

If you want to scan all events, you can specify a time of B_INFINITE_TIMEOUT and a direction of B_BEFORE_TIME.

If no matching event is found, NULL is returned.

FirstEvent() returns the first event in the queue, without removing it from the queue.

FirstEventTime() returns the first event's time, in microseconds.

RETURN CODES

Flushes the specified events from the queue. You specify which events to flush by indicating a time from which events should be flushed, a direction in which to search for events to flush, and the type of events to flush:

If you want to flush all events, you can specify a time of B_INFINITE_TIMEOUT and a direction of B_BEFORE_TIME.

RETURN CODES

Returns true if there are events in the queue, otherwise returns false.

LastEvent() returns the last event in the queue, without removing it from the queue.

LastEventTime() returns the last event's time, in microseconds.

RETURN CODES

RemoveEvent() removes the specified event from the queue.

RemoveFirstEvent() removes the first event from the queue. If outEvent isn't NULL, the specified buffer is filled with a copy of the event that's been removed.

RETURN CODES

Sets up the cleanup hook function specified by hook to be called for events as they're removed from the queue. The hook will be called only for events with cleanup_flag values of B_DELETE or B_USER_CLEANUP or greater.

Declared in: be/media/TimedEventQueue.h

These values define how BTimedEventQueue should handle removing events from the queue. If the flag is B_USER_CLEANUP or greater, the cleanup hook function is called when the event is removed.

Declared in: be/media/TimedEventQueue.h

These values describe type types of events that a BTimedEventQueue can handle.

Declared in: be/media/TimedEventQueue.h

These queue action values are returned by the hook function used by DoForEach(); these values indicate what DoForEach() should do to the event after the hook has processed it.

Declared in: be/media/TimedEventQueue.h

These values are used to indicate a search direction through the time continuum.

Declared in: be/media/TimedEventQueue.h

typedef queue_action (*cleanup_hook)(media_timed_event* event,
                                     void* context);

The cleanup_hook type is used to define a hook function called while removing an event from the queue; it's set by calling SetCleanupHook().

Declared in: be/media/TimedEventQueue.h

typedef queue_action (*for_each_hook)(media_timed_event* event,
                                      void* context);

The for_each_hook type is used to define a hook function called by DoForEach().

Declared in: be/media/TimedEventQueue.h

struct media_timed_event {
   media_timed_event();
   media_timed_event(bigtime_t inTime, int32 inType);
   media_timed_event(bigtime_t inTime, int32 inType, void* inPointer,
            uint32 inCleanup);
   media_timed_event(bigtime_t inTime, int32 inType,
            void* inPointer, uint32 inCleanup,
            int32 inData, int64 inBigdata,
            char* inUserData, size_t dataSize = 0);

   media_timed_event(const media_timed_event& clone);
   void operator=(const media_timed_event& clone);

   ~media_timed_event();

   bigtime_t event_time;
   int32 type;
   void* pointer;
   uint32 cleanup;
   int32 data;
   int64 bigdata;
   char user_data[64];
   uint32 _reserved_media_timed_event_[8];
};

Describes a media event: