haiku.git

/*
 * Copyright 2006-2013, Haiku, Inc. All rights reserved.
 * Copyright 1997, 1998 R3 Software Ltd. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus, superstippi@gmx.de
 *		Philippe Saint-Pierre, stpere@gmail.com
 *		John Scipione, jscipione@gmail.com
 *		Timothy Wayper, timmy@wunderbear.com
 */


#include "CalcView.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>

#include <AboutWindow.h>
#include <Alert.h>
#include <Application.h>
#include <AppFileInfo.h>
#include <AutoLocker.h>
#include <Beep.h>
#include <Bitmap.h>
#include <Catalog.h>
#include <ControlLook.h>
#include <Clipboard.h>
#include <File.h>
#include <Font.h>
#include <Locale.h>
#include <MenuItem.h>
#include <Message.h>
#include <MessageRunner.h>
#include <NumberFormat.h>
#include <Point.h>
#include <PopUpMenu.h>
#include <Region.h>
#include <Roster.h>

#include <ExpressionParser.h>

#include "CalcApplication.h"
#include "CalcOptions.h"
#include "ExpressionTextView.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "CalcView"


static const int32 kMsgCalculating = 'calc';
static const int32 kMsgAnimateDots = 'dots';
static const int32 kMsgDoneEvaluating = 'done';

//const uint8 K_COLOR_OFFSET				= 32;
const float kFontScaleY						= 0.4f;
const float kFontScaleX						= 0.4f;
const float kExpressionFontScaleY			= 0.6f;
const float kDisplayScaleY					= 0.2f;

static const bigtime_t kFlashOnOffInterval	= 100000;
static const bigtime_t kCalculatingInterval	= 1000000;
static const bigtime_t kAnimationInterval	= 333333;

static const float kMinimumWidthCompact		= 130.0f;
static const float kMaximumWidthCompact		= 400.0f;
static const float kMinimumHeightCompact	= 20.0f;
static const float kMaximumHeightCompact	= 60.0f;

// Basic mode size limits are defined in CalcView.h so
// that they can be used by the CalcWindow constructor.

static const float kMinimumWidthScientific	= 240.0f;
static const float kMaximumWidthScientific	= 400.0f;
static const float kMinimumHeightScientific	= 200.0f;
static const float kMaximumHeightScientific	= 400.0f;

// basic mode keypad layout (default)
const char *kKeypadDescriptionBasic[] = {
	B_TRANSLATE_MARK("7"),
	B_TRANSLATE_MARK("8"),
	B_TRANSLATE_MARK("9"),
	B_TRANSLATE_MARK("("),
	B_TRANSLATE_MARK(")"),
	"\n",
	B_TRANSLATE_MARK("4"),
	B_TRANSLATE_MARK("5"),
	B_TRANSLATE_MARK("6"),
	B_TRANSLATE_MARK("*"),
	B_TRANSLATE_MARK("/"),
	"\n",
	B_TRANSLATE_MARK("1"),
	B_TRANSLATE_MARK("2"),
	B_TRANSLATE_MARK("3"),
	B_TRANSLATE_MARK("+"),
	B_TRANSLATE_MARK("-"),
	"\n",
	B_TRANSLATE_MARK("0"),
	B_TRANSLATE_MARK("."),
	B_TRANSLATE_MARK("BS"),
	B_TRANSLATE_MARK("="),
	B_TRANSLATE_MARK("C"),
	"\n",
	NULL
};

// scientific mode keypad layout
const char *kKeypadDescriptionScientific[] = {
	B_TRANSLATE_MARK("ln"),
	B_TRANSLATE_MARK("sin"),
	B_TRANSLATE_MARK("cos"),
	B_TRANSLATE_MARK("tan"),
	B_TRANSLATE_MARK("π"),
	"\n",
	B_TRANSLATE_MARK("log"),
	B_TRANSLATE_MARK("asin"),
	B_TRANSLATE_MARK("acos"),
	B_TRANSLATE_MARK("atan"),
	B_TRANSLATE_MARK("sqrt"),
	"\n",
	B_TRANSLATE_MARK("exp"),
	B_TRANSLATE_MARK("sinh"),
	B_TRANSLATE_MARK("cosh"),
	B_TRANSLATE_MARK("tanh"),
	B_TRANSLATE_MARK("cbrt"),
	"\n",
	B_TRANSLATE_MARK("!"),
	B_TRANSLATE_MARK("ceil"),
	B_TRANSLATE_MARK("floor"),
	B_TRANSLATE_MARK("E"),
	B_TRANSLATE_MARK("^"),
	"\n",
	B_TRANSLATE_MARK("7"),
	B_TRANSLATE_MARK("8"),
	B_TRANSLATE_MARK("9"),
	B_TRANSLATE_MARK("("),
	B_TRANSLATE_MARK(")"),
	"\n",
	B_TRANSLATE_MARK("4"),
	B_TRANSLATE_MARK("5"),
	B_TRANSLATE_MARK("6"),
	B_TRANSLATE_MARK("*"),
	B_TRANSLATE_MARK("/"),
	"\n",
	B_TRANSLATE_MARK("1"),
	B_TRANSLATE_MARK("2"),
	B_TRANSLATE_MARK("3"),
	B_TRANSLATE_MARK("+"),
	B_TRANSLATE_MARK("-"),
	"\n",
	B_TRANSLATE_MARK("0"),
	B_TRANSLATE_MARK("."),
	B_TRANSLATE_MARK("BS"),
	B_TRANSLATE_MARK("="),
	B_TRANSLATE_MARK("C"),
	"\n",
	NULL
};


enum {
	FLAGS_FLASH_KEY							= 1 << 0,
	FLAGS_MOUSE_DOWN						= 1 << 1
};


