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


// RouteApp.cpp
// e.moon 14may99

#include "RouteApp.h"
#include "RouteWindow.h"
#include "DormantNodeWindow.h"
#include "MediaRoutingView.h"
#include "MediaNodePanel.h"

#include "RouteAppNodeManager.h"
#include "NodeRef.h"

#include "TipManager.h"

#include "AddOnHost.h"

#include "route_app_io.h"
#include "XML.h"
#include "MessageIO.h"
#include "NodeSetIOContext.h"

#include <Debug.h>
#include <OS.h>
#include <Roster.h>
#include <Directory.h>
#include <FindDirectory.h>
#include <NodeInfo.h>
#include <Path.h>
#include <Entry.h>

extern "C" void SetNewLeakChecking(bool);
extern "C" void SetMallocLeakChecking(bool);

using namespace std;

__USE_CORTEX_NAMESPACE

const char* const		RouteApp::s_settingsDirectory = "Cortex";
const char* const		RouteApp::s_settingsFile = "cortex_settings";

const char* const		RouteApp::s_appSignature = "application/x-vnd.Cortex.Route";

BMimeType						RouteApp::s_nodeSetType("text/x-vnd.Cortex.NodeSet");

const char* const		RouteApp::s_rootElement = "cortex_settings";
const char* const		RouteApp::s_mediaRoutingViewElement = "MediaRoutingView";
const char* const		RouteApp::s_routeWindowElement = "RouteWindow";

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

RouteApp::~RouteApp() {
//	PRINT((
//		"RouteApp::~RouteApp()\n"));

	ASSERT(manager);
	thread_id id = manager->Thread();
	manager->release();
	
//	PRINT((
//		"- waiting for manager to die\n"));
	if(id >= B_OK) {
		status_t err;
		while(wait_for_thread(id, &err) == B_INTERRUPTED) {
			PRINT((" * RouteApp::~RouteApp(): B_INTERRUPTED\n"));
		}
	}
//	PRINT((
//		"- RouteApp done.\n"));

	// [e.moon 6nov99] kill off the AddOnHost app, if any
	AddOnHost::Kill();
	
	if(m_settingsDocType)
		delete m_settingsDocType;
		
	if(m_nodeSetDocType)
		delete m_nodeSetDocType;
}

RouteApp::RouteApp() :
	BApplication(s_appSignature),
	manager(new RouteAppNodeManager(true)),
	routeWindow(0),
	m_settingsDocType(_createSettingsDocType()),
	m_nodeSetDocType(_createNodeSetDocType()),
	m_openPanel(B_OPEN_PANEL),
	m_savePanel(B_SAVE_PANEL) {
	
	// register MIME type(s)
	_InitMimeTypes();
	
	// create the window hierarchy
	RouteWindow*& r = const_cast<RouteWindow*&>(routeWindow);
	r = new RouteWindow(manager);
	
	// restore settings
	_readSettings();
	
	// fit windows to screen
	routeWindow->constrainToScreen();

	// show main window & palettes	
	routeWindow->Show();
}


bool
RouteApp::QuitRequested()
{
	// [e.moon 20oct99] make sure the main window is dead before quitting

	// store window positions & other settings
	// write settings file
	_writeSettings();

	routeWindow->_closePalettes();
	routeWindow->Lock();
	routeWindow->Quit();
	RouteWindow*& r = const_cast<RouteWindow*&>(routeWindow);
	r = 0;
		
	// clean up the TipManager [e.moon 19oct99]
	TipManager::QuitInstance();

	return true;
}

// -------------------------------------------------------- //
// *** BHandler
// -------------------------------------------------------- //

void RouteApp::MessageReceived(
	BMessage*									message) {
	
	status_t err;
	
	entry_ref ref;
	const char* name;
	
	switch(message->what) {
		
		case M_SHOW_OPEN_PANEL:
			m_openPanel.Show();
			break;

		case M_SHOW_SAVE_PANEL:
			m_savePanel.Show();
			break;

		case B_SAVE_REQUESTED: {
			err = message->FindRef("directory", &ref);
			if(err < B_OK)
				break;
			err = message->FindString("name", &name);
			if(err < B_OK)
				break;
			
			_writeSelectedNodeSet(&ref, name);

			m_savePanel.GetPanelDirectory(&ref);
			BEntry e(&ref);
			m_lastIODir.SetTo(&e);
			break;
		}
		
		default:
			_inherited::MessageReceived(message);
	}
}

