/*
 * Copyright 2001-2015, Haiku, Inc.
 * Copyright 2003-2004 Kian Duffy, myob@users.sourceforge.net
 * Parts Copyright 1998-1999 Kazuho Okui and Takashi Murai.
 * All rights reserved. Distributed under the terms of the MIT license.
 */


#include "AppearPrefView.h"

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

#include <Button.h>
#include <Catalog.h>
#include <CharacterSet.h>
#include <CharacterSetRoster.h>
#include <CheckBox.h>
#include <ColorControl.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Menu.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <TextControl.h>
#include <View.h>

#include "Colors.h"
#include "Globals.h"
#include "PrefHandler.h"
#include "TermConst.h"
#include "TermWindow.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Terminal AppearancePrefView"



// #pragma mark -


AppearancePrefView::AppearancePrefView(const char* name,
		const BMessenger& messenger)
	:
	BGroupView(name, B_VERTICAL, 5),
	fTerminalMessenger(messenger)
{
	const char* kColorTable[] = {
		B_TRANSLATE_MARK("Text"),
		B_TRANSLATE_MARK("Background"),
		B_TRANSLATE_MARK("Cursor"),
		B_TRANSLATE_MARK("Text under cursor"),
		B_TRANSLATE_MARK("Selected text"),
		B_TRANSLATE_MARK("Selected background"),
		"",
		B_TRANSLATE_MARK("ANSI black color"),
		B_TRANSLATE_MARK("ANSI red color"),
		B_TRANSLATE_MARK("ANSI green color"),
		B_TRANSLATE_MARK("ANSI yellow color"),
		B_TRANSLATE_MARK("ANSI blue color"),
		B_TRANSLATE_MARK("ANSI magenta color"),
		B_TRANSLATE_MARK("ANSI cyan color"),
		B_TRANSLATE_MARK("ANSI white color"),
		"",
		B_TRANSLATE_MARK("ANSI bright black color"),
		B_TRANSLATE_MARK("ANSI bright red color"),
		B_TRANSLATE_MARK("ANSI bright green color"),
		B_TRANSLATE_MARK("ANSI bright yellow color"),
		B_TRANSLATE_MARK("ANSI bright blue color"),
		B_TRANSLATE_MARK("ANSI bright magenta color"),
		B_TRANSLATE_MARK("ANSI bright cyan color"),
		B_TRANSLATE_MARK("ANSI bright white color"),
		NULL
	};

	fBlinkCursor = new BCheckBox(
		B_TRANSLATE("Blinking cursor"),
			new BMessage(MSG_BLINK_CURSOR_CHANGED));

	fAllowBold = new BCheckBox(
		B_TRANSLATE("Allow bold text"),
			new BMessage(MSG_ALLOW_BOLD_CHANGED));

	fUseOptionAsMetaKey = new BCheckBox(
		B_TRANSLATE("Use left Option as Meta key"),
			new BMessage(MSG_USE_OPTION_AS_META_CHANGED));

	fWarnOnExit = new BCheckBox(
		B_TRANSLATE("Confirm exit if active programs exist"),
			new BMessage(MSG_WARN_ON_EXIT_CHANGED));

	BMenu* fontMenu = _MakeFontMenu(MSG_HALF_FONT_CHANGED,
		PrefHandler::Default()->getString(PREF_HALF_FONT_FAMILY),
		PrefHandler::Default()->getString(PREF_HALF_FONT_STYLE));
	fFontField = new BMenuField(B_TRANSLATE("Font:"), fontMenu);

	BMenu* sizeMenu = new (std::nothrow) BPopUpMenu(
		B_TRANSLATE_COMMENT("Custom", "Window size"));
	if (sizeMenu != NULL) {
		TermWindow::MakeWindowSizeMenu(sizeMenu);
		sizeMenu->SetLabelFromMarked(true);
	}
	fWindowSizeField = new BMenuField(B_TRANSLATE("Window size:"), sizeMenu);

	BMenu* encodingMenu = new (std::nothrow) BPopUpMenu("Text encoding");
	if (encodingMenu != NULL) {
		TermWindow::MakeEncodingMenu(encodingMenu);
		encodingMenu->SetLabelFromMarked(true);
	}
	fEncodingField = new BMenuField(B_TRANSLATE("Encoding:"), encodingMenu);

	BPopUpMenu* schemesPopUp = _MakeColorSchemeMenu(MSG_COLOR_SCHEME_CHANGED,
		gPredefinedColorSchemes, gPredefinedColorSchemes[0]);
	fColorSchemeField = new BMenuField(B_TRANSLATE("Color scheme:"),
		schemesPopUp);

	BPopUpMenu* colorsPopUp = _MakeMenu(MSG_COLOR_FIELD_CHANGED, kColorTable,
		kColorTable[0]);

	fColorField = new BMenuField(B_TRANSLATE("Color:"), colorsPopUp);

	fTabTitle = new BTextControl("tabTitle", B_TRANSLATE("Tab title:"), "",
		NULL);
	fTabTitle->SetModificationMessage(
		new BMessage(MSG_TAB_TITLE_SETTING_CHANGED));
	fTabTitle->SetToolTip(BString(B_TRANSLATE(
		"The pattern specifying the tab titles. The following placeholders\n"
		"can be used:")) << "\n" << kToolTipSetTabTitlePlaceholders
		<< "\n" << kToolTipCommonTitlePlaceholders);

	fWindowTitle = new BTextControl("windowTitle", B_TRANSLATE("Window title:"),
		"", NULL);
	fWindowTitle->SetModificationMessage(
		new BMessage(MSG_WINDOW_TITLE_SETTING_CHANGED));
	fWindowTitle->SetToolTip(BString(B_TRANSLATE(
		"The pattern specifying the window titles. The following placeholders\n"
		"can be used:")) << "\n" << kToolTipSetWindowTitlePlaceholders
		<< "\n" << kToolTipCommonTitlePlaceholders);

	BLayoutBuilder::Group<>(this)
		.SetInsets(5, 5, 5, 5)
		.AddGrid(5, 5)
			.Add(fTabTitle->CreateLabelLayoutItem(), 0, 0)
			.Add(fTabTitle->CreateTextViewLayoutItem(), 1, 0)
			.Add(fWindowTitle->CreateLabelLayoutItem(), 0, 1)
			.Add(fWindowTitle->CreateTextViewLayoutItem(), 1, 1)
			.Add(fWindowSizeField->CreateLabelLayoutItem(), 0, 2)
			.Add(fWindowSizeField->CreateMenuBarLayoutItem(), 1, 2)
			.Add(fFontField->CreateLabelLayoutItem(), 0, 3)
			.Add(fFontField->CreateMenuBarLayoutItem(), 1, 3)
			.Add(fEncodingField->CreateLabelLayoutItem(), 0, 4)
			.Add(fEncodingField->CreateMenuBarLayoutItem(), 1, 4)
			.Add(fColorSchemeField->CreateLabelLayoutItem(), 0, 5)
			.Add(fColorSchemeField->CreateMenuBarLayoutItem(), 1, 5)
			.Add(fColorField->CreateLabelLayoutItem(), 0, 6)
			.Add(fColorField->CreateMenuBarLayoutItem(), 1, 6)
			.End()
		.AddGlue()
		.Add(fColorControl = new BColorControl(BPoint(10, 10),
			B_CELLS_32x8, 8.0, "", new BMessage(MSG_COLOR_CHANGED)))
		.Add(fBlinkCursor)
		.Add(fAllowBold)
		.Add(fUseOptionAsMetaKey)
		.Add(fWarnOnExit);

	fTabTitle->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
	fWindowTitle->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
	fFontField->SetAlignment(B_ALIGN_RIGHT);
	fWindowSizeField->SetAlignment(B_ALIGN_RIGHT);
	fEncodingField->SetAlignment(B_ALIGN_RIGHT);
	fColorField->SetAlignment(B_ALIGN_RIGHT);
	fColorSchemeField->SetAlignment(B_ALIGN_RIGHT);

	Revert();

	BTextControl* redInput = (BTextControl*)fColorControl->ChildAt(0);
	BTextControl* greenInput = (BTextControl*)fColorControl->ChildAt(1);
	BTextControl* blueInput = (BTextControl*)fColorControl->ChildAt(2);

	redInput->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
	greenInput->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
	blueInput->SetAlignment(B_ALIGN_RIGHT, B_ALIGN_LEFT);
}


