haiku.git

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// InfoWindowManager.cpp

#include "InfoWindowManager.h"
// InfoWindow
#include "AppNodeInfoView.h"
#include "ConnectionInfoView.h"
#include "DormantNodeInfoView.h"
#include "EndPointInfoView.h"
#include "FileNodeInfoView.h"
#include "LiveNodeInfoView.h"
#include "InfoWindow.h"
// NodeManager
#include "AddOnHostProtocol.h"
#include "Connection.h"
#include "NodeRef.h"

// Application Kit
#include <Application.h>
#include <AppDefs.h>
#include <Roster.h>
// Media Kit
#include <MediaAddOn.h>
#include <MediaRoster.h>
// Support Kit
#include <List.h>

__USE_CORTEX_NAMESPACE

#include <Debug.h>
#define D_ACCESS(x) //PRINT (x)
#define D_ALLOC(x) //PRINT (x)
#define D_INTERNAL(x) //PRINT (x)
#define D_MESSAGE(x) //PRINT (x)
#define D_WINDOW(x) //PRINT (x)

// -------------------------------------------------------- //
// internal types
// -------------------------------------------------------- //

// used to remember window for live nodes
struct live_node_window {

public:						// *** ctor/dtor

							live_node_window(
								const NodeRef *ref,
								BWindow *window)
								: ref(ref),
								  window(window)
							{ }

public:						// *** data members

	const NodeRef		   *ref;

	BWindow				   *window;
};

// used to remember windows for dormant nodes
struct dormant_node_window {

public:						// *** ctor/dtor

							dormant_node_window(
								const dormant_node_info &info,
								BWindow *window)
								: info(info),
								  window(window)
							{ }

public:						// *** data members

	const dormant_node_info	info;

	BWindow				   *window;
};

// used to remember windows for connections
struct connection_window {

public:						// *** ctor/dtor

							connection_window(
								const media_source &source,
								const media_destination &destination,
								BWindow *window)
								: source(source),
								  destination(destination),
								  window(window)
							{ }

public:						// *** data members

	media_source			source;

	media_destination		destination;

	BWindow				   *window;
};

// used to remember windows for media_inputs
struct input_window {

public:						// *** ctor/dtor

							input_window(
								const media_destination &destination,
								BWindow *window)
								: destination(destination),
								  window(window)
							{ }

public:						// *** data members

	media_destination		destination;

	BWindow				   *window;
};

// used to remember windows for media_outputs
struct output_window {

public:						// *** ctor/dtor

							output_window(
								const media_source &source,
								BWindow *window)
								: source(source),
								  window(window)
							{ }

public:						// *** data members

	media_source			source;

	BWindow				   *window;
};

// -------------------------------------------------------- //
// static member init
// -------------------------------------------------------- //

const BPoint InfoWindowManager::M_DEFAULT_OFFSET	= BPoint(20.0, 20.0);
const BPoint InfoWindowManager::M_INIT_POSITION	= BPoint(90.0, 90.0);

InfoWindowManager *InfoWindowManager::s_instance = 0;

// -------------------------------------------------------- //
// *** ctor/dtor
// -------------------------------------------------------- //

/* hidden */
InfoWindowManager::InfoWindowManager()
	: BLooper("InfoWindowManager",
			  B_NORMAL_PRIORITY),
	  m_liveNodeWindows(0),
	  m_dormantNodeWindows(0),
	  m_connectionWindows(0),
	  m_inputWindows(0),
	  m_outputWindows(0),
	  m_nextWindowPosition(M_INIT_POSITION) {
	D_ALLOC(("InfoWindowManager::InfoWindowManager()\n"));

	Run();

	BMediaRoster *roster = BMediaRoster::CurrentRoster();
	if (roster) {
		roster->StartWatching(BMessenger(0, this),
							  B_MEDIA_CONNECTION_BROKEN);
	}
}