// -------------------------------------------------------- //
// *** BApplication
// -------------------------------------------------------- //

void RouteApp::RefsReceived(
	BMessage*									message) {

	PRINT(("### RefsReceived\n"));

	status_t err;
	
	entry_ref ref;

	for(int32 n = 0; ; ++n) {	
		err = message->FindRef("refs", n, &ref);
		if(err < B_OK)
			break;
		
		_readNodeSet(&ref);
		
		m_openPanel.GetPanelDirectory(&ref);
		BEntry e(&ref);
		m_lastIODir.SetTo(&e);
	}
}

// -------------------------------------------------------- //
// *** IPersistent
// -------------------------------------------------------- //

// EXPORT

void RouteApp::xmlExportBegin(
	ExportContext&						context) const {
	context.beginElement(s_rootElement);
}
	
void RouteApp::xmlExportAttributes(
	ExportContext&						context) const {} //nyi: write version info +++++

// +++++
void RouteApp::xmlExportContent(
	ExportContext&						context) const {

	context.beginContent();

	// export app settings
	{
		BMessage m;
		exportState(&m);
		MessageIO io(&m);
		status_t err __attribute__((unused)) = context.writeObject(&io);
		ASSERT(err == B_OK);
	}
	
	if(routeWindow) {
		// export main routing window (frame/palette) settings
		context.beginElement(s_routeWindowElement);
		context.beginContent();
		BMessage m;
		if (routeWindow->Lock()) {
			routeWindow->exportState(&m);
			routeWindow->Unlock();
		}
		MessageIO io(&m);
		context.writeObject(&io);
		context.endElement();

		// export routing view (content) settings
		m.MakeEmpty();
		ASSERT(routeWindow->m_routingView);
		context.beginElement(s_mediaRoutingViewElement);
		context.beginContent();
		routeWindow->m_routingView->exportState(&m);
		context.writeObject(&io);
		context.endElement();
	}	
}
	
void RouteApp::xmlExportEnd(
	ExportContext&						context) const {
	context.endElement();
}

// IMPORT

void RouteApp::xmlImportBegin(
	ImportContext&						context) {

	m_readState = _READ_ROOT;
}

void RouteApp::xmlImportAttribute(
	const char*								key,
	const char*								value,
	ImportContext&						context) {} //nyi
	
void RouteApp::xmlImportContent(
	const char*								data,
	uint32										length,
	ImportContext&						context) {} //nyi
	
void RouteApp::xmlImportChild(
	IPersistent*							child,
	ImportContext&						context) {
	
	MessageIO* io = dynamic_cast<MessageIO*>(child);
	if(io) {
		ASSERT(io->message());
//		PRINT(("* RouteApp::xmlImportChild() [flat message]:\n"));
//		io->message()->PrintToStream();
		
		switch(m_readState) {
			case _READ_ROOT:
				importState(io->message());
				break;
			
			case _READ_ROUTE_WINDOW:
				ASSERT(routeWindow);
				routeWindow->importState(io->message());
				break;
				
			case _READ_MEDIA_ROUTING_VIEW:
				ASSERT(routeWindow);
				ASSERT(routeWindow->m_routingView);
				routeWindow->m_routingView->importState(io->message());
				break;

			default:
				PRINT(("! RouteApp::xmlImportChild(): unimplemented target\n"));
				break;
		}
	}
}
	
void RouteApp::xmlImportComplete(
	ImportContext&						context) {} //nyi

void RouteApp::xmlImportChildBegin(
	const char*								name,
	ImportContext&						context) {

	if(m_readState != _READ_ROOT) {
		context.reportError("RouteApp import: invalid nested element");
		return;
	}

	if(!strcmp(name, s_routeWindowElement)) {
		m_readState = _READ_ROUTE_WINDOW;
	}
	else if(!strcmp(name, s_mediaRoutingViewElement)) {
		m_readState = _READ_MEDIA_ROUTING_VIEW;
	}
	else {
		context.reportError("RouteApp import: unknown child element");
	}
}

void RouteApp::xmlImportChildComplete(
	const char*								name,
	ImportContext&						context) {

	if(m_readState == _READ_ROOT) {
		context.reportError("RouteApp import: garbled state");
		return;
	}
	m_readState = _READ_ROOT;
}

// -------------------------------------------------------- //
// *** IStateArchivable
// -------------------------------------------------------- //