void
AppearancePrefView::Revert()
{
	PrefHandler* pref = PrefHandler::Default();

	fTabTitle->SetText(pref->getString(PREF_TAB_TITLE));
	fWindowTitle->SetText(pref->getString(PREF_WINDOW_TITLE));

	fBlinkCursor->SetValue(pref->getBool(PREF_BLINK_CURSOR));
	fAllowBold->SetValue(pref->getBool(PREF_ALLOW_BOLD));
	fUseOptionAsMetaKey->SetValue(pref->getBool(PREF_USE_OPTION_AS_META));
	fWarnOnExit->SetValue(pref->getBool(PREF_WARN_ON_EXIT));

	_SetCurrentColorScheme();
	_SetEncoding(pref->getString(PREF_TEXT_ENCODING));
	_SetWindowSize(pref->getInt32(PREF_ROWS), pref->getInt32(PREF_COLS));
	fColorControl->SetValue(pref->getRGB(PREF_TEXT_FORE_COLOR));

	const char* family = pref->getString(PREF_HALF_FONT_FAMILY);
	const char* style = pref->getString(PREF_HALF_FONT_STYLE);
	const char* size = pref->getString(PREF_HALF_FONT_SIZE);

	_MarkSelectedFont(family, style, size);
}


void
AppearancePrefView::AttachedToWindow()
{
	fTabTitle->SetTarget(this);
	fWindowTitle->SetTarget(this);
	fBlinkCursor->SetTarget(this);
	fAllowBold->SetTarget(this);
	fUseOptionAsMetaKey->SetTarget(this);
	fWarnOnExit->SetTarget(this);

	fFontField->Menu()->SetTargetForItems(this);
	for (int32 i = 0; i < fFontField->Menu()->CountItems(); i++) {
		BMenu* fontSizeMenu = fFontField->Menu()->SubmenuAt(i);
		if (fontSizeMenu == NULL)
			continue;

		fontSizeMenu->SetTargetForItems(this);
	}

	fColorControl->SetTarget(this);
	fColorField->Menu()->SetTargetForItems(this);
	fColorSchemeField->Menu()->SetTargetForItems(this);
	fWindowSizeField->Menu()->SetTargetForItems(this);
	fEncodingField->Menu()->SetTargetForItems(this);

	_SetCurrentColorScheme();
}