struct CalcView::CalcKey {
	char		label[8];
	char		code[8];
	char		keymap[4];
	uint32		flags;
//	float		width;
};


typedef AutoLocker<BClipboard> ClipboardLocker;


CalcView*
CalcView::Instantiate(BMessage* archive)
{
	if (!validate_instantiation(archive, "CalcView"))
		return NULL;

	return new CalcView(archive);
}


CalcView::CalcView(BRect frame, rgb_color rgbBaseColor, BMessage* settings)
	:
	BView(frame, "DeskCalc", B_FOLLOW_ALL_SIDES, B_WILL_DRAW | B_FRAME_EVENTS),

	fColumns(5),
	fRows(4),

	fBaseColor(rgbBaseColor),
	fHasCustomBaseColor(rgbBaseColor != ui_color(B_PANEL_BACKGROUND_COLOR)),

	fWidth(1),
	fHeight(1),

	fKeypadDescription(kKeypadDescriptionBasic),
	fKeypad(NULL),

	fCalcIcon(new BBitmap(BRect(0, 0, 15, 15), 0, B_RGBA32)),

	fPopUpMenu(NULL),
	fAutoNumlockItem(NULL),
	fOptions(new CalcOptions()),
	fEvaluateThread(-1),
	fEvaluateMessageRunner(NULL),
	fEvaluateSemaphore(B_BAD_SEM_ID),
	fEnabled(true)
{
	// tell the app server not to erase our b/g
	SetViewColor(B_TRANSPARENT_32_BIT);

	_Init(settings);
}


CalcView::CalcView(BMessage* archive)
	:
	BView(archive),

	fColumns(5),
	fRows(4),

	fBaseColor(ui_color(B_PANEL_BACKGROUND_COLOR)),

	fHasCustomBaseColor(false),

	fWidth(1),
	fHeight(1),

	fKeypadDescription(kKeypadDescriptionBasic),
	fKeypad(NULL),

	fCalcIcon(new BBitmap(BRect(0, 0, 15, 15), 0, B_RGBA32)),

	fPopUpMenu(NULL),
	fAutoNumlockItem(NULL),
	fOptions(new CalcOptions()),
	fEvaluateThread(-1),
	fEvaluateMessageRunner(NULL),
	fEvaluateSemaphore(B_BAD_SEM_ID),
	fEnabled(true)
{
	// Do not restore the follow mode, in shelfs, we never follow.
	SetResizingMode(B_FOLLOW_NONE);

	_Init(archive);
}


CalcView::~CalcView()
{
	delete[] fKeypad;
	delete fOptions;
	delete fEvaluateMessageRunner;
	delete_sem(fEvaluateSemaphore);
}


void
CalcView::AttachedToWindow()
{
	if (be_control_look == NULL)
		SetFont(be_bold_font);

	BRect frame(Frame());
	FrameResized(frame.Width(), frame.Height());

	bool addKeypadModeMenuItems = true;
	if (Parent() && (Parent()->Flags() & B_DRAW_ON_CHILDREN) != 0) {
		// don't add these items if we are a replicant on the desktop
		addKeypadModeMenuItems = false;
	}

	// create and attach the pop-up menu
	_CreatePopUpMenu(addKeypadModeMenuItems);

	if (addKeypadModeMenuItems)
		SetKeypadMode(fOptions->keypad_mode);
}