InfoWindowManager::~InfoWindowManager() {
	D_ALLOC(("InfoWindowManager::~InfoWindowManager()\n"));

	BMediaRoster *roster = BMediaRoster::CurrentRoster();
	if (roster) {
		roster->StopWatching(BMessenger(0, this),
							  B_MEDIA_CONNECTION_BROKEN);
	}

	if (m_liveNodeWindows) {
		while (m_liveNodeWindows->CountItems() > 0) {
			live_node_window *entry = static_cast<live_node_window *>
									  (m_liveNodeWindows->ItemAt(0));
			if (entry && entry->window) {
				remove_observer(this, entry->ref);
				BMessenger messenger(0, entry->window);
				messenger.SendMessage(B_QUIT_REQUESTED);
			}
			m_liveNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}	
		delete m_liveNodeWindows;
		m_liveNodeWindows = 0;
	}

	if (m_dormantNodeWindows) {
		while (m_dormantNodeWindows->CountItems() > 0) {
			dormant_node_window *entry = static_cast<dormant_node_window *>
										 (m_dormantNodeWindows->ItemAt(0));
			if (entry && entry->window) {
				BMessenger messenger(0, entry->window);
				messenger.SendMessage(B_QUIT_REQUESTED);
			}
			m_dormantNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}	
		delete m_dormantNodeWindows;
		m_dormantNodeWindows = 0;
	}

	if (m_connectionWindows) {
		while (m_connectionWindows->CountItems() > 0) {
			connection_window *entry = static_cast<connection_window *>
									   (m_connectionWindows->ItemAt(0));
			if (entry && entry->window) {
				BMessenger messenger(0, entry->window);
				messenger.SendMessage(B_QUIT_REQUESTED);
			}
			m_connectionWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}	
		delete m_connectionWindows;
		m_connectionWindows = 0;
	}

	if (m_inputWindows) {
		while (m_inputWindows->CountItems() > 0) {
			input_window *entry = static_cast<input_window *>
								  (m_inputWindows->ItemAt(0));
			if (entry && entry->window) {
				BMessenger messenger(0, entry->window);
				messenger.SendMessage(B_QUIT_REQUESTED);
			}
			m_inputWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}	
		delete m_inputWindows;
		m_inputWindows = 0;
	}

	if (m_outputWindows) {
		while (m_outputWindows->CountItems() > 0) {
			output_window *entry = static_cast<output_window *>
								   (m_outputWindows->ItemAt(0));
			if (entry && entry->window) {
				BMessenger messenger(0, entry->window);
				messenger.SendMessage(B_QUIT_REQUESTED);
			}
			m_outputWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}	
		delete m_outputWindows;
		m_outputWindows = 0;
	}
}

// -------------------------------------------------------- //
// *** singleton access
// -------------------------------------------------------- //

/*static*/
InfoWindowManager *InfoWindowManager::Instance() {
	D_ACCESS(("InfoWindowManager::Instance()\n"));

	if (!s_instance) {
		D_ACCESS((" -> create instance\n"));
		s_instance = new InfoWindowManager();
	}		

	return s_instance;
}

/* static */
void InfoWindowManager::shutDown() {
	D_WINDOW(("InfoWindowManager::shutDown()\n"));

	if (s_instance) {
		s_instance->Lock();
		s_instance->Quit();
		s_instance = 0;
	}
}

// -------------------------------------------------------- //
// *** operations
// -------------------------------------------------------- //

status_t InfoWindowManager::openWindowFor(
	const NodeRef *ref) {
	D_WINDOW(("InfoWindowManager::openWindowFor(live_node)\n"));

	// make absolutely sure we're locked
	if (!IsLocked()) {
		debugger("The looper must be locked !");
	}

	// make sure the ref is valid
	if (!ref) {
		return B_ERROR;
	}

	BWindow *window = 0;
	if (_findWindowFor(ref->id(), &window)) {
		// window for this node already exists, activate it
		window->SetWorkspaces(B_CURRENT_WORKSPACE);
		window->Activate();
		return B_OK;
	}

	BRect frame = InfoView::M_DEFAULT_FRAME;
	frame.OffsetTo(m_nextWindowPosition);
	m_nextWindowPosition += M_DEFAULT_OFFSET;
	window = new InfoWindow(frame);

	if (_addWindowFor(ref, window)) {
		// find the correct InfoView sub-class
		BMediaRoster *roster = BMediaRoster::CurrentRoster();
		dormant_node_info dormantNodeInfo;
		if (ref->kind() & B_FILE_INTERFACE)
		{
			window->AddChild(new FileNodeInfoView(ref));
		}
		else if (roster->GetDormantNodeFor(ref->node(), &dormantNodeInfo) != B_OK) {
			port_info portInfo;
			app_info appInfo;
			if ((get_port_info(ref->node().port, &portInfo) == B_OK)
			 && (be_roster->GetRunningAppInfo(portInfo.team, &appInfo) == B_OK)) {
				app_info thisAppInfo;
				if ((be_app->GetAppInfo(&thisAppInfo) != B_OK)
				 || ((strcmp(appInfo.signature, thisAppInfo.signature) != 0)
				 && (strcmp(appInfo.signature, addon_host::g_appSignature) != 0))) {
					window->AddChild(new AppNodeInfoView(ref));
				}
				else {
					window->AddChild(new LiveNodeInfoView(ref));
				}
			}
			else {
				window->AddChild(new LiveNodeInfoView(ref));
			}
		}
		else {
			window->AddChild(new LiveNodeInfoView(ref));
		}
		// display the window
		window->Show();
		return B_OK;
	}

	// failed
	delete window;
	return B_ERROR;
}