status_t RouteApp::importState(
	const BMessage*						archive) {

	const char* last;
	if(archive->FindString("lastDir", &last) == B_OK) {
		m_lastIODir.SetTo(last);
		m_openPanel.SetPanelDirectory(last);
		m_savePanel.SetPanelDirectory(last);
	}
	
	return B_OK;
}

status_t RouteApp::exportState(
	BMessage*									archive) const {
	
	if(m_lastIODir.InitCheck() == B_OK)
		archive->AddString("lastDir", m_lastIODir.Path());
	
	return B_OK;
}

// -------------------------------------------------------- //
// implementation
// -------------------------------------------------------- //

XML::DocumentType* RouteApp::_createSettingsDocType() {

	XML::DocumentType* docType = new XML::DocumentType(
		s_rootElement);
	MessageIO::AddTo(docType);
	
	return docType;
}

XML::DocumentType* RouteApp::_createNodeSetDocType() {

	XML::DocumentType* docType = new XML::DocumentType(
		_NODE_SET_ELEMENT);
	RouteAppNodeManager::AddTo(docType);
	
	return docType;
}

status_t RouteApp::_readSettings() {

	// figure path
	BPath path;
	status_t err = find_directory(
		B_USER_SETTINGS_DIRECTORY,
		&path);
	ASSERT(err == B_OK);
	
	path.Append(s_settingsDirectory);
	BEntry entry(path.Path());
	if(!entry.Exists())
		return B_ENTRY_NOT_FOUND;

	path.Append(s_settingsFile);
	entry.SetTo(path.Path());
	if(!entry.Exists())
		return B_ENTRY_NOT_FOUND;

	// open the settings file
	BFile file(&entry, B_READ_ONLY);
	if(file.InitCheck() != B_OK)
		return file.InitCheck();
	
	// read it:
	list<BString> errors;
	err = XML::Read(
		&file,
		this,
		m_settingsDocType,
		&errors);

	if(errors.size()) {
		fputs("!!! RouteApp::_readSettings():", stderr);
		for(list<BString>::iterator it = errors.begin();
			it != errors.end(); ++it)
			fputs((*it).String(), stderr);
	}
	return err;			
}