void
CalcView::MessageReceived(BMessage* message)
{
	if (message->what == B_COLORS_UPDATED) {
		const char* panelBgColorName = ui_color_name(B_PANEL_BACKGROUND_COLOR);
		if (message->HasColor(panelBgColorName) && !fHasCustomBaseColor) {
			fBaseColor = message->GetColor(panelBgColorName, fBaseColor);
			_Colorize();
		}
		if (message->HasColor(ui_color_name(B_PANEL_TEXT_COLOR)))
			_Colorize();

		return;
	}

	if (Parent() && (Parent()->Flags() & B_DRAW_ON_CHILDREN) != 0) {
		// if we are embedded in desktop we need to receive these
		// message here since we don't have a parent BWindow
		switch (message->what) {
			case MSG_OPTIONS_AUTO_NUM_LOCK:
				ToggleAutoNumlock();
				return;

			case MSG_OPTIONS_ANGLE_MODE_RADIAN:
				SetDegreeMode(false);
				return;

			case MSG_OPTIONS_ANGLE_MODE_DEGREE:
				SetDegreeMode(true);
				return;
		}
	}

	// check if message was dropped
	if (message->WasDropped()) {
		// pass message on to paste
		if (message->IsSourceRemote())
			Paste(message);
	} else {
		// act on posted message type
		switch (message->what) {

			// handle "cut"
			case B_CUT:
				Cut();
				break;

			// handle copy
			case B_COPY:
				Copy();
				break;

			// handle paste
			case B_PASTE:
			{
				// access system clipboard
				ClipboardLocker locker(be_clipboard);
				if (locker.IsLocked()) {
					BMessage* clipper = be_clipboard->Data();
					if (clipper)
						Paste(clipper);
				}
				break;
			}

			// (replicant) about box requested
			case B_ABOUT_REQUESTED:
			{
				BAboutWindow* window = new BAboutWindow(kAppName, kSignature);

				// create the about window
				const char* extraCopyrights[] = {
					"1997, 1998 R3 Software Ltd.",
					NULL
				};

				const char* authors[] = {
					"Stephan Aßmus",
					"John Scipione",
					"Timothy Wayper",
					"Ingo Weinhold",
					NULL
				};

				window->AddCopyright(2006, "Haiku, Inc.", extraCopyrights);
				window->AddAuthors(authors);

				window->Show();

				break;
			}

			case MSG_UNFLASH_KEY:
			{
				int32 key;
				if (message->FindInt32("key", &key) == B_OK)
					_FlashKey(key, 0);

				break;
			}

			case kMsgAnimateDots:
			{
				int32 end = fExpressionTextView->TextLength();
				int32 start = end - 3;
				if (fEnabled || strcmp(fExpressionTextView->Text() + start,
						"...") != 0) {
					// stop the message runner
					delete fEvaluateMessageRunner;
					fEvaluateMessageRunner = NULL;
					break;
				}

				uint8 dot = 0;
				if (message->FindUInt8("dot", &dot) == B_OK) {
					rgb_color fontColor = fExpressionTextView->HighColor();
					rgb_color backColor = fExpressionTextView->LowColor();
					fExpressionTextView->SetStylable(true);
					fExpressionTextView->SetFontAndColor(start, end, NULL, 0,
						&backColor);
					fExpressionTextView->SetFontAndColor(start + dot - 1,
						start + dot, NULL, 0, &fontColor);
					fExpressionTextView->SetStylable(false);
				}

				dot++;
				if (dot == 4)
					dot = 1;

				delete fEvaluateMessageRunner;
				BMessage animate(kMsgAnimateDots);
				animate.AddUInt8("dot", dot);
				fEvaluateMessageRunner = new (std::nothrow) BMessageRunner(
					BMessenger(this), &animate, kAnimationInterval, 1);
				break;
			}

			case kMsgCalculating:
			{
				// calculation has taken more than 3 seconds
				if (fEnabled) {
					// stop the message runner
					delete fEvaluateMessageRunner;
					fEvaluateMessageRunner = NULL;
					break;
				}

				BString calculating;
				calculating << B_TRANSLATE("Calculating") << "...";
				fExpressionTextView->SetText(calculating.String());

				delete fEvaluateMessageRunner;
				BMessage animate(kMsgAnimateDots);
				animate.AddUInt8("dot", 1U);
				fEvaluateMessageRunner = new (std::nothrow) BMessageRunner(
					BMessenger(this), &animate, kAnimationInterval, 1);
				break;
			}

			case kMsgDoneEvaluating:
			{
				_SetEnabled(true);
				rgb_color fontColor = fExpressionTextView->HighColor();
				fExpressionTextView->SetFontAndColor(NULL, 0, &fontColor);

				const char* result;
				if (message->FindString("error", &result) == B_OK)
					fExpressionTextView->SetText(result);
				else if (message->FindString("value", &result) == B_OK) {
					BLocale locale;
					BNumberFormat format(&locale);

					fExpressionTextView->SetValue(result, format.GetSeparator(B_DECIMAL_SEPARATOR));
				}

				// stop the message runner
				delete fEvaluateMessageRunner;
				fEvaluateMessageRunner = NULL;
				break;
			}

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


void
CalcView::Draw(BRect updateRect)
{
	bool drawBackground = !_IsEmbedded();

	SetHighColor(fBaseColor);
	BRect expressionRect(_ExpressionRect());
	if (updateRect.Intersects(expressionRect)) {
		if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT
			&& expressionRect.Height() >= fCalcIcon->Bounds().Height()) {
			// render calc icon
			expressionRect.left = fExpressionTextView->Frame().right + 2;
			if (drawBackground) {
				SetHighColor(fBaseColor);
				FillRect(updateRect & expressionRect);
			}

			SetDrawingMode(B_OP_ALPHA);
			SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);

			BPoint iconPos;
			iconPos.x = expressionRect.right - (expressionRect.Width()
				+ fCalcIcon->Bounds().Width()) / 2.0;
			iconPos.y = expressionRect.top + (expressionRect.Height()
				- fCalcIcon->Bounds().Height()) / 2.0;
			DrawBitmap(fCalcIcon, iconPos);

			SetDrawingMode(B_OP_COPY);
		}

		// render border around expression text view
		expressionRect = fExpressionTextView->Frame();
		expressionRect.InsetBy(-2, -2);
		if (fOptions->keypad_mode != KEYPAD_MODE_COMPACT && drawBackground) {
			expressionRect.InsetBy(-2, -2);
			StrokeRect(expressionRect);
			expressionRect.InsetBy(1, 1);
			StrokeRect(expressionRect);
			expressionRect.InsetBy(1, 1);
		}

		uint32 flags = 0;
		if (!drawBackground)
			flags |= BControlLook::B_BLEND_FRAME;
		be_control_look->DrawTextControlBorder(this, expressionRect,
			updateRect, fBaseColor, flags);
	}

	if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT)
		return;

	// calculate grid sizes
	BRect keypadRect(_KeypadRect());

	if (be_control_look != NULL) {
		if (drawBackground)
			StrokeRect(keypadRect);
		keypadRect.InsetBy(1, 1);
	}

	float sizeDisp = keypadRect.top;
	float sizeCol = (keypadRect.Width() + 1) / (float)fColumns;
	float sizeRow = (keypadRect.Height() + 1) / (float)fRows;

	if (!updateRect.Intersects(keypadRect))
		return;

	SetFontSize(min_c(sizeRow * kFontScaleY, sizeCol * kFontScaleX));

	CalcKey* key = fKeypad;
	for (int row = 0; row < fRows; row++) {
		for (int col = 0; col < fColumns; col++) {
			BRect frame;
			frame.left = keypadRect.left + col * sizeCol;
			frame.right = keypadRect.left + (col + 1) * sizeCol - 1;
			frame.top = sizeDisp + row * sizeRow;
			frame.bottom = sizeDisp + (row + 1) * sizeRow - 1;

			if (drawBackground) {
				SetHighColor(fBaseColor);
				StrokeRect(frame);
			}
			frame.InsetBy(1, 1);

			uint32 flags = 0;
			if (!drawBackground)
				flags |= BControlLook::B_BLEND_FRAME;
			if (key->flags != 0)
				flags |= BControlLook::B_ACTIVATED;
			flags |= BControlLook::B_IGNORE_OUTLINE;

			be_control_look->DrawButtonFrame(this, frame, updateRect,
				fBaseColor, fBaseColor, flags);

			be_control_look->DrawButtonBackground(this, frame, updateRect,
				fBaseColor, flags);

			be_control_look->DrawLabel(this, key->label, frame, updateRect,
				fBaseColor, flags, BAlignment(B_ALIGN_HORIZONTAL_CENTER,
					B_ALIGN_VERTICAL_CENTER), &fButtonTextColor);

			key++;
		}
	}
}