status_t InfoWindowManager::openWindowFor(
	const dormant_node_info &info) {
	D_WINDOW(("InfoWindowManager::openWindowFor(dormant_node)\n"));

	// make absolutely sure we're locked
	if (!IsLocked()) {
		debugger("The looper must be locked !");
	}

	BWindow *window = 0;
	if (_findWindowFor(info, &window)) {
		// window for this node already exists, activate it
		window->SetWorkspaces(B_CURRENT_WORKSPACE);
		window->Activate();
		return B_OK;
	}

	BRect frame = InfoView::M_DEFAULT_FRAME;
	frame.OffsetTo(m_nextWindowPosition);
	m_nextWindowPosition += M_DEFAULT_OFFSET;
	window = new InfoWindow(frame);

	if (_addWindowFor(info, window)) {
		window->AddChild(new DormantNodeInfoView(info));
		window->Show();
		return B_OK;
	}

	// failed
	delete window;
	return B_ERROR;
}

status_t InfoWindowManager::openWindowFor(
	const Connection &connection) {
	D_WINDOW(("InfoWindowManager::openWindowFor(connection)\n"));

	// make absolutely sure we're locked
	if (!IsLocked()) {
		debugger("The looper must be locked !");
	}

	BWindow *window = 0;
	if (_findWindowFor(connection.source(), connection.destination(), &window)) {
		// window for this node already exists, activate it
		window->SetWorkspaces(B_CURRENT_WORKSPACE);
		window->Activate();
		return B_OK;
	}

	BRect frame = InfoView::M_DEFAULT_FRAME;
	frame.OffsetTo(m_nextWindowPosition);
	m_nextWindowPosition += M_DEFAULT_OFFSET;
	window = new InfoWindow(frame);

	if (_addWindowFor(connection, window)) {
		window->AddChild(new ConnectionInfoView(connection));
		window->Show();
		return B_OK;
	}

	// failed
	delete window;
	return B_ERROR;
}

status_t InfoWindowManager::openWindowFor(
	const media_input &input) {
	D_WINDOW(("InfoWindowManager::openWindowFor(input)\n"));

	// make absolutely sure we're locked
	if (!IsLocked()) {
		debugger("The looper must be locked !");
	}

	BWindow *window = 0;
	if (_findWindowFor(input.destination, &window)) {
		// window for this node already exists, activate it
		window->SetWorkspaces(B_CURRENT_WORKSPACE);
		window->Activate();
		return B_OK;
	}

	BRect frame = InfoView::M_DEFAULT_FRAME;
	frame.OffsetTo(m_nextWindowPosition);
	m_nextWindowPosition += M_DEFAULT_OFFSET;
	window = new InfoWindow(frame);

	if (_addWindowFor(input, window)) {
		window->AddChild(new EndPointInfoView(input));
		window->Show();
		return B_OK;
	}

	// failed
	delete window;
	return B_ERROR;
}

status_t InfoWindowManager::openWindowFor(
	const media_output &output) {
	D_WINDOW(("InfoWindowManager::openWindowFor(output)\n"));

	// make absolutely sure we're locked
	if (!IsLocked()) {
		debugger("The looper must be locked !");
	}

	BWindow *window = 0;
	if (_findWindowFor(output.source, &window)) {
		// window for this node already exists, activate it
		window->SetWorkspaces(B_CURRENT_WORKSPACE);
		window->Activate();
		return B_OK;
	}

	BRect frame = InfoView::M_DEFAULT_FRAME;
	frame.OffsetTo(m_nextWindowPosition);
	m_nextWindowPosition += M_DEFAULT_OFFSET;
	window = new BWindow(frame, "", B_DOCUMENT_WINDOW, 0);

	if (_addWindowFor(output, window)) {
		window->AddChild(new EndPointInfoView(output));
		window->Show();
		return B_OK;
	}

	// failed
	delete window;
	return B_ERROR;
}