void

AppearancePrefView::MessageReceived(BMessage* msg)
{
	bool modified = false;

	switch (msg->what) {
		case MSG_HALF_FONT_CHANGED:
		{
			const char* family = NULL;
			const char* style = NULL;
			const char* size = NULL;
			if (msg->FindString("font_family", &family) != B_OK
				|| msg->FindString("font_style", &style) != B_OK
				|| msg->FindString("font_size", &size) != B_OK) {
				break;
			}

			PrefHandler* pref = PrefHandler::Default();
			const char* currentFamily
				= pref->getString(PREF_HALF_FONT_FAMILY);
			const char* currentStyle
				= pref->getString(PREF_HALF_FONT_STYLE);
			const char* currentSize
				= pref->getString(PREF_HALF_FONT_SIZE);

			if (currentFamily == NULL || strcmp(currentFamily, family) != 0
				|| currentStyle == NULL || strcmp(currentStyle, style) != 0
				|| currentSize == NULL || strcmp(currentSize, size) != 0) {
				pref->setString(PREF_HALF_FONT_FAMILY, family);
				pref->setString(PREF_HALF_FONT_STYLE, style);
				pref->setString(PREF_HALF_FONT_SIZE, size);
				_MarkSelectedFont(family, style, size);
				modified = true;
			}
			break;
		}

		case MSG_COLOR_CHANGED:
		{
			const BMessage* itemMessage
				= fColorField->Menu()->FindMarked()->Message();
			const char* label = NULL;
			if (itemMessage->FindString("label", &label) != B_OK)
				break;
			rgb_color oldColor = PrefHandler::Default()->getRGB(label);
			if (oldColor != fColorControl->ValueAsColor()) {
				BMenuItem* item = fColorSchemeField->Menu()->FindMarked();
				if (strcmp(item->Label(), gCustomColorScheme.name) != 0) {
					item->SetMarked(false);
					item = fColorSchemeField->Menu()->FindItem(
						gCustomColorScheme.name);
					if (item)
						item->SetMarked(true);
				}

				PrefHandler::Default()->setRGB(label,
					fColorControl->ValueAsColor());
				modified = true;
			}
			break;
		}

		case MSG_COLOR_SCHEME_CHANGED:
		{
			color_scheme* newScheme = NULL;
			if (msg->FindPointer("color_scheme",
					(void**)&newScheme) == B_OK) {
				_ChangeColorScheme(newScheme);
				const char* label = NULL;
				if (fColorField->Menu()->FindMarked()->Message()->FindString(
						"label", &label) == B_OK)
					fColorControl->SetValue(
						PrefHandler::Default()->getRGB(label));
				modified = true;
			}
			break;
		}

		case MSG_COLOR_FIELD_CHANGED:
		{
			const char* label = NULL;
			if (msg->FindString("label", &label) == B_OK)
				fColorControl->SetValue(PrefHandler::Default()->getRGB(label));
			break;
		}

		case MSG_COLS_CHANGED:
		{
			int rows = msg->FindInt32("rows");
			int columns = msg->FindInt32("columns");
			_SetWindowSize(rows, columns);
			PrefHandler* handler = PrefHandler::Default();
			if (handler->getInt32(PREF_ROWS) != rows) {
				PrefHandler::Default()->setInt32(PREF_ROWS, rows);
				modified = true;
			}
			if (handler->getInt32(PREF_COLS) != columns) {
				PrefHandler::Default()->setInt32(PREF_COLS, columns);
				modified = true;
			}

			break;
		}

		case MSG_BLINK_CURSOR_CHANGED:
			if (PrefHandler::Default()->getBool(PREF_BLINK_CURSOR)
				!= fBlinkCursor->Value()) {
					PrefHandler::Default()->setBool(PREF_BLINK_CURSOR,
						fBlinkCursor->Value());
					modified = true;
			}
			break;

		case MSG_ALLOW_BOLD_CHANGED:
			if (PrefHandler::Default()->getBool(PREF_ALLOW_BOLD)
				!= fAllowBold->Value()) {
					PrefHandler::Default()->setBool(PREF_ALLOW_BOLD,
						fAllowBold->Value());
					modified = true;
			}
			break;

		case MSG_USE_OPTION_AS_META_CHANGED:
			if (PrefHandler::Default()->getBool(PREF_USE_OPTION_AS_META)
				!= fUseOptionAsMetaKey->Value()) {
					PrefHandler::Default()->setBool(PREF_USE_OPTION_AS_META,
						fUseOptionAsMetaKey->Value());
					modified = true;
			}
			break;

		case MSG_WARN_ON_EXIT_CHANGED:
			if (PrefHandler::Default()->getBool(PREF_WARN_ON_EXIT)
				!= fWarnOnExit->Value()) {
					PrefHandler::Default()->setBool(PREF_WARN_ON_EXIT,
						fWarnOnExit->Value());
					modified = true;
			}
			break;

		case MSG_TAB_TITLE_SETTING_CHANGED:
		{
			BString oldValue(PrefHandler::Default()->getString(PREF_TAB_TITLE));
			if (oldValue != fTabTitle->Text()) {
				PrefHandler::Default()->setString(PREF_TAB_TITLE,
					fTabTitle->Text());
				modified = true;
			}
			break;
		}

		case MSG_WINDOW_TITLE_SETTING_CHANGED:
		{
			BString oldValue(PrefHandler::Default()->getString(
				PREF_WINDOW_TITLE));
			if (oldValue != fWindowTitle->Text()) {
				PrefHandler::Default()->setString(PREF_WINDOW_TITLE,
					fWindowTitle->Text());
				modified = true;
			}
			break;
		}

		default:
			BView::MessageReceived(msg);
			return;
	}

	if (modified) {
		fTerminalMessenger.SendMessage(msg);

		BMessenger messenger(this);
		messenger.SendMessage(MSG_PREF_MODIFIED);
	}
}