void
CalcView::MouseDown(BPoint point)
{
	// ensure this view is the current focus
	if (!fExpressionTextView->IsFocus()) {
		// Call our version of MakeFocus(), since that will also apply the
		// num_lock setting.
		MakeFocus();
	}

	// read mouse buttons state
	int32 buttons = 0;
	Window()->CurrentMessage()->FindInt32("buttons", &buttons);

	if ((B_PRIMARY_MOUSE_BUTTON & buttons) == 0) {
		// display popup menu if not primary mouse button
		BMenuItem* selected;
		if ((selected = fPopUpMenu->Go(ConvertToScreen(point))) != NULL
			&& selected->Message() != NULL) {
			Window()->PostMessage(selected->Message(), this);
		}
		return;
	}

	if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT) {
		if (fCalcIcon != NULL) {
			BRect bounds(Bounds());
			bounds.left = bounds.right - fCalcIcon->Bounds().Width();
			if (bounds.Contains(point)) {
				// user clicked on calculator icon
				fExpressionTextView->Clear();
			}
		}
		return;
	}

	// calculate grid sizes
	float sizeDisp = fHeight * kDisplayScaleY;
	float sizeCol = fWidth / (float)fColumns;
	float sizeRow = (fHeight - sizeDisp) / (float)fRows;

	// calculate location within grid
	int gridCol = (int)floorf(point.x / sizeCol);
	int gridRow = (int)floorf((point.y - sizeDisp) / sizeRow);

	// check limits
	if ((gridCol >= 0) && (gridCol < fColumns)
		&& (gridRow >= 0) && (gridRow < fRows)) {

		// process key press
		int key = gridRow * fColumns + gridCol;
		_FlashKey(key, FLAGS_MOUSE_DOWN);
		_PressKey(key);

		// make sure we receive the mouse up!
		SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
	}
}


void
CalcView::MouseUp(BPoint point)
{
	if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT)
		return;

	int keys = fRows * fColumns;
	for (int i = 0; i < keys; i++) {
		if (fKeypad[i].flags & FLAGS_MOUSE_DOWN) {
			_FlashKey(i, 0);
			break;
		}
	}
}


void
CalcView::KeyDown(const char* bytes, int32 numBytes)
{
	// if single byte character...
	if (numBytes == 1) {

		//printf("Key pressed: %c\n", bytes[0]);

		switch (bytes[0]) {

			case B_ENTER:
				// translate to evaluate key
				_PressKey("=");
				break;

			case B_LEFT_ARROW:
			case B_BACKSPACE:
				// translate to backspace key
				_PressKey("BS");
				break;

			case B_SPACE:
			case B_ESCAPE:
			case 'c':
				// translate to clear key
				_PressKey("C");
				break;

			// bracket translation
			case '[':
			case '{':
				_PressKey("(");
				break;

			case ']':
			case '}':
				_PressKey(")");
				break;

			default: {
				// scan the keymap array for match
				int keys = fRows * fColumns;
				for (int i = 0; i < keys; i++) {
					if (fKeypad[i].keymap[0] == bytes[0]) {
						_PressKey(i);
						return;
					}
				}
				break;
			}
		}
	}
}


void
CalcView::MakeFocus(bool focused)
{
	if (focused) {
		// set num lock
		if (fOptions->auto_num_lock) {
			set_keyboard_locks(B_NUM_LOCK
				| (modifiers() & (B_CAPS_LOCK | B_SCROLL_LOCK)));
		}
	}

	// pass on request to text view
	fExpressionTextView->MakeFocus(focused);
}


void
CalcView::FrameResized(float width, float height)
{
	fWidth = width;
	fHeight = height;

	// layout expression text view
	BRect expressionRect = _ExpressionRect();
	if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT) {
		expressionRect.InsetBy(2, 2);
		expressionRect.right -= ceilf(fCalcIcon->Bounds().Width() * 1.5);
	} else
		expressionRect.InsetBy(4, 4);

	fExpressionTextView->MoveTo(expressionRect.LeftTop());
	fExpressionTextView->ResizeTo(expressionRect.Width(), expressionRect.Height());

	// configure expression text view font size and color
	float sizeDisp = fOptions->keypad_mode == KEYPAD_MODE_COMPACT
		? fHeight : fHeight * kDisplayScaleY;
	BFont font(be_bold_font);
	font.SetSize(sizeDisp * kExpressionFontScaleY);
	rgb_color fontColor = fExpressionTextView->HighColor();
	fExpressionTextView->SetFontAndColor(&font, B_FONT_ALL, &fontColor);

	expressionRect.OffsetTo(B_ORIGIN);
	fExpressionTextView->SetTextRect(expressionRect);
	Invalidate();
}