// -------------------------------------------------------- //
// *** BLooper impl
// -------------------------------------------------------- //

void InfoWindowManager::MessageReceived(
	BMessage *message) {
	D_MESSAGE(("InfoWindowManager::MessageReceived()\n"));

	switch (message->what) {
		case M_LIVE_NODE_WINDOW_CLOSED: {
			D_MESSAGE((" -> M_LIVE_NODE_WINDOW_CLOSED\n"));
			int32 nodeID;
			if (message->FindInt32("nodeID", &nodeID) != B_OK) {
				return;
			}
			_removeWindowFor(nodeID);
			break;
		}
		case M_DORMANT_NODE_WINDOW_CLOSED: {
			D_MESSAGE((" -> M_DORMANT_NODE_WINDOW_CLOSED\n"));
			dormant_node_info info;
			if (message->FindInt32("addOnID", &info.addon) != B_OK) {
				return;
			}
			if (message->FindInt32("flavorID", &info.flavor_id) != B_OK) {
				return;
			}
			_removeWindowFor(info);
			break;
		}
		case M_CONNECTION_WINDOW_CLOSED: {
			D_MESSAGE((" -> M_CONNECTION_WINDOW_CLOSED\n"));
			media_source source;
			if (message->FindInt32("source_port", &source.port) != B_OK) {
				return;
			}
			if (message->FindInt32("source_id", &source.id) != B_OK) {
				return;
			}
			media_destination destination;
			if (message->FindInt32("destination_port", &destination.port) != B_OK) {
				return;
			}
			if (message->FindInt32("destination_id", &destination.id) != B_OK) {
				return;
			}
			_removeWindowFor(source, destination);
			break;
		}
		case M_INPUT_WINDOW_CLOSED: {
			D_MESSAGE((" -> M_INPUT_WINDOW_CLOSED\n"));
			media_destination destination;
			if (message->FindInt32("destination_port", &destination.port) != B_OK) {
				return;
			}
			if (message->FindInt32("destination_id", &destination.id) != B_OK) {
				return;
			}
			_removeWindowFor(destination);
			break;
		}
		case M_OUTPUT_WINDOW_CLOSED: {
			D_MESSAGE((" -> M_OUTPUT_WINDOW_CLOSED\n"));
			media_source source;
			if (message->FindInt32("source_port", &source.port) != B_OK) {
				return;
			}
			if (message->FindInt32("source_id", &source.id) != B_OK) {
				return;
			}
			_removeWindowFor(source);
			break;
		}
		case NodeRef::M_RELEASED: {
			D_MESSAGE((" -> NodeRef::M_RELEASED\n"));
			int32 nodeID;
			if (message->FindInt32("nodeID", &nodeID) != B_OK) {
				return;
			}
			BWindow *window;
			if (_findWindowFor(nodeID, &window)) {
				window->Lock();
				window->Quit();
				_removeWindowFor(nodeID);
			}
			break;
		}
		case B_MEDIA_CONNECTION_BROKEN: {
			D_MESSAGE((" -> B_MEDIA_CONNECTION_BROKEN\n"));
			const void *data;
			ssize_t dataSize;
			if (message->FindData("source", B_RAW_TYPE, &data, &dataSize) != B_OK) {
				return;
			}
			const media_source source = *reinterpret_cast<const media_source *>(data);
			if (message->FindData("destination", B_RAW_TYPE, &data, &dataSize) != B_OK) {
				return;
			}
			const media_destination destination = *reinterpret_cast<const media_destination *>(data);
			BWindow *window;
			if (_findWindowFor(source, destination, &window)) {
				window->Lock();
				window->Quit();
				_removeWindowFor(source, destination);
			}
			break;
		}
		default: {
			BLooper::MessageReceived(message);
		}
	}
}

// -------------------------------------------------------- //
// *** internal operations
// -------------------------------------------------------- //