void
AppearancePrefView::_ChangeColorScheme(color_scheme* scheme)
{
	PrefHandler* pref = PrefHandler::Default();

	pref->setRGB(PREF_TEXT_FORE_COLOR, scheme->text_fore_color);
	pref->setRGB(PREF_TEXT_BACK_COLOR, scheme->text_back_color);
	pref->setRGB(PREF_SELECT_FORE_COLOR, scheme->select_fore_color);
	pref->setRGB(PREF_SELECT_BACK_COLOR, scheme->select_back_color);
	pref->setRGB(PREF_CURSOR_FORE_COLOR, scheme->cursor_fore_color);
	pref->setRGB(PREF_CURSOR_BACK_COLOR, scheme->cursor_back_color);
	pref->setRGB(PREF_ANSI_BLACK_COLOR, scheme->ansi_colors.black);
	pref->setRGB(PREF_ANSI_RED_COLOR, scheme->ansi_colors.red);
	pref->setRGB(PREF_ANSI_GREEN_COLOR, scheme->ansi_colors.green);
	pref->setRGB(PREF_ANSI_YELLOW_COLOR, scheme->ansi_colors.yellow);
	pref->setRGB(PREF_ANSI_BLUE_COLOR, scheme->ansi_colors.blue);
	pref->setRGB(PREF_ANSI_MAGENTA_COLOR, scheme->ansi_colors.magenta);
	pref->setRGB(PREF_ANSI_CYAN_COLOR, scheme->ansi_colors.cyan);
	pref->setRGB(PREF_ANSI_WHITE_COLOR, scheme->ansi_colors.white);
	pref->setRGB(PREF_ANSI_BLACK_HCOLOR, scheme->ansi_colors_h.black);
	pref->setRGB(PREF_ANSI_RED_HCOLOR, scheme->ansi_colors_h.red);
	pref->setRGB(PREF_ANSI_GREEN_HCOLOR, scheme->ansi_colors_h.green);
	pref->setRGB(PREF_ANSI_YELLOW_HCOLOR, scheme->ansi_colors_h.yellow);
	pref->setRGB(PREF_ANSI_BLUE_HCOLOR, scheme->ansi_colors_h.blue);
	pref->setRGB(PREF_ANSI_MAGENTA_HCOLOR, scheme->ansi_colors_h.magenta);
	pref->setRGB(PREF_ANSI_CYAN_HCOLOR, scheme->ansi_colors_h.cyan);
	pref->setRGB(PREF_ANSI_WHITE_HCOLOR, scheme->ansi_colors_h.white);
}