status_t
CalcView::Archive(BMessage* archive, bool deep) const
{
	fExpressionTextView->RemoveSelf();

	// passed on request to parent
	status_t ret = BView::Archive(archive, deep);

	const_cast<CalcView*>(this)->AddChild(fExpressionTextView);

	// save app signature for replicant add-on loading
	if (ret == B_OK)
		ret = archive->AddString("add_on", kSignature);

	// save all the options
	if (ret == B_OK)
		ret = SaveSettings(archive);

	// add class info last
	if (ret == B_OK)
		ret = archive->AddString("class", "CalcView");

	return ret;
}


void
CalcView::Cut()
{
	Copy();	// copy data to clipboard
	fExpressionTextView->Clear(); // remove data
}


void
CalcView::Copy()
{
	// access system clipboard
	ClipboardLocker locker(be_clipboard);
	if (!locker.IsLocked())
		return;

	if (be_clipboard->Clear() != B_OK)
		return;

	BMessage* clipper = be_clipboard->Data();
	if (clipper == NULL)
		return;

	BString expression = fExpressionTextView->Text();
	if (clipper->AddData("text/plain", B_MIME_TYPE,
		expression.String(), expression.Length()) == B_OK) {
		clipper->what = B_MIME_DATA;
		be_clipboard->Commit();
	}
}


void
CalcView::Paste(BMessage* message)
{
	// handle files first
	int32 count;
	if (message->GetInfo("refs", NULL, &count) == B_OK) {
		entry_ref ref;
		ssize_t read;
		BFile file;
		char buffer[256];
		memset(buffer, 0, sizeof(buffer));
		for (int32 i = 0; i < count; i++) {
			if (message->FindRef("refs", i, &ref) == B_OK) {
				if (file.SetTo(&ref, B_READ_ONLY) == B_OK) {
					read = file.Read(buffer, sizeof(buffer) - 1);
					if (read <= 0)
						continue;
					BString expression(buffer);
					int32 j = expression.Length();
					while (j > 0 && expression[j - 1] == '\n')
						j--;
					expression.Truncate(j);
					if (expression.Length() > 0)
						fExpressionTextView->Insert(expression.String());
				}
			}
		}
		return;
	}
	// handle color drops
	// read incoming color
	const rgb_color* dropColor = NULL;
	ssize_t dataSize;
	if (message->FindData("RGBColor", B_RGB_COLOR_TYPE,
			(const void**)&dropColor, &dataSize) == B_OK
		&& dataSize == sizeof(rgb_color)) {

		// calculate view relative drop point
		BPoint dropPoint = ConvertFromScreen(message->DropPoint());

		// calculate current keypad area
		float sizeDisp = fHeight * kDisplayScaleY;
		BRect keypadRect(0.0, sizeDisp, fWidth, fHeight);

		// check location of color drop
		if (keypadRect.Contains(dropPoint) && dropColor != NULL) {
			fBaseColor = *dropColor;
			fHasCustomBaseColor =
				fBaseColor != ui_color(B_PANEL_BACKGROUND_COLOR);
			_Colorize();
			// redraw
			Invalidate();
		}

	} else {
		// look for text/plain MIME data
		const char* text;
		ssize_t numBytes;
		if (message->FindData("text/plain", B_MIME_TYPE,
				(const void**)&text, &numBytes) == B_OK) {
			BString temp;
			temp.Append(text, numBytes);
			fExpressionTextView->Insert(temp.String());
		}
	}
}


status_t
CalcView::SaveSettings(BMessage* archive) const
{
	status_t ret = archive ? B_OK : B_BAD_VALUE;

	// record grid dimensions
	if (ret == B_OK)
		ret = archive->AddInt16("cols", fColumns);

	if (ret == B_OK)
		ret = archive->AddInt16("rows", fRows);

	// record color scheme
	if (ret == B_OK && fHasCustomBaseColor) {
		ret = archive->AddData("rgbBaseColor", B_RGB_COLOR_TYPE,
			&fBaseColor, sizeof(rgb_color));
	}

	// record current options
	if (ret == B_OK)
		ret = fOptions->SaveSettings(archive);

	// record display text
	if (ret == B_OK)
		ret = archive->AddString("displayText", fExpressionTextView->Text());

	// record expression history
	if (ret == B_OK)
		ret = fExpressionTextView->SaveSettings(archive);

	// record calculator description
	if (ret == B_OK)
		ret = archive->AddString("calcDesc",
			fKeypadDescription == kKeypadDescriptionBasic
			? "basic" : "scientific");

	return ret;
}


void
CalcView::Evaluate()
{
	if (fExpressionTextView->TextLength() == 0) {
		beep();
		return;
	}

	fEvaluateThread = spawn_thread(_EvaluateThread, "Evaluate Thread",
		B_LOW_PRIORITY, this);
	if (fEvaluateThread < B_OK) {
		// failed to create evaluate thread, error out
		fExpressionTextView->SetText(strerror(fEvaluateThread));
		return;
	}

	_SetEnabled(false);
		// Disable input while we evaluate

	status_t threadStatus = resume_thread(fEvaluateThread);
	if (threadStatus != B_OK) {
		// evaluate thread failed to start, error out
		fExpressionTextView->SetText(strerror(threadStatus));
		_SetEnabled(true);
		return;
	}

	if (fEvaluateMessageRunner == NULL) {
		BMessage message(kMsgCalculating);
		fEvaluateMessageRunner = new (std::nothrow) BMessageRunner(
			BMessenger(this), &message, kCalculatingInterval, 1);
		status_t runnerStatus = fEvaluateMessageRunner->InitCheck();
		if (runnerStatus != B_OK)
			printf("Evaluate Message Runner: %s\n", strerror(runnerStatus));
	}
}


