haiku.git

/*
 * Copyright 2004-2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "TypeEditors.h"
#include "DataEditor.h"

#include <stdio.h>
#include <stdlib.h>

#include <Alert.h>
#include <Autolock.h>
#include <Bitmap.h>
#include <Catalog.h>
#include <IconUtils.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <Mime.h>
#include <PopUpMenu.h>
#include <ScrollBar.h>
#include <ScrollView.h>
#include <Slider.h>
#include <String.h>
#include <StringView.h>
#include <TextControl.h>
#include <TextView.h>
#include <TranslationUtils.h>
#include <TranslatorFormats.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TypeEditors"

static const uint32 kMsgValueChanged = 'vlch';
static const uint32 kMsgScaleChanged = 'scch';
static const uint32 kMimeTypeItem = 'miti';


class StringEditor : public TypeEditorView {
	public:
		StringEditor(DataEditor& editor);

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage* message);

		virtual void CommitChanges();

	private:
		void _UpdateText();

		BTextView*		fTextView;
		BString			fPreviousText;
};


class MimeTypeEditor : public TypeEditorView {
	public:
		MimeTypeEditor(DataEditor& editor);

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage* message);

		virtual void CommitChanges();
		virtual bool TypeMatches();

	private:
		void _UpdateText();

		BTextControl*	fTextControl;
		BString			fPreviousText;
};


class NumberEditor : public TypeEditorView {
	public:
		NumberEditor(DataEditor& editor);

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage* message);

		virtual void CommitChanges();
		virtual bool TypeMatches();

	private:
		void _UpdateText();
		const char* _TypeLabel();
		status_t _Format(char* buffer);
		size_t _Size();

		BTextControl*	fTextControl;
		BString			fPreviousText;
};


class BooleanEditor : public TypeEditorView {
	public:
		BooleanEditor(DataEditor& editor);

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage* message);

		virtual void CommitChanges();
		virtual bool TypeMatches();

	private:
		void _UpdateMenuField();

		BMenuItem*		fFalseMenuItem;
		BMenuItem*		fTrueMenuItem;
};


class ImageView : public TypeEditorView {
	public:
		ImageView(DataEditor &editor);
		virtual ~ImageView();

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage *message);
		virtual void Draw(BRect updateRect);

	private:
		void _UpdateImage();

		BBitmap*		fBitmap;
		BStringView*	fDescriptionView;
		BSlider*		fScaleSlider;
};


class MessageView : public TypeEditorView {
	public:
		MessageView(DataEditor& editor);
		virtual ~MessageView();

		virtual void AttachedToWindow();
		virtual void DetachedFromWindow();
		virtual void MessageReceived(BMessage* message);

		void SetTo(BMessage& message);

	private:
		BString _TypeToString(type_code type);
		void _UpdateMessage();

		BTextView*		fTextView;
};


//	#pragma mark - TypeEditorView


TypeEditorView::TypeEditorView(const char *name, uint32 flags,
		DataEditor& editor)
	: BView(name, flags),
	fEditor(editor)
{
}


TypeEditorView::~TypeEditorView()
{
}


void
TypeEditorView::CommitChanges()
{
	// the default just does nothing here
}


bool
TypeEditorView::TypeMatches()
{
	// the default is to accept anything that easily fits into memory

	system_info info;
	get_system_info(&info);

	return uint64(fEditor.FileSize()) / B_PAGE_SIZE < info.max_pages / 2;
}


//	#pragma mark - StringEditor


StringEditor::StringEditor(DataEditor& editor)
	: TypeEditorView(B_TRANSLATE("String editor"), 0, editor)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

	BStringView *stringView = new BStringView(B_EMPTY_STRING,
		B_TRANSLATE("Contents:"));

	fTextView = new BTextView(B_EMPTY_STRING, B_WILL_DRAW);
	BScrollView* scrollView = new BScrollView("scroller", fTextView, 0, true, true);

	BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
		.SetInsets(0, B_USE_WINDOW_INSETS)
		.Add(stringView)
		.Add(scrollView);
}


void
StringEditor::_UpdateText()
{
	BAutolock locker(fEditor);

	size_t viewSize = fEditor.ViewSize();
	// that may need some more memory...
	if ((off_t)viewSize < fEditor.FileSize())
		fEditor.SetViewSize(fEditor.FileSize());

	const char *buffer;
	if (fEditor.GetViewBuffer((const uint8 **)&buffer) == B_OK) {
		fTextView->SetText(buffer);
		fPreviousText.SetTo(buffer);
	}

	// restore old view size
	fEditor.SetViewSize(viewSize);
}


void
StringEditor::CommitChanges()
{
	if (fPreviousText != fTextView->Text()) {
		fEditor.Replace(0, (const uint8 *)fTextView->Text(),
			fTextView->TextLength() + 1);
	}
}


void
StringEditor::AttachedToWindow()
{
	fEditor.StartWatching(this);

	_UpdateText();
}


void
StringEditor::DetachedFromWindow()
{
	fEditor.StopWatching(this);

	CommitChanges();
}


void
StringEditor::MessageReceived(BMessage *message)
{
	BView::MessageReceived(message);
}


//	#pragma mark - MimeTypeEditor


MimeTypeEditor::MimeTypeEditor(DataEditor& editor)
	: TypeEditorView(B_TRANSLATE("MIME type editor"), 0, editor)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	SetHighUIColor(B_PANEL_TEXT_COLOR);

	fTextControl = new BTextControl(B_EMPTY_STRING, B_TRANSLATE("MIME type:"), NULL,
		new BMessage(kMsgValueChanged));

	BLayoutBuilder::Group<>(this, B_VERTICAL)
		.SetInsets(0, B_USE_WINDOW_INSETS)
		.Add(fTextControl);
}


void
MimeTypeEditor::_UpdateText()
{
	BAutolock locker(fEditor);

	const char* mimeType;
	if (fEditor.GetViewBuffer((const uint8 **)&mimeType) == B_OK) {
		fTextControl->SetText(mimeType);
		fPreviousText.SetTo(mimeType);
	}
}


void
MimeTypeEditor::CommitChanges()
{
	if (fPreviousText != fTextControl->Text()) {
		fEditor.Replace(0, (const uint8*)fTextControl->Text(),
			strlen(fTextControl->Text()) + 1);
	}
}


bool
MimeTypeEditor::TypeMatches()
{
	// TODO: check contents?
	return fEditor.FileSize() <= B_MIME_TYPE_LENGTH;
}


void
MimeTypeEditor::AttachedToWindow()
{
	fTextControl->SetTarget(this);
	fEditor.StartWatching(this);

	_UpdateText();
}


void
MimeTypeEditor::DetachedFromWindow()
{
	fEditor.StopWatching(this);

	CommitChanges();
}


void
MimeTypeEditor::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case kMsgValueChanged:
			fEditor.Replace(0, (const uint8 *)fTextControl->Text(),
				strlen(fTextControl->Text()) + 1);
			break;

		case kMsgDataEditorUpdate:
			_UpdateText();
			break;

		default:
			BView::MessageReceived(message);
	}
}


//	#pragma mark - NumberEditor


NumberEditor::NumberEditor(DataEditor &editor)
	: TypeEditorView(B_TRANSLATE("Number editor"), 0, editor)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	SetHighUIColor(B_PANEL_TEXT_COLOR);

	fTextControl = new BTextControl(B_EMPTY_STRING, _TypeLabel(), NULL,
		new BMessage(kMsgValueChanged));
	fTextControl->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_RIGHT);

	BLayoutBuilder::Group<>(this, B_VERTICAL)
		.SetInsets(0, B_USE_WINDOW_INSETS)
		.Add(fTextControl);
}


void
NumberEditor::_UpdateText()
{
	if (fEditor.Lock()) {
		const char* number;
		if (fEditor.GetViewBuffer((const uint8**)&number) == B_OK) {
			char buffer[64];
			char format[16];
			switch (fEditor.Type()) {
				case B_FLOAT_TYPE:
				{
					float value = *(float*)number;
					snprintf(buffer, sizeof(buffer), "%g", value);
					break;
				}
				case B_DOUBLE_TYPE:
				{
					double value = *(double *)number;
					snprintf(buffer, sizeof(buffer), "%g", value);
					break;
				}
				case B_SSIZE_T_TYPE:
				case B_INT8_TYPE:
				case B_INT16_TYPE:
				case B_INT32_TYPE:
				case B_INT64_TYPE:
				case B_OFF_T_TYPE:
				{
					_Format(format);
					switch (_Size()) {
						case 1:
						{
							int8 value = *(int8 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 2:
						{
							int16 value = *(int16 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 4:
						{
							int32 value = *(int32 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 8:
						{
							int64 value = *(int64 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
					}
					break;
				}

				default:
				{
					_Format(format);
					switch (_Size()) {
						case 1:
						{
							uint8 value = *(uint8 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 2:
						{
							uint16 value = *(uint16 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 4:
						{
							uint32 value = *(uint32 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
						case 8:
						{
							uint64 value = *(uint64 *)number;
							snprintf(buffer, sizeof(buffer), format, value);
							break;
						}
					}
					break;
				}
			}
			fTextControl->SetText(buffer);
			fPreviousText.SetTo(buffer);
		}

		fEditor.Unlock();
	}
}


bool
NumberEditor::TypeMatches()
{
	return fEditor.FileSize() >= (off_t)_Size();
		// we only look at as many bytes we need to
}


void
NumberEditor::CommitChanges()
{
	if (fPreviousText == fTextControl->Text())
		return;

	const char *number = fTextControl->Text();
	uint8 buffer[8];

	switch (fEditor.Type()) {
		case B_FLOAT_TYPE:
		{
			float value = strtod(number, NULL);
			*(float *)buffer = value;
			break;
		}
		case B_DOUBLE_TYPE:
		{
			double value = strtod(number, NULL);
			*(double *)buffer = value;
			break;
		}
		case B_INT8_TYPE:
		{
			int64 value = strtoll(number, NULL, 0);
			if (value > CHAR_MAX)
				value = CHAR_MAX;
			else if (value < CHAR_MIN)
				value = CHAR_MIN;
			*(int8 *)buffer = (int8)value;
			break;
		}
		case B_UINT8_TYPE:
		{
			int64 value = strtoull(number, NULL, 0);
			if (value > UCHAR_MAX)
				value = UCHAR_MAX;
			*(uint8 *)buffer = (uint8)value;
			break;
		}
		case B_INT16_TYPE:
		{
			int64 value = strtoll(number, NULL, 0);
			if (value > SHRT_MAX)
				value = SHRT_MAX;
			else if (value < SHRT_MIN)
				value = SHRT_MIN;
			*(int16 *)buffer = (int16)value;
			break;
		}
		case B_UINT16_TYPE:
		{
			int64 value = strtoull(number, NULL, 0);
			if (value > USHRT_MAX)
				value = USHRT_MAX;
			*(uint16 *)buffer = (uint16)value;
			break;
		}
		case B_INT32_TYPE:
		case B_SSIZE_T_TYPE:
		{
			int64 value = strtoll(number, NULL, 0);
			if (value > LONG_MAX)
				value = LONG_MAX;
			else if (value < LONG_MIN)
				value = LONG_MIN;
			*(int32 *)buffer = (int32)value;
			break;
		}
		case B_UINT32_TYPE:
		case B_SIZE_T_TYPE:
		case B_POINTER_TYPE:
		{
			uint64 value = strtoull(number, NULL, 0);
			if (value > ULONG_MAX)
				value = ULONG_MAX;
			*(uint32 *)buffer = (uint32)value;
			break;
		}
		case B_INT64_TYPE:
		case B_OFF_T_TYPE:
		{
			int64 value = strtoll(number, NULL, 0);
			*(int64 *)buffer = value;
			break;
		}
		case B_UINT64_TYPE:
		{
			uint64 value = strtoull(number, NULL, 0);
			*(uint64 *)buffer = value;
			break;
		}
		default:
			return;
	}

	fEditor.Replace(0, buffer, _Size());
	fPreviousText.SetTo((char *)buffer);
}


const char*
NumberEditor::_TypeLabel()
{
	switch (fEditor.Type()) {
		case B_INT8_TYPE:
			return B_TRANSLATE("8 bit signed value:");
		case B_UINT8_TYPE:
			return B_TRANSLATE("8 bit unsigned value:");
		case B_INT16_TYPE:
			return B_TRANSLATE("16 bit signed value:");
		case B_UINT16_TYPE:
			return B_TRANSLATE("16 bit unsigned value:");
		case B_INT32_TYPE:
			return B_TRANSLATE("32 bit signed value:");
		case B_UINT32_TYPE:
			return B_TRANSLATE("32 bit unsigned value:");
		case B_INT64_TYPE:
			return B_TRANSLATE("64 bit signed value:");
		case B_UINT64_TYPE:
			return B_TRANSLATE("64 bit unsigned value:");
		case B_FLOAT_TYPE:
			return B_TRANSLATE("Floating-point value:");
		case B_DOUBLE_TYPE:
			return B_TRANSLATE("Double precision floating-point value:");
		case B_SSIZE_T_TYPE:
			return B_TRANSLATE("32 bit size or status:");
		case B_SIZE_T_TYPE:
			return B_TRANSLATE("32 bit unsigned size:");
		case B_OFF_T_TYPE:
			return B_TRANSLATE("64 bit signed offset:");
		case B_POINTER_TYPE:
			return B_TRANSLATE("32 bit unsigned pointer:");
		default:
			return B_TRANSLATE("Number:");
	}
}


size_t
NumberEditor::_Size()
{
	switch (fEditor.Type()) {
		case B_INT8_TYPE:
		case B_UINT8_TYPE:
			return 1;
		case B_INT16_TYPE:
		case B_UINT16_TYPE:
			return 2;
		case B_SSIZE_T_TYPE:
		case B_INT32_TYPE:
		case B_SIZE_T_TYPE:
		case B_POINTER_TYPE:
		case B_UINT32_TYPE:
			return 4;
		case B_INT64_TYPE:
		case B_OFF_T_TYPE:
		case B_UINT64_TYPE:
			return 8;
		case B_FLOAT_TYPE:
			return 4;
		case B_DOUBLE_TYPE:
			return 8;

		default:
			return 0;
	}
}


status_t
NumberEditor::_Format(char *buffer)
{
	switch (fEditor.Type()) {
		case B_INT8_TYPE:
			strcpy(buffer, "%hd");
			return B_OK;
		case B_UINT8_TYPE:
			strcpy(buffer, "%hu");
			return B_OK;
		case B_INT16_TYPE:
			strcpy(buffer, "%hd");
			return B_OK;
		case B_UINT16_TYPE:
			strcpy(buffer, "%hu");
			return B_OK;
		case B_SSIZE_T_TYPE:
		case B_INT32_TYPE:
			strcpy(buffer, "%ld");
			return B_OK;
		case B_SIZE_T_TYPE:
		case B_POINTER_TYPE:
		case B_UINT32_TYPE:
			strcpy(buffer, "%lu");
			return B_OK;
		case B_INT64_TYPE:
		case B_OFF_T_TYPE:
			strcpy(buffer, "%lld");
			return B_OK;
		case B_UINT64_TYPE:
			strcpy(buffer, "%Lu");
			return B_OK;
		case B_FLOAT_TYPE:
			strcpy(buffer, "%g");
			return B_OK;
		case B_DOUBLE_TYPE:
			strcpy(buffer, "%lg");
			return B_OK;

		default:
			return B_ERROR;
	}
}


void
NumberEditor::AttachedToWindow()
{
	fTextControl->SetTarget(this);
	fEditor.StartWatching(this);

	_UpdateText();
}


void
NumberEditor::DetachedFromWindow()
{
	fEditor.StopWatching(this);

	CommitChanges();
}


void
NumberEditor::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case kMsgValueChanged:
			CommitChanges();
			break;
		case kMsgDataEditorUpdate:
			_UpdateText();
			break;

		default:
			BView::MessageReceived(message);
	}
}


//	#pragma mark - BooleanEditor


BooleanEditor::BooleanEditor(DataEditor &editor)
	: TypeEditorView(B_TRANSLATE("Boolean editor"), 0, editor)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	SetHighUIColor(B_PANEL_TEXT_COLOR);

	BPopUpMenu *menu = new BPopUpMenu("bool");
	BMessage *message;
	menu->AddItem(fFalseMenuItem = new BMenuItem("false",
		new BMessage(kMsgValueChanged)));
	menu->AddItem(fTrueMenuItem = new BMenuItem("true",
		message = new BMessage(kMsgValueChanged)));
	message->AddInt8("value", 1);

	BMenuField *menuField = new BMenuField(B_EMPTY_STRING, B_TRANSLATE("Boolean value:"), menu);

	_UpdateMenuField();

	BLayoutBuilder::Group<>(this, B_VERTICAL)
		.SetInsets(0, B_USE_WINDOW_INSETS)
		.Add(menuField);
}


bool
BooleanEditor::TypeMatches()
{
	// we accept everything: we just look at the first byte, anyway
	return true;
}


void
BooleanEditor::_UpdateMenuField()
{
	if (fEditor.FileSize() != 1)
		return;

	if (fEditor.Lock()) {
		const char *buffer;
		if (fEditor.GetViewBuffer((const uint8 **)&buffer) == B_OK)
			(buffer[0] != 0 ? fTrueMenuItem : fFalseMenuItem)->SetMarked(true);

		fEditor.Unlock();
	}
}


void
BooleanEditor::CommitChanges()
{
	// we're commiting the changes as they happen
}


void
BooleanEditor::AttachedToWindow()
{
	fTrueMenuItem->SetTarget(this);
	fFalseMenuItem->SetTarget(this);

	fEditor.StartWatching(this);
}


void
BooleanEditor::DetachedFromWindow()
{
	fEditor.StopWatching(this);
}


void
BooleanEditor::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case kMsgValueChanged:
		{
			uint8 boolean = message->FindInt8("value");
			fEditor.Replace(0, (const uint8 *)&boolean, 1);
			break;
		}
		case kMsgDataEditorUpdate:
			_UpdateMenuField();
			break;

		default:
			BView::MessageReceived(message);
	}
}


//	#pragma mark - ImageView


ImageView::ImageView(DataEditor &editor)
	: TypeEditorView(B_TRANSLATE_COMMENT("Image view", "Image means here a "
		"picture file, not a disk image."),
		B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE, editor),
	fBitmap(NULL),
	fScaleSlider(NULL)
{
	if (editor.Type() == B_MINI_ICON_TYPE
		|| editor.Type() == B_LARGE_ICON_TYPE
		|| editor.Type() == B_VECTOR_ICON_TYPE) {
		SetName(B_TRANSLATE("Icon view"));
	}


	fDescriptionView = new BStringView("",
		B_TRANSLATE_COMMENT("Could not read image", "Image means "
		"here a picture file, not a disk image."));
	fDescriptionView->SetAlignment(B_ALIGN_CENTER);

	if (editor.Type() == B_VECTOR_ICON_TYPE) {
		// vector icon
		fScaleSlider = new BSlider("", NULL,
			new BMessage(kMsgScaleChanged), 2, 32, B_HORIZONTAL);
		fScaleSlider->SetModificationMessage(new BMessage(kMsgScaleChanged));
		fScaleSlider->ResizeToPreferred();
		fScaleSlider->SetValue(8);
		fScaleSlider->SetHashMarks(B_HASH_MARKS_BOTH);
		fScaleSlider->SetHashMarkCount(15);

		BLayoutBuilder::Group<>(this, B_HORIZONTAL)
			.SetInsets(B_USE_WINDOW_SPACING, 256, B_USE_WINDOW_SPACING,
				B_H_SCROLL_BAR_HEIGHT) // Leave space for the icon
			.AddGlue()
			.AddGroup(B_VERTICAL)
				.Add(fDescriptionView)
				.Add(fScaleSlider)
			.End()
			.AddGlue();
	} else {
		BLayoutBuilder::Group<>(this, B_HORIZONTAL)
			.SetInsets(B_USE_WINDOW_SPACING, 256, B_USE_WINDOW_SPACING,
				B_USE_WINDOW_SPACING) // Leave space for the icon
			.AddGlue()
			.Add(fDescriptionView)
			.AddGlue();
	}
}


ImageView::~ImageView()
{
	delete fBitmap;
}


void
ImageView::AttachedToWindow()
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

	fEditor.StartWatching(this);
	if (fScaleSlider != NULL)
		fScaleSlider->SetTarget(this);

	_UpdateImage();
}


void
ImageView::DetachedFromWindow()
{
	fEditor.StopWatching(this);
}


void
ImageView::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case kMsgDataEditorUpdate:
			_UpdateImage();
			break;

		case kMsgScaleChanged:
			_UpdateImage();
			break;

		default:
			BView::MessageReceived(message);
	}
}


void
ImageView::Draw(BRect updateRect)
{
	if (fBitmap != NULL) {
		SetDrawingMode(B_OP_ALPHA);
		DrawBitmap(fBitmap, BPoint((Bounds().Width() - fBitmap->Bounds().Width()) / 2,
			(Bounds().Height() - fBitmap->Bounds().Height() - 60) / 2));
		SetDrawingMode(B_OP_COPY);
	}
}


void
ImageView::_UpdateImage()
{
	// ToDo: add scroller if necessary?!

	BAutolock locker(fEditor);

	// we need all the data...

	size_t viewSize = fEditor.ViewSize();
	// that may need some more memory...
	if ((off_t)viewSize < fEditor.FileSize())
		fEditor.SetViewSize(fEditor.FileSize());

	const char *data;
	if (fEditor.GetViewBuffer((const uint8 **)&data) != B_OK) {
		fEditor.SetViewSize(viewSize);
		return;
	}

	if (fBitmap != NULL && (fEditor.Type() == B_MINI_ICON_TYPE
			|| fEditor.Type() == B_LARGE_ICON_TYPE)) {
		// optimize icon update...
		fBitmap->SetBits(data, fEditor.FileSize(), 0, B_CMAP8);
		fEditor.SetViewSize(viewSize);
		return;
	}
	if (fBitmap != NULL && fEditor.Type() == B_VECTOR_ICON_TYPE
		&& fScaleSlider->Value() * 8 - 1 == fBitmap->Bounds().Width()) {
		if (BIconUtils::GetVectorIcon((const uint8 *)data,
				(size_t)fEditor.FileSize(), fBitmap) == B_OK) {
			fEditor.SetViewSize(viewSize);
			return;
		}
	}

	delete fBitmap;
	fBitmap = NULL;

	switch (fEditor.Type()) {
		case B_MINI_ICON_TYPE:
			fBitmap = new BBitmap(BRect(0, 0, 15, 15), B_CMAP8);
			if (fBitmap->InitCheck() == B_OK)
				fBitmap->SetBits(data, fEditor.FileSize(), 0, B_CMAP8);
			break;
		case B_LARGE_ICON_TYPE:
			fBitmap = new BBitmap(BRect(0, 0, 31, 31), B_CMAP8);
			if (fBitmap->InitCheck() == B_OK)
				fBitmap->SetBits(data, fEditor.FileSize(), 0, B_CMAP8);
			break;
		case B_VECTOR_ICON_TYPE:
			fBitmap = new BBitmap(BRect(0, 0, fScaleSlider->Value() * 8 - 1,
				fScaleSlider->Value() * 8 - 1), B_RGB32);
			if (fBitmap->InitCheck() != B_OK
				|| BIconUtils::GetVectorIcon((const uint8 *)data,
					(size_t)fEditor.FileSize(), fBitmap) != B_OK) {
				delete fBitmap;
				fBitmap = NULL;
			}
			break;
		case B_PNG_FORMAT:
		{
			BMemoryIO stream(data, fEditor.FileSize());
			fBitmap = BTranslationUtils::GetBitmap(&stream);
			break;
		}
		case B_MESSAGE_TYPE:
		{
			BMessage message;
			// ToDo: this could be problematic if the data is not large
			//		enough to contain the message...
			if (message.Unflatten(data) == B_OK)
				fBitmap = new BBitmap(&message);
			break;
		}
	}

	// Update the bitmap description. If no image can be displayed,
	// we will show our "unsupported" message

	if (fBitmap != NULL && fBitmap->InitCheck() != B_OK) {
		delete fBitmap;
		fBitmap = NULL;
	}

	if (fBitmap != NULL) {
		char buffer[256];
		const char *type = B_TRANSLATE("Unknown type");
		switch (fEditor.Type()) {
			case B_MINI_ICON_TYPE:
			case B_LARGE_ICON_TYPE:
			case B_VECTOR_ICON_TYPE:
				type = B_TRANSLATE("Icon");
				break;
			case B_PNG_FORMAT:
				type = B_TRANSLATE("PNG format");
				break;
			case B_MESSAGE_TYPE:
				type = B_TRANSLATE("Flattened bitmap");
				break;
			default:
				break;
		}
		const char *colorSpace;
		switch (fBitmap->ColorSpace()) {
			case B_GRAY1:
			case B_GRAY8:
				colorSpace = B_TRANSLATE("Grayscale");
				break;
			case B_CMAP8:
				colorSpace = B_TRANSLATE("8 bit palette");
				break;
			case B_RGB32:
			case B_RGBA32:
			case B_RGB32_BIG:
			case B_RGBA32_BIG:
				colorSpace = B_TRANSLATE("32 bit");
				break;
			case B_RGB15:
			case B_RGBA15:
			case B_RGB15_BIG:
			case B_RGBA15_BIG:
				colorSpace = B_TRANSLATE("15 bit");
				break;
			case B_RGB16:
			case B_RGB16_BIG:
				colorSpace = B_TRANSLATE("16 bit");
				break;
			default:
				colorSpace = B_TRANSLATE("Unknown format");
				break;
		}
		snprintf(buffer, sizeof(buffer), B_TRANSLATE_COMMENT("%s, %g × %g, %s",
			"The '×' is the Unicode multiplication sign U+00D7"), type,
			fBitmap->Bounds().Width() + 1, fBitmap->Bounds().Height() + 1,
			colorSpace);
		fDescriptionView->SetText(buffer);
	} else
		fDescriptionView->SetText(B_TRANSLATE_COMMENT("Could not read image",
			"Image means here a picture file, not a disk image."));

	if (fBitmap != NULL) {
		if (fScaleSlider != NULL) {
			if (fScaleSlider->IsHidden())
				fScaleSlider->Show();
		}
	} else if (fScaleSlider != NULL && !fScaleSlider->IsHidden())
		fScaleSlider->Hide();

	Invalidate();

	// restore old view size
	fEditor.SetViewSize(viewSize);
}


//	#pragma mark - MessageView


MessageView::MessageView(DataEditor &editor)
	: TypeEditorView(B_TRANSLATE("Message View"), 0, editor)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	SetHighUIColor(B_PANEL_TEXT_COLOR);

	fTextView = new BTextView(B_EMPTY_STRING, B_WILL_DRAW);
	fTextView->SetViewUIColor(ViewUIColor());
	fTextView->SetLowUIColor(ViewUIColor());

	BScrollView *scrollView = new BScrollView("scroller", fTextView,
		B_FOLLOW_ALL, B_WILL_DRAW, true, true);

	BLayoutBuilder::Group<>(this, B_VERTICAL)
		.SetInsets(0, B_USE_WINDOW_INSETS)
		.Add(scrollView);
}


MessageView::~MessageView()
{
}


BString
MessageView::_TypeToString(type_code type)
{
	// TODO: move this to a utility function (it's a copy from something
	// similar in ProbeView.cpp)
	char text[32];
	for (int32 i = 0; i < 4; i++) {
		text[i] = type >> (24 - 8 * i);
		if (text[i] < ' ' || text[i] == 0x7f) {
			snprintf(text, sizeof(text), "0x%04" B_PRIx32, type);
			break;
		} else if (i == 3)
			text[4] = '\0';
	}

	return BString(text);
}


void
MessageView::SetTo(BMessage& message)
{
	// TODO: when we have a real column list/tree view, redo this using
	// it with nice editors as well.

	fTextView->SetText("");

	char text[512];
	snprintf(text, sizeof(text), B_TRANSLATE_COMMENT("what: '%.4s'\n\n",
		"'What' is a message specifier that defines the type of the message."),
		(char*)&message.what);
	fTextView->Insert(text);

	type_code type;
	int32 count;
	char* name;
	for (int32 i = 0; message.GetInfo(B_ANY_TYPE, i, &name, &type, &count)
			== B_OK; i++) {
		snprintf(text, sizeof(text), "%s\t", _TypeToString(type).String());
		fTextView->Insert(text);

		text_run_array array;
		array.count = 1;
		array.runs[0].offset = 0;
		array.runs[0].font.SetFace(B_BOLD_FACE);
		array.runs[0].color = (rgb_color){0, 0, 0, 255};

		fTextView->Insert(name, &array);

		array.runs[0].font = be_plain_font;
		fTextView->Insert("\n", &array);

		for (int32 j = 0; j < count; j++) {
			const char* data;
			ssize_t size;
			if (message.FindData(name, type, j, (const void**)&data, &size)
					!= B_OK)
				continue;

			text[0] = '\0';

			switch (type) {
				case B_INT64_TYPE:
					snprintf(text, sizeof(text), "%" B_PRId64, *(int64*)data);
					break;
				case B_UINT64_TYPE:
					snprintf(text, sizeof(text), "%" B_PRIu64, *(uint64*)data);
					break;
				case B_INT32_TYPE:
					snprintf(text, sizeof(text), "%" B_PRId32, *(int32*)data);
					break;
				case B_UINT32_TYPE:
					snprintf(text, sizeof(text), "%" B_PRIu32, *(uint32*)data);
					break;
				case B_BOOL_TYPE:
					if (*(uint8*)data)
						strcpy(text, "true");
					else
						strcpy(text, "false");
					break;
				case B_STRING_TYPE:
				case B_MIME_STRING_TYPE:
				{
					snprintf(text, sizeof(text), "%s", data);
					break;
				}
			}

			if (text[0]) {
				fTextView->Insert("\t\t");
				if (count > 1) {
					char index[16];
					snprintf(index, sizeof(index), "%" B_PRId32 ".\t", j);
					fTextView->Insert(index);
				}
				fTextView->Insert(text);
				fTextView->Insert("\n");
			}
		}
	}
}


void
MessageView::_UpdateMessage()
{
	BAutolock locker(fEditor);

	size_t viewSize = fEditor.ViewSize();
	// that may need some more memory...
	if ((off_t)viewSize < fEditor.FileSize())
		fEditor.SetViewSize(fEditor.FileSize());

	const char *buffer;
	if (fEditor.GetViewBuffer((const uint8 **)&buffer) == B_OK) {
		BMessage message;
		message.Unflatten(buffer);
		SetTo(message);
	}

	// restore old view size
	fEditor.SetViewSize(viewSize);
}


void
MessageView::AttachedToWindow()
{
	fEditor.StartWatching(this);

	_UpdateMessage();
}


void
MessageView::DetachedFromWindow()
{
	fEditor.StopWatching(this);
}


void
MessageView::MessageReceived(BMessage* message)
{
	BView::MessageReceived(message);
}


//	#pragma mark -


TypeEditorView*
GetTypeEditorFor(DataEditor& editor)
{
	switch (editor.Type()) {
		case B_STRING_TYPE:
			return new StringEditor(editor);
		case B_MIME_STRING_TYPE:
			return new MimeTypeEditor(editor);
		case B_BOOL_TYPE:
			return new BooleanEditor(editor);
		case B_INT8_TYPE:
		case B_UINT8_TYPE:
		case B_INT16_TYPE:
		case B_UINT16_TYPE:
		case B_INT32_TYPE:
		case B_UINT32_TYPE:
		case B_INT64_TYPE:
		case B_UINT64_TYPE:
		case B_FLOAT_TYPE:
		case B_DOUBLE_TYPE:
		case B_SSIZE_T_TYPE:
		case B_SIZE_T_TYPE:
		case B_OFF_T_TYPE:
		case B_POINTER_TYPE:
			return new NumberEditor(editor);
		case B_MESSAGE_TYPE:
			// TODO: check for archived bitmaps!!!
			return new MessageView(editor);
		case B_MINI_ICON_TYPE:
		case B_LARGE_ICON_TYPE:
		case B_PNG_FORMAT:
		case B_VECTOR_ICON_TYPE:
			return new ImageView(editor);
	}

	return NULL;
}


status_t
GetNthTypeEditor(int32 index, const char** _name)
{
	static const char* kEditors[] = {
		B_TRANSLATE_COMMENT("Text", "This is the type of editor"),
		B_TRANSLATE_COMMENT("Number", "This is the type of editor"),
		B_TRANSLATE_COMMENT("Boolean", "This is the type of editor"),
		B_TRANSLATE_COMMENT("Message", "This is the type of view"),
		B_TRANSLATE_COMMENT("Image", "This is the type of view")
	};

	if (index < 0 || index >= int32(sizeof(kEditors) / sizeof(kEditors[0])))
		return B_BAD_VALUE;

	*_name = kEditors[index];
	return B_OK;
}


TypeEditorView*
GetTypeEditorAt(int32 index, DataEditor& editor)
{
	TypeEditorView* view = NULL;

	switch (index) {
		case 0:
			view = new StringEditor(editor);
			break;
		case 1:
			view = new NumberEditor(editor);
			break;
		case 2:
			view = new BooleanEditor(editor);
			break;
		case 3:
			view = new MessageView(editor);
			break;
		case 4:
			view = new ImageView(editor);
			break;

		default:
			return NULL;
	}

	if (view == NULL)
		return NULL;

	if (!view->TypeMatches()) {
		delete view;
		return NULL;
	}

	return view;
}