void
AppearancePrefView::_SetCurrentColorScheme()
{
	PrefHandler* pref = PrefHandler::Default();

	gCustomColorScheme.text_fore_color = pref->getRGB(PREF_TEXT_FORE_COLOR);
	gCustomColorScheme.text_back_color = pref->getRGB(PREF_TEXT_BACK_COLOR);
	gCustomColorScheme.select_fore_color = pref->getRGB(PREF_SELECT_FORE_COLOR);
	gCustomColorScheme.select_back_color = pref->getRGB(PREF_SELECT_BACK_COLOR);
	gCustomColorScheme.cursor_fore_color = pref->getRGB(PREF_CURSOR_FORE_COLOR);
	gCustomColorScheme.cursor_back_color = pref->getRGB(PREF_CURSOR_BACK_COLOR);
	gCustomColorScheme.ansi_colors.black = pref->getRGB(PREF_ANSI_BLACK_COLOR);
	gCustomColorScheme.ansi_colors.red = pref->getRGB(PREF_ANSI_RED_COLOR);
	gCustomColorScheme.ansi_colors.green = pref->getRGB(PREF_ANSI_GREEN_COLOR);
	gCustomColorScheme.ansi_colors.yellow = pref->getRGB(PREF_ANSI_YELLOW_COLOR);
	gCustomColorScheme.ansi_colors.blue = pref->getRGB(PREF_ANSI_BLUE_COLOR);
	gCustomColorScheme.ansi_colors.magenta =
		pref->getRGB(PREF_ANSI_MAGENTA_COLOR);
	gCustomColorScheme.ansi_colors.cyan = pref->getRGB(PREF_ANSI_CYAN_COLOR);
	gCustomColorScheme.ansi_colors.white = pref->getRGB(PREF_ANSI_WHITE_COLOR);
	gCustomColorScheme.ansi_colors_h.black = pref->getRGB(PREF_ANSI_BLACK_HCOLOR);
	gCustomColorScheme.ansi_colors_h.red = pref->getRGB(PREF_ANSI_RED_HCOLOR);
	gCustomColorScheme.ansi_colors_h.green = pref->getRGB(PREF_ANSI_GREEN_HCOLOR);
	gCustomColorScheme.ansi_colors_h.yellow =
		pref->getRGB(PREF_ANSI_YELLOW_HCOLOR);
	gCustomColorScheme.ansi_colors_h.blue = pref->getRGB(PREF_ANSI_BLUE_HCOLOR);
	gCustomColorScheme.ansi_colors_h.magenta =
		pref->getRGB(PREF_ANSI_MAGENTA_HCOLOR);
	gCustomColorScheme.ansi_colors_h.cyan = pref->getRGB(PREF_ANSI_CYAN_HCOLOR);
	gCustomColorScheme.ansi_colors_h.white = pref->getRGB(PREF_ANSI_WHITE_HCOLOR);

	const char* currentSchemeName = NULL;

	for (const color_scheme** schemes = gPredefinedColorSchemes;
			*schemes != NULL; schemes++) {
		if (gCustomColorScheme == **schemes) {
			currentSchemeName = (*schemes)->name;
			break;
		}
	}

	// If the scheme is not one of the known ones, assume a custom one.
	if (currentSchemeName == NULL)
		currentSchemeName = "Custom";

	for (int32 i = 0; i < fColorSchemeField->Menu()->CountItems(); i++) {
		BMenuItem* item = fColorSchemeField->Menu()->ItemAt(i);
		if (strcmp(item->Label(), currentSchemeName) == 0) {
			item->SetMarked(true);
			break;
		}
	}
}