void
CalcView::FlashKey(const char* bytes, int32 numBytes)
{
	BString temp;
	temp.Append(bytes, numBytes);
	int32 key = _KeyForLabel(temp.String());
	if (key >= 0)
		_FlashKey(key, FLAGS_FLASH_KEY);
}


void
CalcView::ToggleAutoNumlock(void)
{
	fOptions->auto_num_lock = !fOptions->auto_num_lock;
	fAutoNumlockItem->SetMarked(fOptions->auto_num_lock);
}


void
CalcView::SetDegreeMode(bool degrees)
{
	fOptions->degree_mode = degrees;
	fAngleModeRadianItem->SetMarked(!degrees);
	fAngleModeDegreeItem->SetMarked(degrees);
}


void
CalcView::SetKeypadMode(uint8 mode)
{
	if (_IsEmbedded())
		return;

	BWindow* window = Window();
	if (window == NULL)
		return;

	if (fOptions->keypad_mode == mode)
		return;

	fOptions->keypad_mode = mode;
	_MarkKeypadItems(fOptions->keypad_mode);

	float width = fWidth;
	float height = fHeight;

	switch (fOptions->keypad_mode) {
		case KEYPAD_MODE_COMPACT:
		{
			if (window->Bounds() == Frame()) {
				window->SetSizeLimits(kMinimumWidthCompact,
					kMaximumWidthCompact, kMinimumHeightCompact,
					kMaximumHeightCompact);
				window->ResizeTo(width, height * kDisplayScaleY);
			} else
				ResizeTo(width, height * kDisplayScaleY);

			break;
		}

		case KEYPAD_MODE_SCIENTIFIC:
		{
			fKeypadDescription = kKeypadDescriptionScientific;
			fRows = 8;
			_ParseCalcDesc(fKeypadDescription);

			window->SetSizeLimits(kMinimumWidthScientific,
				kMaximumWidthScientific, kMinimumHeightScientific,
				kMaximumHeightScientific);

			if (width < kMinimumWidthScientific)
				width = kMinimumWidthScientific;
			else if (width > kMaximumWidthScientific)
				width = kMaximumWidthScientific;

			if (height < kMinimumHeightScientific)
				height = kMinimumHeightScientific;
			else if (height > kMaximumHeightScientific)
				height = kMaximumHeightScientific;

			if (width != fWidth || height != fHeight)
				ResizeTo(width, height);
			else
				Invalidate();

			break;
		}

		case KEYPAD_MODE_BASIC:
		default:
		{
			fKeypadDescription = kKeypadDescriptionBasic;
			fRows = 4;
			_ParseCalcDesc(fKeypadDescription);

			window->SetSizeLimits(kMinimumWidthBasic, kMaximumWidthBasic,
				kMinimumHeightBasic, kMaximumHeightBasic);

			if (width < kMinimumWidthBasic)
				width = kMinimumWidthBasic;
			else if (width > kMaximumWidthBasic)
				width = kMaximumWidthBasic;

			if (height < kMinimumHeightBasic)
				height = kMinimumHeightBasic;
			else if (height > kMaximumHeightBasic)
				height = kMaximumHeightBasic;

			if (width != fWidth || height != fHeight)
				ResizeTo(width, height);
			else
				Invalidate();
		}
	}
}


// #pragma mark -


/*static*/ status_t
CalcView::_EvaluateThread(void* data)
{
	CalcView* calcView = reinterpret_cast<CalcView*>(data);
	if (calcView == NULL)
		return B_BAD_TYPE;

	BMessenger messenger(calcView);
	if (!messenger.IsValid())
		return B_BAD_VALUE;

	BString result;
	status_t status = acquire_sem(calcView->fEvaluateSemaphore);
	if (status == B_OK) {
		BLocale locale;
		BNumberFormat format(&locale);

		ExpressionParser parser;
		parser.SetDegreeMode(calcView->fOptions->degree_mode);
		parser.SetSeparators(format.GetSeparator(B_DECIMAL_SEPARATOR),
			format.GetSeparator(B_GROUPING_SEPARATOR));

		BString expression(calcView->fExpressionTextView->Text());
		try {
			result = parser.Evaluate(expression.String());
		} catch (ParseException& e) {
			result << e.message.String() << " at " << (e.position + 1);
			status = B_ERROR;
		}
		release_sem(calcView->fEvaluateSemaphore);
	} else
		result = strerror(status);

	BMessage message(kMsgDoneEvaluating);
	message.AddString(status == B_OK ? "value" : "error", result.String());
	messenger.SendMessage(&message);

	return status;
}


void
CalcView::_Init(BMessage* settings)
{
	// create expression text view
	fExpressionTextView = new ExpressionTextView(_ExpressionRect(), this);
	AddChild(fExpressionTextView);

	// read data from archive
	_LoadSettings(settings);

	// fetch the calc icon for compact view
	_FetchAppIcon(fCalcIcon);

	fEvaluateSemaphore = create_sem(1, "Evaluate Semaphore");
}


