haiku/headers/private/media/MediaRosterEx.h

/*
 * Copyright (c) 2003 Marcus Overhagen.
 * All Rights Reserved.
 *
 * This file may be used under the terms of the MIT License.
 */
#ifndef _MEDIA_ROSTER_EX_H_
#define _MEDIA_ROSTER_EX_H_


#ifndef _MEDIA_T_LIST_H
	#include "TList.h"
#endif
#ifndef _DATA_EXCHANGE_H
	#include "DataExchange.h"
#endif
#ifndef _MEDIA_NODE_H
	#include <MediaNode.h>
#endif
#ifndef _MEDIA_ADD_ON_H
	#include <MediaAddOn.h>
#endif


namespace BPrivate { namespace media {


/* The BMediaRosterEx class is an extension to the BMediaRoster.
 * It provides functionality that can be used by the implementation
 * of media_server, media_addon_server and libmedia.so.
 * To access it, convert any BMediaRoster pointer in a BMediaRosterEx
 * pointer using the inline function provided below.
 */
class BMediaRosterEx : public BMediaRoster
{
public:
							BMediaRosterEx(status_t* out_error);
		virtual				~BMediaRosterEx();

		virtual void		Quit();

		status_t			SaveNodeConfiguration(BMediaNode* node);
		status_t 			LoadNodeConfiguration(media_addon_id addonid,
							int32 flavorid, BMessage* out_msg);

		status_t			IncrementAddonFlavorInstancesCount(
							media_addon_id addonid, int32 flavorid);

		status_t			DecrementAddonFlavorInstancesCount(
							media_addon_id addonid, int32 flavorid);

		status_t			ReleaseNodeAll(const media_node& node);

		status_t			SetNodeCreator(media_node_id node, team_id creator);

		status_t			RegisterNode(BMediaNode* node, media_addon_id addonid,
								int32 flavorid);

		status_t			InstantiateDormantNode(media_addon_id addonid,
								int32 flavorid, team_id creator, media_node* out_node);

		status_t			GetDormantFlavorInfo(media_addon_id addonid,
								int32 flavorid, dormant_flavor_info* out_flavor);

		status_t			GetNode(node_type type, media_node* out_node,
								int32* out_input_id = NULL,
								BString* out_input_name = NULL);

		status_t			SetNode(node_type type, const media_node* node,
								const dormant_node_info* info = NULL,
								const media_input *input = NULL);

		status_t			GetAllOutputs(const media_node& node,
								List<media_output>* list);

		status_t			GetAllOutputs(BBufferProducer* node,
								List<media_output>* list);

		status_t			GetAllInputs(const media_node& node,
								List<media_input>* list);

		status_t			GetAllInputs(BBufferConsumer* node,
								List<media_input>* list);

		status_t			PublishOutputs(const media_node& node,
								List<media_output>* list);

		status_t			PublishInputs(const media_node& node,
								List<media_input>* list);

		BTimeSource*		MakeTimeSourceObject(media_node_id timesource_id);

		status_t			BuildConnections();

		void				RegisterLocalNode(BMediaNode* node);
		void				UnregisterLocalNode(BMediaNode* node);

		void				EnableLaunchNotification(bool enable,
								bool autoExit);

private:
		bool				fLaunchNotification;
		bool				fAutoExit;

	friend class BMediaRoster;
};

/* The pointer returned by BMediaRoster::Roster() is always a
 * BMediaRosterEx object pointer. Use this to convert it.
 */
inline BMediaRosterEx* MediaRosterEx(BMediaRoster* mediaroster)
{
	return static_cast<BMediaRosterEx*>(mediaroster);
}


} } // BPrivate::media
using namespace BPrivate::media;

#endif