void
AppearancePrefView::_SetEncoding(const char* name)
{
	const BPrivate::BCharacterSet* charset
		= BPrivate::BCharacterSetRoster::FindCharacterSetByName(name);
	if (charset == NULL)
		return;
	int code = charset->GetConversionID();
	for (int32 i = 0; i < fEncodingField->Menu()->CountItems(); i++) {
		BMenuItem* item = fEncodingField->Menu()->ItemAt(i);
		BMessage* msg = item->Message();
		if (msg->FindInt32("op") == code) {
			item->SetMarked(true);
			break;
		}
	}
}


void
AppearancePrefView::_SetWindowSize(int rows, int cols)
{
	for (int32 i = 0; i < fWindowSizeField->Menu()->CountItems(); i++) {
		BMenuItem* item = fWindowSizeField->Menu()->ItemAt(i);
		BMessage* msg = item->Message();
		if (msg->FindInt32("rows") == rows && msg->FindInt32("columns") == cols) {
			item->SetMarked(true);
			break;
		}
	}
}


/*static*/ BMenu*
AppearancePrefView::_MakeFontMenu(uint32 command,
	const char* defaultFamily, const char* defaultStyle)
{
	BPopUpMenu* menu = new BPopUpMenu("");
	int32 numFamilies = count_font_families();
	for (int32 i = 0; i < numFamilies; i++) {
		font_family family;
		uint32 flags;
		if (get_font_family(i, &family, &flags) == B_OK) {
			BFont font;
			font_style style;
			int32 numStyles = count_font_styles(family);
			for (int32 j = 0; j < numStyles; j++) {
				if (get_font_style(family, j, &style) == B_OK) {
					font.SetFamilyAndStyle(family, style);
					if (IsFontUsable(font)) {
						BMessage* message = new BMessage(command);
						const char* size
							= PrefHandler::Default()->getString(PREF_HALF_FONT_SIZE);
						message->AddString("font_family", family);
						message->AddString("font_style", style);
						message->AddString("font_size", size);
						char fontMenuLabel[134];
						snprintf(fontMenuLabel, sizeof(fontMenuLabel),
							"%s - %s", family, style);
						BMenu* fontSizeMenu = _MakeFontSizeMenu(fontMenuLabel,
							MSG_HALF_FONT_CHANGED, family, style, size);
						BMenuItem* item = new BMenuItem(fontSizeMenu, message);
						menu->AddItem(item);
						if (strcmp(defaultFamily, family) == 0
							&& strcmp(defaultStyle, style) == 0)
							item->SetMarked(true);
					}
				}
			}
		}
	}

	if (menu->FindMarked() == NULL)
		menu->ItemAt(0)->SetMarked(true);

	return menu;
}