status_t
CalcView::_LoadSettings(BMessage* archive)
{
	if (!archive)
		return B_BAD_VALUE;

	// record calculator description
	BString calcDesc;
	archive->FindString("calcDesc", &calcDesc);
	if (calcDesc == "scientific" || calcDesc.StartsWith("ln"))
		fKeypadDescription = kKeypadDescriptionScientific;
	else
		fKeypadDescription = kKeypadDescriptionBasic;

	// read grid dimensions
	if (archive->FindInt16("cols", &fColumns) < B_OK)
		fColumns = 5;
	if (archive->FindInt16("rows", &fRows) < B_OK)
		fRows = 4;

	// read color scheme
	const rgb_color* color;
	ssize_t size;
	if (archive->FindData("rgbBaseColor", B_RGB_COLOR_TYPE,
			(const void**)&color, &size) < B_OK
		|| size != sizeof(rgb_color)) {
		fBaseColor = ui_color(B_PANEL_BACKGROUND_COLOR);
		puts("Missing rgbBaseColor from CalcView archive!\n");
	} else
		fBaseColor = *color;

	fHasCustomBaseColor = fBaseColor != ui_color(B_PANEL_BACKGROUND_COLOR);

	// load options
	fOptions->LoadSettings(archive);

	// load display text
	const char* display;
	if (archive->FindString("displayText", &display) < B_OK) {
		puts("Missing expression text from CalcView archive.\n");
	} else {
		// init expression text
		fExpressionTextView->SetText(display);
	}

	// load expression history
	fExpressionTextView->LoadSettings(archive);

	// parse calculator description
	_ParseCalcDesc(fKeypadDescription);

	// colorize based on base color.
	_Colorize();

	return B_OK;
}


void
CalcView::_ParseCalcDesc(const char** keypadDescription)
{
	// TODO: should calculate dimensions from desc here!
	fKeypad = new CalcKey[fRows * fColumns];

	// scan through calculator description and assemble keypad
	CalcKey* key = fKeypad;
	for (int i = 0; const char* p = keypadDescription[i]; i++) {
		// Move to next row as needed
		if (strcmp(p, "\n") == 0)
			continue;

		// copy label
		strlcpy(key->label, B_TRANSLATE_NOCOLLECT(p), sizeof(key->label));

		// set code
		if (strcmp(p, "=") == 0)
			strlcpy(key->code, "\n", sizeof(key->code));
		else
			strlcpy(key->code, p, sizeof(key->code));

		// set keymap
		if (strlen(key->label) == 1)
			strlcpy(key->keymap, key->label, sizeof(key->keymap));
		else
			*key->keymap = '\0';

		key->flags = 0;

		// add this to the expression text view, so that it
		// will forward the respective KeyDown event to us
		fExpressionTextView->AddKeypadLabel(key->label);

		// advance
		key++;
	}
}


void
CalcView::_PressKey(int key)
{
	if (!fEnabled)
		return;

	assert(key < (fRows * fColumns));
	assert(key >= 0);

	if (strcmp(fKeypad[key].code, "BS") == 0) {
		// BS means backspace
		fExpressionTextView->BackSpace();
	} else if (strcmp(fKeypad[key].code, "C") == 0) {
		// C means clear
		fExpressionTextView->Clear();
	} else if (strcmp(fKeypad[key].code, "acos") == 0
		|| strcmp(fKeypad[key].code, "asin") == 0
		|| strcmp(fKeypad[key].code, "atan") == 0
		|| strcmp(fKeypad[key].code, "cbrt") == 0
		|| strcmp(fKeypad[key].code, "ceil") == 0
		|| strcmp(fKeypad[key].code, "cos") == 0
		|| strcmp(fKeypad[key].code, "cosh") == 0
		|| strcmp(fKeypad[key].code, "exp") == 0
		|| strcmp(fKeypad[key].code, "floor") == 0
		|| strcmp(fKeypad[key].code, "log") == 0
		|| strcmp(fKeypad[key].code, "ln") == 0
		|| strcmp(fKeypad[key].code, "sin") == 0
		|| strcmp(fKeypad[key].code, "sinh") == 0
		|| strcmp(fKeypad[key].code, "sqrt") == 0
		|| strcmp(fKeypad[key].code, "tan") == 0
		|| strcmp(fKeypad[key].code, "tanh") == 0) {
		int32 labelLen = strlen(fKeypad[key].code);
		int32 startSelection = 0;
		int32 endSelection = 0;
		fExpressionTextView->GetSelection(&startSelection, &endSelection);
		if (endSelection > startSelection) {
			// There is selected text, put it inbetween the parens
			fExpressionTextView->Insert(startSelection, fKeypad[key].code,
				labelLen);
			fExpressionTextView->Insert(startSelection + labelLen, "(", 1);
			fExpressionTextView->Insert(endSelection + labelLen + 1, ")", 1);
			// Put the cursor after the ending paren
			// Need to cast to BTextView because Select() is protected
			// in the InputTextView class
			static_cast<BTextView*>(fExpressionTextView)->Select(
				endSelection + labelLen + 2, endSelection + labelLen + 2);
		} else {
			// There is no selected text, insert at the cursor location
			fExpressionTextView->Insert(fKeypad[key].code);
			fExpressionTextView->Insert("()");
			// Put the cursor inside the parens so you can enter an argument
			// Need to cast to BTextView because Select() is protected
			// in the InputTextView class
			static_cast<BTextView*>(fExpressionTextView)->Select(
				endSelection + labelLen + 1, endSelection + labelLen + 1);
		}
	} else if (strcmp(fKeypad[key].code, ".") == 0) {
		BLocale locale;
		BNumberFormat format(&locale);

		fExpressionTextView->Insert(format.GetSeparator(B_DECIMAL_SEPARATOR));
	} else {
		// check for evaluation order
		if (fKeypad[key].code[0] == '\n') {
			fExpressionTextView->ApplyChanges();
		} else {
			// insert into expression text
			fExpressionTextView->Insert(fKeypad[key].code);
		}
	}
}


void
CalcView::_PressKey(const char* label)
{
	int32 key = _KeyForLabel(label);
	if (key >= 0)
		_PressKey(key);
}


int32
CalcView::_KeyForLabel(const char* label) const
{
	int keys = fRows * fColumns;
	for (int i = 0; i < keys; i++) {
		if (strcmp(fKeypad[i].label, label) == 0) {
			return i;
		}
	}
	return -1;
}