status_t RouteApp::_writeSettings() {
	// figure path, creating settings folder if necessary
	BPath path;
	status_t err = find_directory(
		B_USER_SETTINGS_DIRECTORY,
		&path);
	ASSERT(err == B_OK);

	BDirectory baseDirectory, settingsDirectory;
	
	err = baseDirectory.SetTo(path.Path());
	if(err < B_OK)
		return err;
	
	path.Append(s_settingsDirectory);

	BEntry folderEntry(path.Path());
	if(!folderEntry.Exists()) {
		// create folder
		err = baseDirectory.CreateDirectory(s_settingsDirectory, &settingsDirectory);
		ASSERT(err == B_OK);
	}
	else
		settingsDirectory.SetTo(&folderEntry);
		
	// open/clobber file
	BFile file(
		&settingsDirectory,
		s_settingsFile,
		B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
	err = file.InitCheck();
	if(err < B_OK)
		return err;

	// write document header
	const char* header = "<?xml version=\"1.0\"?>\n";
	file.Write((const void*)header, strlen(header));
	
	// write content
	BString errorText;
	err = XML::Write(
		&file,
		this,
		&errorText);
	
	if(err < B_OK) {
		fprintf(stderr,
			"!!! RouteApp::_writeSettings() failed: %s\n",
			errorText.String());
	}

	return err;
}

// -------------------------------------------------------- //

class _RouteAppImportContext :
	public	ImportContext,
	public	NodeSetIOContext {

public:
	_RouteAppImportContext(
		list<BString>&							errors,
		MediaRoutingView*						routingView) :
		ImportContext(errors),
		m_routingView(routingView) {}

public:													// *** hooks
	virtual void importUIState(
		const BMessage*							archive) {
	
		PRINT((
			"### importUIState\n"));	
		
		if(m_routingView) {
//			m_routingView->LockLooper();
			m_routingView->DeselectAll();
			status_t err = m_routingView->importStateFor(
				this,
				archive);
			if(err < B_OK) {
				PRINT((
					"!!! _RouteAppImportContext::importStateFor() failed:\n"
					"    %s\n", strerror(err)));
			}
			m_routingView->Invalidate(); // +++++ not particularly clean
//			m_routingView->UnlockLooper();
		}
	}
	
	MediaRoutingView*							m_routingView;
};

status_t RouteApp::_readNodeSet(
	entry_ref*								ref) {

	BFile file(ref, B_READ_ONLY);
	status_t err = file.InitCheck();
	if(err < B_OK)
		return err;

	routeWindow->Lock();
	
	list<BString> errors;

	err = XML::Read(
		&file,
		manager,
		m_nodeSetDocType,
		new _RouteAppImportContext(errors, routeWindow->m_routingView));

	routeWindow->Unlock();

	if(errors.size()) {
		fputs("!!! RouteApp::_readNodeSet():", stderr);
		for(list<BString>::iterator it = errors.begin();
			it != errors.end(); ++it)
			fputs((*it).String(), stderr);
	}
	return err;			
}

// -------------------------------------------------------- //

class _RouteAppExportContext :
	public	ExportContext,
	public	NodeSetIOContext {

public:
	_RouteAppExportContext(
		MediaRoutingView*						routingView) :
		m_routingView(routingView) {}

public:													// *** hooks
	virtual void exportUIState(
		BMessage*										archive) {
	
		PRINT((
			"### exportUIState\n"));	

		if(m_routingView) {
			m_routingView->LockLooper();
			m_routingView->exportStateFor(
				this,
				archive);
			m_routingView->UnlockLooper();
		}
	}

	MediaRoutingView*							m_routingView;
};

status_t RouteApp::_writeSelectedNodeSet(
	entry_ref*								dirRef,
	const char*								filename) {
	
	status_t err;


	// sanity-check & fetch the selection
	routeWindow->Lock();
	
	MediaRoutingView* v = routeWindow->m_routingView;
	ASSERT(v);

	if(
		v->CountSelectedItems() < 0 ||
		v->SelectedType() != DiagramItem::M_BOX) {
		PRINT((
			"!!! RouteApp::_writeSelectedNodeSet():\n"
			"    Invalid selection!\n"));
			
		routeWindow->Unlock();
		return B_NOT_ALLOWED;
	}

	_RouteAppExportContext context(v);
	
	for(uint32 i = 0; i < v->CountSelectedItems(); ++i) {
		MediaNodePanel* panel = dynamic_cast<MediaNodePanel*>(v->SelectedItemAt(i));
		if(!panel)
			continue;
		err = context.addNode(panel->ref->id());
		if(err < B_OK) {
			PRINT((	
				"!!! context.addNode() failed: '%s\n", strerror(err)));
		}
	}
	routeWindow->Unlock();

	// open/clobber file
	BDirectory dir(dirRef);
	err = dir.InitCheck();
	if(err < B_OK)
		return err;

	BFile file(
		&dir,
		filename,
		B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
	err = file.InitCheck();
	if(err < B_OK)
		return err;
	
	// write document header
	const char* header = "<?xml version=\"1.0\"?>\n";
	file.Write((const void*)header, strlen(header));
	
	// export nodes
	context.stream = &file;
	err = context.writeObject(manager);
	if(err < B_OK) {
		PRINT((
			"!!! RouteApp::_writeSelectedNodeSet(): error:\n"
			"    %s\n", context.errorText()));

		// +++++ delete the malformed file
		
	}


	// write MIME type
	BNodeInfo* fileInfo = new BNodeInfo(&file);
	fileInfo->SetType(s_nodeSetType.Type());
	fileInfo->SetPreferredApp(s_appSignature);
	delete fileInfo;	
	
	return B_OK;
}

/*static*/
status_t RouteApp::_InitMimeTypes() {
	
	status_t err;
	
	ASSERT(s_nodeSetType.IsValid());
	
	if(!s_nodeSetType.IsInstalled()) {
		err = s_nodeSetType.Install();
		if(err < B_OK) {
			PRINT((
				"!!! RouteApp::_InitMimeTypes(): Install():\n"
				"    %s\n", strerror(err)));
			return err;
		}
		
		err = s_nodeSetType.SetPreferredApp(s_appSignature);
		if(err < B_OK) {
			PRINT((
				"!!! RouteApp::_InitMimeTypes(): SetPreferredApp():\n"
				"    %s\n", strerror(err)));
			return err;
		}
	}
	
	return B_OK;
}

// -------------------------------------------------------- //
// main() stub
// -------------------------------------------------------- //

int main(int argc, char** argv) {
//	SetNewLeakChecking(true);
//	SetMallocLeakChecking(true);
	
	RouteApp app;
	app.Run();

	return 0;
}

// END -- RouteApp.cpp --