bool InfoWindowManager::_addWindowFor(
	const NodeRef *ref,
	BWindow *window) {
	D_INTERNAL(("InfoWindowManager::_addWindowFor(live_node)\n"));

	if (!m_liveNodeWindows) {
		m_liveNodeWindows = new BList();
	}

	live_node_window *entry = new live_node_window(ref, window);
	if (m_liveNodeWindows->AddItem(reinterpret_cast<void *>(entry))) {
		add_observer(this, entry->ref);
		return true;
	}

	return false;
}

bool InfoWindowManager::_findWindowFor(
	int32 nodeID,
	BWindow **outWindow) {
	D_INTERNAL(("InfoWindowManager::_findWindowFor(live_node)\n"));

	if (!m_liveNodeWindows) {
		return false;
	}

	for (int32 i = 0; i < m_liveNodeWindows->CountItems(); i++) {
		live_node_window *entry = static_cast<live_node_window *>
								  (m_liveNodeWindows->ItemAt(i));
		if (entry->ref->id() == nodeID) {
			*outWindow = entry->window;
			return true;
		}
	}

	return false;
}

void InfoWindowManager::_removeWindowFor(
	int32 nodeID) {
	D_INTERNAL(("InfoWindowManager::_removeWindowFor(live_node)\n"));

	if (!m_liveNodeWindows) {
		return;
	}

	for (int32 i = 0; i < m_liveNodeWindows->CountItems(); i++) {
		live_node_window *entry = static_cast<live_node_window *>
								  (m_liveNodeWindows->ItemAt(i));
		if (entry->ref->id() == nodeID) {
			m_liveNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
			remove_observer(this, entry->ref);
			delete entry;
		}
	}

	if (m_liveNodeWindows->CountItems() <= 0) {
		delete m_liveNodeWindows;
		m_liveNodeWindows = 0;
	}
}

bool InfoWindowManager::_addWindowFor(
	const dormant_node_info &info,
	BWindow *window) {
	D_INTERNAL(("InfoWindowManager::_addWindowFor(dormant_node)\n"));

	if (!m_dormantNodeWindows) {
		m_dormantNodeWindows = new BList();
	}

	dormant_node_window *entry = new dormant_node_window(info, window);
	return m_dormantNodeWindows->AddItem(reinterpret_cast<void *>(entry));
}

bool InfoWindowManager::_findWindowFor(
	const dormant_node_info &info,
	BWindow **outWindow) {
	D_INTERNAL(("InfoWindowManager::_findWindowFor(dormant_node)\n"));

	if (!m_dormantNodeWindows) {
		return false;
	}

	for (int32 i = 0; i < m_dormantNodeWindows->CountItems(); i++) {
		dormant_node_window *entry = static_cast<dormant_node_window *>
									 (m_dormantNodeWindows->ItemAt(i));
		if ((entry->info.addon == info.addon) 
		 && (entry->info.flavor_id == info.flavor_id)) {
			*outWindow = entry->window;
			return true;
		}
	}

	return false;
}

void InfoWindowManager::_removeWindowFor(
	const dormant_node_info &info) {
	D_INTERNAL(("InfoWindowManager::_removeWindowFor(dormant_node)\n"));

	if (!m_dormantNodeWindows) {
		return;
	}

	for (int32 i = 0; i < m_dormantNodeWindows->CountItems(); i++) {
		dormant_node_window *entry = static_cast<dormant_node_window *>
									 (m_dormantNodeWindows->ItemAt(i));
		if ((entry->info.addon == info.addon) 
		 && (entry->info.flavor_id == info.flavor_id)) {
			m_dormantNodeWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}
	}

	if (m_dormantNodeWindows->CountItems() >= 0) {
		delete m_dormantNodeWindows;
		m_dormantNodeWindows = 0;
	}
}

bool InfoWindowManager::_addWindowFor(
	const Connection &connection,
	BWindow *window) {
	D_INTERNAL(("InfoWindowManager::_addWindowFor(connection)\n"));

	if (!m_connectionWindows) {
		m_connectionWindows = new BList();
	}

	connection_window *entry = new connection_window(connection.source(),
													 connection.destination(),
													 window);
	return m_connectionWindows->AddItem(reinterpret_cast<void *>(entry));
}