void
CalcView::_FlashKey(int32 key, uint32 flashFlags)
{
	if (fOptions->keypad_mode == KEYPAD_MODE_COMPACT)
		return;

	if (flashFlags != 0)
		fKeypad[key].flags |= flashFlags;
	else
		fKeypad[key].flags = 0;
	Invalidate();

	if (fKeypad[key].flags == FLAGS_FLASH_KEY) {
		BMessage message(MSG_UNFLASH_KEY);
		message.AddInt32("key", key);
		BMessageRunner::StartSending(BMessenger(this), &message,
			kFlashOnOffInterval, 1);
	}
}


void
CalcView::_Colorize()
{
	rgb_color panelColor = ui_color(B_PANEL_TEXT_COLOR);
	if (rgb_color::Contrast(fBaseColor, panelColor) > 100)
		fButtonTextColor = panelColor;
	else {
		if (fBaseColor.IsLight())
			fButtonTextColor = (rgb_color){ 0, 0, 0, 255 };
		else
			fButtonTextColor = (rgb_color){ 255, 255, 255, 255 };
	}
}


void
CalcView::_CreatePopUpMenu(bool addKeypadModeMenuItems)
{
	// construct items
	fAutoNumlockItem = new BMenuItem(B_TRANSLATE("Enable Num Lock on startup"),
		new BMessage(MSG_OPTIONS_AUTO_NUM_LOCK));
	fAngleModeRadianItem = new BMenuItem(B_TRANSLATE("Radians"),
		new BMessage(MSG_OPTIONS_ANGLE_MODE_RADIAN));
	fAngleModeDegreeItem = new BMenuItem(B_TRANSLATE("Degrees"),
		new BMessage(MSG_OPTIONS_ANGLE_MODE_DEGREE));
	if (addKeypadModeMenuItems) {
		fKeypadModeCompactItem = new BMenuItem(B_TRANSLATE("Compact"),
			new BMessage(MSG_OPTIONS_KEYPAD_MODE_COMPACT), '0');
		fKeypadModeBasicItem = new BMenuItem(B_TRANSLATE("Basic"),
			new BMessage(MSG_OPTIONS_KEYPAD_MODE_BASIC), '1');
		fKeypadModeScientificItem = new BMenuItem(B_TRANSLATE("Scientific"),
			new BMessage(MSG_OPTIONS_KEYPAD_MODE_SCIENTIFIC), '2');
	}

	// apply current settings
	fAutoNumlockItem->SetMarked(fOptions->auto_num_lock);
	fAngleModeRadianItem->SetMarked(!fOptions->degree_mode);
	fAngleModeDegreeItem->SetMarked(fOptions->degree_mode);

	// construct menu
	fPopUpMenu = new BPopUpMenu("pop-up", false, false);

	fPopUpMenu->AddItem(fAutoNumlockItem);
	fPopUpMenu->AddSeparatorItem();
	fPopUpMenu->AddItem(fAngleModeRadianItem);
	fPopUpMenu->AddItem(fAngleModeDegreeItem);
	if (addKeypadModeMenuItems) {
		fPopUpMenu->AddSeparatorItem();
		fPopUpMenu->AddItem(fKeypadModeCompactItem);
		fPopUpMenu->AddItem(fKeypadModeBasicItem);
		fPopUpMenu->AddItem(fKeypadModeScientificItem);
		_MarkKeypadItems(fOptions->keypad_mode);
	}
}


BRect
CalcView::_ExpressionRect() const
{
	BRect r(0.0, 0.0, fWidth, fHeight);
	if (fOptions->keypad_mode != KEYPAD_MODE_COMPACT) {
		r.bottom = floorf(fHeight * kDisplayScaleY) + 1;
	}
	return r;
}


BRect
CalcView::_KeypadRect() const
{
	BRect r(0.0, 0.0, -1.0, -1.0);
	if (fOptions->keypad_mode != KEYPAD_MODE_COMPACT) {
		r.right = fWidth;
		r.bottom = fHeight;
		r.top = floorf(fHeight * kDisplayScaleY);
	}
	return r;
}


void
CalcView::_MarkKeypadItems(uint8 keypad_mode)
{
	switch (keypad_mode) {
		case KEYPAD_MODE_COMPACT:
			fKeypadModeCompactItem->SetMarked(true);
			fKeypadModeBasicItem->SetMarked(false);
			fKeypadModeScientificItem->SetMarked(false);
			break;

		case KEYPAD_MODE_SCIENTIFIC:
			fKeypadModeCompactItem->SetMarked(false);
			fKeypadModeBasicItem->SetMarked(false);
			fKeypadModeScientificItem->SetMarked(true);
			break;

		default: // KEYPAD_MODE_BASIC is the default
			fKeypadModeCompactItem->SetMarked(false);
			fKeypadModeBasicItem->SetMarked(true);
			fKeypadModeScientificItem->SetMarked(false);
	}
}


void
CalcView::_FetchAppIcon(BBitmap* into)
{
	entry_ref appRef;
	status_t status = be_roster->FindApp(kSignature, &appRef);
	if (status == B_OK) {
		BFile file(&appRef, B_READ_ONLY);
		BAppFileInfo appInfo(&file);
		status = appInfo.GetIcon(into, B_MINI_ICON);
	}
	if (status != B_OK)
		memset(into->Bits(), 0, into->BitsLength());
}


// Returns whether or not CalcView is embedded somewhere, most likely
// the Desktop
bool
CalcView::_IsEmbedded()
{
	return Parent() != NULL && (Parent()->Flags() & B_DRAW_ON_CHILDREN) != 0;
}


void
CalcView::_SetEnabled(bool enable)
{
	fEnabled = enable;
	fExpressionTextView->MakeSelectable(enable);
	fExpressionTextView->MakeEditable(enable);
}