/*static*/ BMenu*
AppearancePrefView::_MakeFontSizeMenu(const char* label, uint32 command,
	const char* family, const char* style, const char* size)
{
	BMenu* menu = new BMenu(label);
	menu->SetRadioMode(true);
	menu->SetLabelFromMarked(false);

	int32 sizes[] = {
		8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 28, 32, 36, 0
	};

	bool found = false;

	for (uint32 i = 0; sizes[i]; i++) {
		BString fontSize;
		fontSize << sizes[i];
		BMessage* message = new BMessage(command);
		message->AddString("font_family", family);
		message->AddString("font_style", style);
		message->AddString("font_size", fontSize.String());
		BMenuItem* item = new BMenuItem(fontSize.String(), message);
		menu->AddItem(item);
		if (sizes[i] == atoi(size)) {
			item->SetMarked(true);
			found = true;
		}
	}

	if (!found) {
		for (uint32 i = 0; sizes[i]; i++) {
			if (sizes[i] > atoi(size)) {
				BMessage* message = new BMessage(command);
				message->AddString("font_family", family);
				message->AddString("font_style", style);
				message->AddString("font_size", size);
				BMenuItem* item = new BMenuItem(size, message);
				item->SetMarked(true);
				menu->AddItem(item, i);
				break;
			}
		}
	}

	return menu;
}


/*static*/ BPopUpMenu*
AppearancePrefView::_MakeMenu(uint32 msg, const char** items,
	const char* defaultItemName)
{
	BPopUpMenu* menu = new BPopUpMenu("");

	while (*items) {
		if (strcmp((*items), "") == 0)
			menu->AddSeparatorItem();
		else {
			BMessage* message = new BMessage(msg);
			message->AddString("label", *items);
			BMenuItem* item = new BMenuItem(B_TRANSLATE(*items), message);
			menu->AddItem(item);
			if (strcmp(*items, defaultItemName) == 0)
				item->SetMarked(true);
		}

		items++;
	}

	return menu;
}


/*static*/ BPopUpMenu*
AppearancePrefView::_MakeColorSchemeMenu(uint32 msg, const color_scheme** items,
	const color_scheme* defaultItemName)
{
	BPopUpMenu* menu = new BPopUpMenu("");

	int32 i = 0;
	while (*items) {
		if (strcmp((*items)->name, "") == 0)
			menu->AddSeparatorItem();
		else {
			BMessage* message = new BMessage(msg);
			message->AddPointer("color_scheme", (const void*)*items);
			menu->AddItem(new BMenuItem((*items)->name, message));
		}

		items++;
		i++;
	}
	return menu;
}


void
AppearancePrefView::_MarkSelectedFont(const char* family, const char* style,
	const char* size)
{
	char fontMenuLabel[134];
	snprintf(fontMenuLabel, sizeof(fontMenuLabel), "%s - %s", family, style);

	// mark the selected font
	BMenuItem* selectedFont = fFontField->Menu()->FindItem(fontMenuLabel);
	if (selectedFont != NULL)
		selectedFont->SetMarked(true);

	// mark the selected font size on all font menus
	for (int32 i = 0; i < fFontField->Menu()->CountItems(); i++) {
		BMenu* fontSizeMenu = fFontField->Menu()->SubmenuAt(i);
		if (fontSizeMenu == NULL)
			continue;

		BMenuItem* item = fontSizeMenu->FindItem(size);
		if (item != NULL)
			item->SetMarked(true);
	}
}