bool InfoWindowManager::_findWindowFor(
	const media_source &source,
	const media_destination &destination,
	BWindow **outWindow) {
	D_INTERNAL(("InfoWindowManager::_findWindowFor(connection)\n"));

	if (!m_connectionWindows) {
		return false;
	}

	for (int32 i = 0; i < m_connectionWindows->CountItems(); i++) {
		connection_window *entry = static_cast<connection_window *>
								   (m_connectionWindows->ItemAt(i));
		if ((entry->source == source) 
		 && (entry->destination == destination)) {
			*outWindow = entry->window;
			return true;
		}
	}

	return false;
}

void InfoWindowManager::_removeWindowFor(
	const media_source &source,
	const media_destination &destination) {
	D_INTERNAL(("InfoWindowManager::_removeWindowFor(connection)\n"));

	if (!m_connectionWindows) {
		return;
	}

	for (int32 i = 0; i < m_connectionWindows->CountItems(); i++) {
		connection_window *entry = static_cast<connection_window *>
								   (m_connectionWindows->ItemAt(i));
		if ((entry->source == source) 
		 && (entry->destination == destination)) {
			m_connectionWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}
	}

	if (m_connectionWindows->CountItems() >= 0) {
		delete m_connectionWindows;
		m_connectionWindows = 0;
	}
}

bool InfoWindowManager::_addWindowFor(
	const media_input &input,
	BWindow *window) {
	D_INTERNAL(("InfoWindowManager::_addWindowFor(input)\n"));

	if (!m_inputWindows) {
		m_inputWindows = new BList();
	}

	input_window *entry = new input_window(input.destination, window);
	return m_inputWindows->AddItem(reinterpret_cast<void *>(entry));
}

bool InfoWindowManager::_findWindowFor(
	const media_destination &destination,
	BWindow **outWindow) {
	D_INTERNAL(("InfoWindowManager::_findWindowFor(input)\n"));

	if (!m_inputWindows) {
		return false;
	}

	for (int32 i = 0; i < m_inputWindows->CountItems(); i++) {
		input_window *entry = static_cast<input_window *>
							  (m_inputWindows->ItemAt(i));
		if (entry->destination == destination) {
			*outWindow = entry->window;
			return true;
		}
	}

	return false;
}

void InfoWindowManager::_removeWindowFor(
	const media_destination &destination) {
	D_INTERNAL(("InfoWindowManager::_removeWindowFor(input)\n"));

	if (!m_inputWindows) {
		return;
	}

	for (int32 i = 0; i < m_inputWindows->CountItems(); i++) {
		input_window *entry = static_cast<input_window *>
							  (m_inputWindows->ItemAt(i));
		if (entry->destination == destination) {
			m_inputWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}
	}

	if (m_inputWindows->CountItems() >= 0) {
		delete m_inputWindows;
		m_inputWindows = 0;
	}
}

bool InfoWindowManager::_addWindowFor(
	const media_output &output,
	BWindow *window) {
	D_INTERNAL(("InfoWindowManager::_addWindowFor(output)\n"));

	if (!m_outputWindows) {
		m_outputWindows = new BList();
	}

	output_window *entry = new output_window(output.source, window);
	return m_outputWindows->AddItem(reinterpret_cast<void *>(entry));
}

bool InfoWindowManager::_findWindowFor(
	const media_source &source,
	BWindow **outWindow) {
	D_INTERNAL(("InfoWindowManager::_findWindowFor(output)\n"));

	if (!m_outputWindows) {
		return false;
	}

	for (int32 i = 0; i < m_outputWindows->CountItems(); i++) {
		output_window *entry = static_cast<output_window *>
							  (m_outputWindows->ItemAt(i));
		if (entry->source == source) {
			*outWindow = entry->window;
			return true;
		}
	}

	return false;
}

void InfoWindowManager::_removeWindowFor(
	const media_source &source) {
	D_INTERNAL(("InfoWindowManager::_removeWindowFor(output)\n"));

	if (!m_outputWindows) {
		return;
	}

	for (int32 i = 0; i < m_outputWindows->CountItems(); i++) {
		output_window *entry = static_cast<output_window *>
							  (m_outputWindows->ItemAt(i));
		if (entry->source == source) {
			m_outputWindows->RemoveItem(reinterpret_cast<void *>(entry));
			delete entry;
		}
	}

	if (m_outputWindows->CountItems() >= 0) {
		delete m_outputWindows;
		m_outputWindows = 0;
	}
}

// END -- InfoWindowManager.cpp --