haiku.git

/*
 * Copyright 2006, 2023, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */

#include "MessageExporter.h"

#include <ByteOrder.h>
#include <DataIO.h>
#include <Message.h>
#include <TypeConstants.h>

#include "Container.h"
#include "Defines.h"
#include "Icon.h"
#include "PathSourceShape.h"
#include "ReferenceImage.h"
#include "Shape.h"
#include "Style.h"
#include "Transformer.h"
#include "VectorPath.h"

// constructor
MessageExporter::MessageExporter()
{
}

// destructor
MessageExporter::~MessageExporter()
{
}

// Export
status_t
MessageExporter::Export(const Icon* icon, BPositionIO* stream)
{
	status_t ret = B_OK;
	BMessage archive;

	const Container<VectorPath>* paths = icon->Paths();
	const Container<Style>* styles = icon->Styles();

	// paths
	if (ret == B_OK) {
		BMessage allPaths;
		int32 count = paths->CountItems();
		for (int32 i = 0; i < count; i++) {
			VectorPath* path = paths->ItemAtFast(i);
			BMessage pathArchive;
			ret = _Export(path, &pathArchive);
			if (ret < B_OK)
				break;
			ret = allPaths.AddMessage("path", &pathArchive);
			if (ret < B_OK)
				break;
		}
	
		if (ret == B_OK)
			ret = archive.AddMessage("paths", &allPaths);
	}

	// styles
	if (ret == B_OK) {
		BMessage allStyles;
		int32 count = styles->CountItems();
		for (int32 i = 0; i < count; i++) {
			Style* style = styles->ItemAtFast(i);
			BMessage styleArchive;
			ret = _Export(style, &styleArchive);
			if (ret < B_OK)
				break;
			ret = allStyles.AddMessage("style", &styleArchive);
			if (ret < B_OK)
				break;
		}
	
		if (ret == B_OK)
			ret = archive.AddMessage("styles", &allStyles);
	}

	// shapes
	if (ret == B_OK) {
		BMessage allShapes;
		const Container<Shape>* shapes = icon->Shapes();
		int32 count = shapes->CountItems();
		for (int32 i = 0; i < count; i++) {
			Shape* shape = shapes->ItemAtFast(i);
			BMessage shapeArchive;
			ret = _Export(shape, paths, styles, &shapeArchive);
			if (ret < B_OK)
				break;
			ret = allShapes.AddMessage("shape", &shapeArchive);
			if (ret < B_OK)
				break;
		}
	
		if (ret == B_OK)
			ret = archive.AddMessage("shapes", &allShapes);
	}

	// prepend the magic number to the file which
	// later tells us that this file is one of us
	if (ret == B_OK) {
		ssize_t size = sizeof(uint32);
		uint32 magic = B_HOST_TO_BENDIAN_INT32(kNativeIconMagicNumber);
		ssize_t written = stream->Write(&magic, size);
		if (written != size) {
			if (written < 0)
				ret = (status_t)written;
			else
				ret = B_IO_ERROR;
		}
	}

	if (ret == B_OK)
		ret = archive.Flatten(stream);

	return ret;
}

// MIMEType
const char*
MessageExporter::MIMEType()
{
	return kNativeIconMimeType;
}

// #pragma mark -

// _Export
status_t
MessageExporter::_Export(const VectorPath* path, BMessage* into) const
{
	return path->Archive(into, true);
}

// _Export
status_t
MessageExporter::_Export(const Style* style, BMessage* into) const
{
	return style->Archive(into, true);
}

// _Export
status_t
MessageExporter::_Export(const Shape* shape,
						 const Container<VectorPath>* globalPaths,
						 const Container<Style>* globalStyles,
						 BMessage* into) const
{
	status_t ret = B_OK;

	const PathSourceShape* pathSourceShape = dynamic_cast<const PathSourceShape*>(shape);
	if (pathSourceShape != NULL) {
		ret = into->AddInt32("type", PathSourceShape::archive_code);

		// NOTE: when the same path is used in two different
		// documents, and these are to be merged, each path
		// having a "globally unique" id would make it possible
		// to reference the same path across documents...
		// For now, we simply use the index of the path in the
		// globalPaths container.

		// index of used style
		if (ret == B_OK) {
			Style* style = pathSourceShape->Style();
			ret = into->AddInt32("style ref", globalStyles->IndexOf(style));
		}

		// indices of used paths
		if (ret == B_OK) {
			int32 count = pathSourceShape->Paths()->CountItems();
			for (int32 i = 0; i < count; i++) {
				VectorPath* path = pathSourceShape->Paths()->ItemAtFast(i);
				ret = into->AddInt32("path ref", globalPaths->IndexOf(path));
				if (ret < B_OK)
					break;
			}
		}
	}

	const ReferenceImage* referenceImage = dynamic_cast<const ReferenceImage*>(shape);
	if (referenceImage != NULL) {
		ret = into->AddInt32("type", ReferenceImage::archive_code);
	}

	// Shape properties
	if (ret == B_OK)
		ret = shape->Archive(into);

	return ret;
}