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.
 */


// ParameterWindowManager.cpp

#include "ParameterWindowManager.h"
#include "ParameterWindow.h"
// NodeManager
#include "NodeRef.h"

// Application Kit
#include <AppDefs.h>
// Media Kit
#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 the list of ParameterWindows
struct window_map_entry {

public:						// *** ctor/dtor

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

public:						// *** data members

	const NodeRef		   *ref;

	BWindow				   *window;
};

// used to remember the list of ControlPanels
struct panel_map_entry {

public:						// *** ctor/dtor

							panel_map_entry(
								int32 id,
								const BMessenger &messenger)
								: id(id),
								  messenger(messenger)
							{ }

public:						// *** data members

	int32					id;

	const BMessenger		messenger;
};

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

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

ParameterWindowManager *ParameterWindowManager::s_instance = 0;

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

/* hidden */
ParameterWindowManager::ParameterWindowManager()
	: BLooper("ParameterWindowManager",
			  B_NORMAL_PRIORITY),
	  m_windowList(0),
	  m_panelList(0),
	  m_lastWindowPosition(M_INIT_POSITION - M_DEFAULT_OFFSET) {
	D_ALLOC(("ParameterWindowManager::ParameterWindowManager()\n"));

	m_windowList = new BList();
	m_panelList = new BList();
	Run();
}

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

	while (m_windowList->CountItems() > 0) {
		window_map_entry *entry = static_cast<window_map_entry *>
								  (m_windowList->ItemAt(0));
		if (entry && entry->window) {
			remove_observer(this, entry->ref);
			entry->window->Lock();
			entry->window->Quit();
		}
		m_windowList->RemoveItem(reinterpret_cast<void *>(entry));
		delete entry;
	}	
	delete m_windowList;

	while (m_panelList->CountItems() > 0) {
		panel_map_entry *entry = static_cast<panel_map_entry *>
								 (m_panelList->ItemAt(0));
		if (entry && entry->messenger.IsValid()) {
			entry->messenger.SendMessage(B_QUIT_REQUESTED);
		}
		m_panelList->RemoveItem(reinterpret_cast<void *>(entry));
		delete entry;
	}	
	delete m_panelList;

	s_instance = 0;
}

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

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

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

	return s_instance;
}

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

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

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

status_t ParameterWindowManager::openWindowFor(
	const NodeRef *ref) {
	D_WINDOW(("ParameterWindowManager::openWindowFor()\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;
	}

	BMessenger messenger(0, this);
	live_node_info nodeInfo = ref->nodeInfo();
	m_lastWindowPosition += M_DEFAULT_OFFSET;
	window = new ParameterWindow(m_lastWindowPosition,
								 nodeInfo, &messenger);
	if (_addWindowFor(ref, window)) {
		window->Show();
		return B_OK;
	}
	delete window;

	return B_ERROR;
}

status_t ParameterWindowManager::startControlPanelFor(
	const NodeRef *ref) {
	D_WINDOW(("ParameterWindowManager::startControlPanelFor()\n"));

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

	BMediaRoster *roster = BMediaRoster::CurrentRoster();
	if (!roster) {
		D_WINDOW((" -> MediaRoster not available\n"));
		return B_ERROR;
	}

	BMessenger messenger;
	if (_findPanelFor(ref->id(), &messenger)) {
		// find out if the messengers target still exists
		if (messenger.IsValid()) {
			return B_OK;
		}
		else {
			_removePanelFor(ref->id());
		}
	}

	status_t error = roster->StartControlPanel(ref->node(),
											   &messenger);
	if (error) {
		D_INTERNAL((" -> StartControlPanel() failed (%s)\n",
					strerror(error)));
		return error;
	}

	_addPanelFor(ref->id(), messenger);
	return B_OK;
}

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

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

	switch (message->what) {
		case ParameterWindow::M_CLOSED: {
			D_MESSAGE((" -> ParameterWindow::M_CLOSED\n"));
			int32 nodeID;
			if (message->FindInt32("nodeID", &nodeID) != B_OK) {
				return;
			}
			_removeWindowFor(nodeID);
			break;
		}
		case ParameterWindow::M_CONTROL_PANEL_STARTED: {
			D_MESSAGE((" -> ParameterWindow::M_CONTROL_PANEL_STARTED\n"));
			int32 nodeID;
			if (message->FindInt32("nodeID", &nodeID) != B_OK) {
				return;
			}
			BMessenger messenger;
			if (message->FindMessenger("messenger", &messenger) != B_OK) {
				return;
			}
			_addPanelFor(nodeID, messenger);
			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;
		}
		default: {
			BLooper::MessageReceived(message);
		}
	}
}

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

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

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

	return false;
}

bool ParameterWindowManager::_findWindowFor(
	int32 id,
	BWindow **outWindow) {
	D_INTERNAL(("ParameterWindowManager::_findWindowFor()\n"));

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

	return false;
}

void ParameterWindowManager::_removeWindowFor(
	int32 id) {
	D_INTERNAL(("ParameterWindowManager::_removeWindowFor()\n"));

	for (int32 i = 0; i < m_windowList->CountItems(); i++) {
		window_map_entry *entry = static_cast<window_map_entry *>
								  (m_windowList->ItemAt(i));
		if (entry->ref->id() == id) {
			m_windowList->RemoveItem(reinterpret_cast<void *>(entry));
			remove_observer(this, entry->ref);
			delete entry;
		}
	}
	
	// try to shutdown
	if (m_windowList->CountItems() == 0) {
		int32 i = 0;
		while (true) {
			// take all invalid messengers out of the panel list
			panel_map_entry *entry = static_cast<panel_map_entry *>
									 (m_panelList->ItemAt(i));
			if (!entry) {
				// end of list
				break;
			}
			if (!entry->messenger.IsValid()) {
				// this control panel doesn't exist anymore
				m_panelList->RemoveItem(entry);
				continue;
			}
		}
		if (m_panelList->CountItems() == 0) {
			// neither windows nor panels to manage, go to sleep
			PostMessage(B_QUIT_REQUESTED);
		}
	}
}

bool ParameterWindowManager::_addPanelFor(
	int32 id,
	const BMessenger &messenger) {
	D_INTERNAL(("ParameterWindowManager::_addPanelFor()\n"));

	panel_map_entry *entry = new panel_map_entry(id,
												 messenger);
	if (m_panelList->AddItem(reinterpret_cast<void *>(entry))) {
		return true;
	}

	return false;
}

bool ParameterWindowManager::_findPanelFor(
	int32 id,
	BMessenger *outMessenger) {
	D_INTERNAL(("ParameterWindowManager::_findPanelFor()\n"));

	for (int32 i = 0; i < m_panelList->CountItems(); i++) {
		panel_map_entry *entry = static_cast<panel_map_entry *>
								 (m_panelList->ItemAt(i));
		if (entry->id == id) {
			*outMessenger = entry->messenger;
			return true;
		}
	}

	return false;
}

void ParameterWindowManager::_removePanelFor(
	int32 id) {
	D_INTERNAL(("ParameterWindowManager::_removeWindowFor()\n"));

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

// END -- ParameterWindowManager.cpp --