haiku.git

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


#include "DataView.h"

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

#include <Autolock.h>
#include <Beep.h>
#include <Clipboard.h>
#include <Mime.h>
#include <ScrollBar.h>
#include <Window.h>

#include "DataEditor.h"


static const uint32 kBlockSize = 16;
// TODO: use variable spacing
static const uint32 kHorizontalSpace = 8;
static const uint32 kVerticalSpace = 4;
static const uint32 kPositionLength = 4;

static const uint32 kBlockSpace = 3;
static const uint32 kHexByteWidth = 3;
	// these are determined by the implementation of DataView::ConvertLine()


/*!	This function checks if the buffer contains a valid UTF-8
	string, following the convention from the DataView::ConvertLine()
	method: everything that's not replaced by a '.' will be accepted.
*/
bool
is_valid_utf8(uint8 *data, size_t size)
{
	for (size_t i = 0; i < size; i++) {
		// accept a terminating null byte
		if (i == size - 1 && data[i] == '\0')
			return true;

		if ((data[i] & 0x80) == 0) {
			// a single byte character
			if ((data[i] < ' '
					&& data[i] != 0x0d && data[i] != 0x09 && data[i] != 0x0a)
				|| data[i] == 0x7f)
				return false;

			continue;
		}

		if ((data[i] & 0xc0) == 0x80) {
			// not a proper multibyte start
			return false;
		}

		// start of a multibyte character
		uint8 mask = 0x80;
		uint32 result = (uint32)(data[i++] & 0xff);

		while (result & mask) {
			if (mask == 0x02) {
				// seven byte char - invalid
				return false;
			}

			result &= ~mask;
			mask >>= 1;
		}

		while (i < size && (data[i] & 0xc0) == 0x80) {
			result <<= 6;
			result += data[i++] & 0x3f;

			mask <<= 1;
			if (mask == 0x40)
				break;
		}

		if (mask != 0x40) {
			// not enough bytes in multibyte char
			return false;
		}
	}

	return true;
}


//	#pragma mark -


DataView::DataView(DataEditor &editor)
	: BView("dataView", B_WILL_DRAW | B_NAVIGABLE | B_FRAME_EVENTS),
	fEditor(editor),
	fFocus(kHexFocus),
	fBase(kHexBase),
	fIsActive(true),
	fMouseSelectionStart(-1),
	fKeySelectionStart(-1),
	fBitPosition(0),
	fFitFontSize(false),
	fDragMessageSize(-1)
{
	fStart = fEnd = 0;

	if (fEditor.Lock()) {
		fDataSize = fEditor.ViewSize();
		fOffset = fEditor.ViewOffset();
		fEditor.Unlock();
	} else
		fDataSize = 512;
	fData = (uint8 *)malloc(fDataSize);

	SetFontSize(12.0);
		// also sets the fixed font

	UpdateFromEditor();
}


DataView::~DataView()
{
}


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


void
DataView::AttachedToWindow()
{
	fEditor.StartWatching(this);
	MakeFocus(true);
		// this seems to be necessary - if we don't do this here,
		// the view is sometimes focus, but IsFocus() returns false...

	SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
	SetLowUIColor(ViewUIColor());
	SetHighUIColor(B_DOCUMENT_TEXT_COLOR);
}


void
DataView::UpdateFromEditor(BMessage *message)
{
	if (fData == NULL)
		return;

	BAutolock locker(fEditor);

	fFileSize = fEditor.FileSize();

	// get the range of the changes

	int32 start = 0, end = fDataSize - 1;
	off_t offset, size;
	if (message != NULL
		&& message->FindInt64("offset", &offset) == B_OK
		&& message->FindInt64("size", &size) == B_OK) {
		if (offset > fOffset + (off_t)fDataSize
			|| offset + (off_t)size < fOffset) {
			// the changes are not within our scope, so we can ignore them
			return;
		}

		if (offset > fOffset)
			start = offset - fOffset;
		if (offset + (off_t)size < fOffset + (off_t)fDataSize)
			end = offset + size - fOffset;
	}

	if (fOffset + (off_t)fDataSize > fFileSize)
		fSizeInView = fFileSize - fOffset;
	else
		fSizeInView = fDataSize;

	const uint8 *data;
	if (fEditor.GetViewBuffer(&data) == B_OK)
		// ToDo: copy only the relevant part
		memcpy(fData, data, fDataSize);

	InvalidateRange(start, end);

	// we notify our selection listeners also if the
	// data in the selection has changed
	if (start <= fEnd && end >= fStart) {
		BMessage update;
		update.AddInt64("start", fStart);
		update.AddInt64("end", fEnd);
		SendNotices(kDataViewSelection, &update);
	}
}


bool
DataView::AcceptsDrop(const BMessage *message)
{
	return !fEditor.IsReadOnly()
		&& (message->HasData("text/plain", B_MIME_TYPE)
			|| message->HasData(B_FILE_MIME_TYPE, B_MIME_TYPE));
}


void
DataView::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case kMsgUpdateData:
		case kMsgDataEditorUpdate:
			UpdateFromEditor(message);
			break;

		case kMsgDataEditorParameterChange:
		{
			int32 viewSize;
			off_t offset;
			if (message->FindInt64("offset", &offset) == B_OK) {
				fOffset = offset;
				SetSelection(0, 0);
				MakeVisible(0);
			}
			if (message->FindInt32("view_size", &viewSize) == B_OK) {
				fDataSize = viewSize;
				fData = (uint8 *)realloc(fData, fDataSize);
				UpdateScroller();
				SendNotices(kDataViewPreferredSize);
			}
			if (message->FindInt64("file_size", &offset) == B_OK)
				UpdateFromEditor();
			break;
		}

		case kMsgBaseType:
		{
			int32 type;
			if (message->FindInt32("base", &type) != B_OK)
				break;

			SetBase((base_type)type);
			break;
		}

		case kMsgSetSelection:
		{
			int64 start, end;
			if (message->FindInt64("start", &start) != B_OK
				|| message->FindInt64("end", &end) != B_OK)
				break;

			SetSelection(start, end);
			break;
		}

		case B_SELECT_ALL:
			SetSelection(0, fDataSize - 1);
			break;

		case B_COPY:
			Copy();
			break;

		case B_PASTE:
			Paste();
			break;

		case B_UNDO:
			fEditor.Undo();
			break;

		case B_REDO:
			fEditor.Redo();
			break;

		case B_MIME_DATA:
			if (AcceptsDrop(message)) {
				const void *data;
				ssize_t size;
				if (message->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK
					|| message->FindData(B_FILE_MIME_TYPE, B_MIME_TYPE, &data, &size) == B_OK) {
					if (fEditor.Replace(fOffset + fStart, (const uint8 *)data, size) != B_OK)
						SetSelection(fStoredStart, fStoredEnd);

					fDragMessageSize = -1;
				}
			}
			break;

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


void
DataView::Copy()
{
	if (!be_clipboard->Lock())
		return;

	be_clipboard->Clear();

	BMessage *clip;
	if ((clip = be_clipboard->Data()) != NULL) {
		uint8 *data = fData + fStart;
		size_t length = fEnd + 1 - fStart;

		clip->AddData(B_FILE_MIME_TYPE, B_MIME_TYPE, data, length);

		if (is_valid_utf8(data, length))
			clip->AddData("text/plain", B_MIME_TYPE, data, length);

		be_clipboard->Commit();
	}

	be_clipboard->Unlock();
}


void
DataView::Paste()
{
	if (!be_clipboard->Lock())
		return;

	const void *data;
	ssize_t length;
	BMessage *clip;
	if ((clip = be_clipboard->Data()) != NULL
		&& (clip->FindData(B_FILE_MIME_TYPE, B_MIME_TYPE, &data, &length) == B_OK
			|| clip->FindData("text/plain", B_MIME_TYPE, &data, &length) == B_OK)) {
		// we have valid data, but it could still be too
		// large to to fit in the file
		if (fOffset + fStart + length > fFileSize)
			length = fFileSize - fOffset;

		if (fEditor.Replace(fOffset + fStart, (const uint8 *)data, length) == B_OK)
			SetSelection(fStart + length, fStart + length);
	} else
		beep();

	be_clipboard->Unlock();
}


void
DataView::ConvertLine(char *line, off_t offset, const uint8 *buffer, size_t size)
{
	if (size == 0) {
		line[0] = '\0';
		return;
	}

	line += sprintf(line, fBase == kHexBase ? "%0*" B_PRIxOFF":  " : "%0*"
		B_PRIdOFF":  ", (int)kPositionLength, offset);

	for (uint32 i = 0; i < kBlockSize; i++) {
		if (i >= size) {
			strcpy(line, "   ");
			line += kHexByteWidth;
		} else
			line += sprintf(line, "%02x ", *(unsigned char *)(buffer + i));
	}

	strcpy(line, "   ");
	line += 3;

	for (uint32 i = 0; i < kBlockSize; i++) {
		if (i < size) {
			char c = buffer[i];

			if (c < ' ' || c == 0x7f)
				*line++ = '.';
			else
				*line++ = c;
		} else
			break;
	}

	*line = '\0';
}


void
DataView::Draw(BRect updateRect)
{
	if (fData == NULL || fFileSize == 0)
		return;

	// ToDo: take "updateRect" into account!

	char line[255];
	BPoint location(kHorizontalSpace, kVerticalSpace + fAscent);
	const float kTintDarkenTouch = (B_NO_TINT + B_DARKEN_1_TINT) / 2.0f;

	for (uint32 lineNum = 0, i = 0; i < fSizeInView; lineNum++, i += kBlockSize) {
		// Tint every 2nd line to create a striped background

		float tint = (lineNum % 2 == 0) ? B_NO_TINT : kTintDarkenTouch;
		SetLowUIColor(B_DOCUMENT_BACKGROUND_COLOR, tint);

		FillRect(BRect(location.x - kHorizontalSpace,
			kVerticalSpace + lineNum * fFontHeight,
			location.x - kHorizontalSpace / 2 + Bounds().right,
			kVerticalSpace + (lineNum + 1) * fFontHeight), B_SOLID_LOW);

		ConvertLine(line, i, fData + i, fSizeInView - i);
		DrawString(line, location);

		location.y += fFontHeight;
	}

	// Draw first vertical line after 18 chars ("0000: xx xx xx xx")
	// Next three vertical lines require an offset of 12 chars ("xx xx xx xx")

	BPoint line_start(kHorizontalSpace + fCharWidth * 18 + fCharWidth / 2, 0);
	BPoint line_end(line_start.x, Bounds().bottom);

	rgb_color lineColor = tint_color(lineColor, B_LIGHTEN_2_TINT);
	uint32 kDrawNumLines = 3;

	BeginLineArray(kDrawNumLines);
	for (uint32 i = 0; i < kDrawNumLines; i++) {
		AddLine(line_start, line_end, lineColor);
		line_start.x += fCharWidth * 12;
		line_end.x = line_start.x;
	}
	EndLineArray();

	DrawSelection();
}


BRect
DataView::DataBounds(bool inView) const
{
	return BRect(0, 0,
		fCharWidth * (kBlockSize * 4 + kPositionLength + 6) + 2 * kHorizontalSpace,
		fFontHeight * (((inView ? fSizeInView : fDataSize) + kBlockSize - 1) / kBlockSize)
			+ 2 * kVerticalSpace);
}


int32
DataView::PositionAt(view_focus focus, BPoint point, view_focus *_newFocus)
{
	// clip the point into our data bounds

	BRect bounds = DataBounds(true);
	if (point.x < bounds.left)
		point.x = bounds.left;
	else if (point.x > bounds.right)
		point.x = bounds.right;

	if (point.y < bounds.top)
		point.y = bounds.top;
	else if (point.y >= bounds.bottom - kVerticalSpace)
		point.y = bounds.bottom - kVerticalSpace - 1;

	float left = fCharWidth * (kPositionLength + kBlockSpace) + kHorizontalSpace;
	float hexWidth = fCharWidth * kBlockSize * kHexByteWidth;
	float width = fCharWidth;

	if (focus == kNoFocus) {
		// find in which part the point is in
		if (point.x < left - width / 2)
			return -1;

		if (point.x > left + hexWidth)
			focus = kAsciiFocus;
		else
			focus = kHexFocus;

		if (_newFocus)
			*_newFocus = focus;
	}
	if (focus == kHexFocus) {
		left -= width / 2;
		width *= kHexByteWidth;
	} else
		left += hexWidth + (kBlockSpace * width);

	int32 row = int32((point.y - kVerticalSpace) / fFontHeight);
	int32 column = int32((point.x - left) / width);
	if (column >= (int32)kBlockSize)
		column = (int32)kBlockSize - 1;
	else if (column < 0)
		column = 0;

	return row * kBlockSize + column;
}


BRect
DataView::SelectionFrame(view_focus which, int32 start, int32 end)
{
	float spacing = 0;
	float width = fCharWidth;
	float byteWidth = fCharWidth;
	float left;

	if (which == kHexFocus) {
		spacing = fCharWidth / 2;
		left = width * (kPositionLength + kBlockSpace);
		width *= kHexByteWidth;
		byteWidth *= 2;
	} else
		left = width * (kPositionLength + 2 * kBlockSpace + kHexByteWidth * kBlockSize);

	left += kHorizontalSpace;
	float startInLine = (start % kBlockSize) * width;
	float endInLine = (end % kBlockSize) * width + byteWidth - 1;

	return BRect(left + startInLine - spacing,
		kVerticalSpace + (start / kBlockSize) * fFontHeight,
		left + endInLine + spacing,
		kVerticalSpace + (end / kBlockSize + 1) * fFontHeight - 1);
}


void
DataView::DrawSelectionFrame(view_focus which)
{
	if (fFileSize == 0)
		return;

	bool drawBlock = false;
	bool drawLastLine = false;
	BRect block, lastLine;
	int32 spacing = 0;
	if (which == kAsciiFocus)
		spacing++;

	// draw first line

	int32 start = fStart % kBlockSize;
	int32 first = (fStart / kBlockSize) * kBlockSize;

	int32 end = fEnd;
	if (end > first + (int32)kBlockSize - 1)
		end = first + kBlockSize - 1;

	BRect firstLine = SelectionFrame(which, first + start, end);
	firstLine.right += spacing;
	first += kBlockSize;

	// draw block (and last line) if necessary

	end = fEnd % kBlockSize;
	int32 last = (fEnd / kBlockSize) * kBlockSize;

	if (last >= first) {
		if (end == kBlockSize - 1)
			last += kBlockSize;
		if (last > first) {
			block = SelectionFrame(which, first, last - 1);
			block.right += spacing;
			drawBlock = true;
		}
		if (end != kBlockSize - 1) {
			lastLine = SelectionFrame(which, last, last + end);
			lastLine.right += spacing;
			drawLastLine = true;
		}
	}

	SetDrawingMode(B_OP_INVERT);
	BeginLineArray(8);

	// +*******
	// |      *
	// +------+

	const rgb_color color = {0, 0, 0};
	float bottom;
	if (drawBlock)
		bottom = block.bottom;
	else
		bottom = firstLine.bottom;

	AddLine(BPoint(firstLine.left + 1, firstLine.top), firstLine.RightTop(), color);
	AddLine(BPoint(firstLine.right, firstLine.top + 1), BPoint(firstLine.right, bottom), color);

	// *-------+
	// *       |
	// *********

	BRect rect;
	if (start == 0 || (!drawBlock && !drawLastLine))
		rect = firstLine;
	else if (drawBlock)
		rect = block;
	else
		rect = lastLine;

	if (drawBlock)
		rect.bottom = block.bottom;
	if (drawLastLine) {
		rect.bottom = lastLine.bottom;
		rect.right = lastLine.right;
	}
	rect.bottom++;

	AddLine(rect.LeftTop(), rect.LeftBottom(), color);
	AddLine(BPoint(rect.left + 1, rect.bottom), rect.RightBottom(), color);

	//     *--------+
	//     *        |
	// +****        |
	// |            |

	if (start && (drawLastLine || drawBlock)) {
		AddLine(firstLine.LeftTop(), firstLine.LeftBottom(), color);

		float right = firstLine.left;
		if (!drawBlock && right > lastLine.right)
			right = lastLine.right;
		AddLine(BPoint(rect.left + 1, rect.top), BPoint(right, rect.top), color);
	}

	// |            |
	// |        *****
	// |        *
	// +--------+

	if (drawLastLine) {
		AddLine(lastLine.RightBottom(), BPoint(lastLine.right, lastLine.top + 1), color);
		if (!drawBlock && lastLine.right <= firstLine.left)
			lastLine.right = firstLine.left + (lastLine.right < firstLine.left ? 0 : 1);
		AddLine(BPoint(lastLine.right, lastLine.top), BPoint(firstLine.right, lastLine.top), color);
	}

	EndLineArray();
	SetDrawingMode(B_OP_COPY);
}


void
DataView::DrawSelectionBlock(view_focus which, int32 blockStart, int32 blockEnd)
{
	if (fFileSize == 0)
		return;

	// draw first line

	SetDrawingMode(B_OP_INVERT);

	int32 start = blockStart % kBlockSize;
	int32 first = (blockStart / kBlockSize) * kBlockSize;

	int32 end = blockEnd;
	if (end > first + (int32)kBlockSize - 1)
		end = first + kBlockSize - 1;

	FillRect(SelectionFrame(which, first + start, end));
	first += kBlockSize;

	// draw block (and last line) if necessary

	end = blockEnd % kBlockSize;
	int32 last = (blockEnd / kBlockSize) * kBlockSize;

	if (last >= first) {
		if (end == kBlockSize - 1)
			last += kBlockSize;

		if (last > first)
			FillRect(SelectionFrame(which, first, last - 1));
		if (end != kBlockSize - 1)
			FillRect(SelectionFrame(which, last, last + end));
	}

	SetDrawingMode(B_OP_COPY);
}


void
DataView::DrawSelectionBlock(view_focus which)
{
	DrawSelectionBlock(which, fStart, fEnd);
}


void
DataView::DrawSelection(bool frameOnly)
{
	if (IsFocus() && fIsActive) {
		if (!frameOnly)
			DrawSelectionBlock(fFocus);
		DrawSelectionFrame(fFocus == kHexFocus ? kAsciiFocus : kHexFocus);
	} else {
		DrawSelectionFrame(kHexFocus);
		DrawSelectionFrame(kAsciiFocus);
	}
}


void
DataView::SetSelection(int32 start, int32 end, view_focus focus)
{
	// correct the values if necessary

	if (start > end) {
		int32 temp = start;
		start = end;
		end = temp;
	}

	if (start > (int32)fSizeInView - 1)
		start = (int32)fSizeInView - 1;
	if (start < 0)
		start = 0;

	if (end > (int32)fSizeInView - 1)
		end = (int32)fSizeInView - 1;
	if (end < 0)
		end = 0;

	if (fStart == start && fEnd == end) {
		// nothing has changed, no need to update
		return;
	}

	// notify our listeners
	if (fStart != start) {
		BMessage update;
		update.AddInt64("position", start);
		SendNotices(kDataViewCursorPosition, &update);
	}

	BMessage update;
	update.AddInt64("start", start);
	update.AddInt64("end", end);
	SendNotices(kDataViewSelection, &update);

	// Update selection - first, we need to remove the old selection, then
	// we redraw the selection with the current values.

	DrawSelection(focus == kNoFocus);
		// From the block selection, only the parts that need updating are
		// actually updated, if there is no focus change.

	if (IsFocus() && fIsActive && focus == kNoFocus) {
		// Update the selection block incrementally

		if (start > fStart) {
			// remove from the top
			DrawSelectionBlock(fFocus, fStart, start - 1);
		} else if (start < fStart) {
			// add to the top
			DrawSelectionBlock(fFocus, start, fStart - 1);
		}

		if (end < fEnd) {
			// remove from bottom
			DrawSelectionBlock(fFocus, end + 1, fEnd);
		} else if (end > fEnd) {
			// add to the bottom
			DrawSelectionBlock(fFocus, fEnd + 1, end);
		}
	}

	if (focus != kNoFocus)
		fFocus = focus;
	fStart = start;
	fEnd = end;

	DrawSelection(focus == kNoFocus);

	fBitPosition = 0;
}


void
DataView::GetSelection(int32 &start, int32 &end)
{
	start = fStart;
	end = fEnd;
}


void
DataView::InvalidateRange(int32 start, int32 end)
{
	if (start <= 0 && end >= int32(fDataSize) - 1) {
		Invalidate();
		return;
	}

	int32 startLine = start / kBlockSize;
	int32 endLine = end / kBlockSize;

	if (endLine > startLine) {
		start = startLine * kBlockSize;
		end = (endLine + 1) * kBlockSize - 1;
	}

	// the part with focus
	BRect rect = SelectionFrame(fFocus, start, end);
	rect.bottom++;
	rect.right++;
	Invalidate(rect);

	// the part without focus
	rect = SelectionFrame(fFocus == kHexFocus ? kAsciiFocus : kHexFocus, start, end);
	rect.bottom++;
	rect.right++;
	Invalidate(rect);
}


void
DataView::MakeVisible(int32 position)
{
	if (position < 0 || position > int32(fDataSize) - 1)
		return;

	BRect frame = SelectionFrame(fFocus, position, position);
	BRect bounds = Bounds();
	if (bounds.Contains(frame))
		return;

	// special case the first and the last line and column, so that
	// we can take kHorizontalSpace & kVerticalSpace into account

	if ((position % kBlockSize) == 0)
		frame.left -= kHorizontalSpace;
	else if ((position % kBlockSize) == kBlockSize - 1)
		frame.right += kHorizontalSpace;

	if (position < int32(kBlockSize))
		frame.top -= kVerticalSpace;
	else if (position > int32(fDataSize - kBlockSize))
		frame.bottom += kVerticalSpace;

	// compute the scroll point

	BPoint point = bounds.LeftTop();
	if (bounds.left > frame.left)
		point.x = frame.left;
	else if (bounds.right < frame.right)
		point.x = frame.right - bounds.Width();

	if (bounds.top > frame.top)
		point.y = frame.top;
	else if (bounds.bottom < frame.bottom)
		point.y = frame.bottom - bounds.Height();

	ScrollTo(point);
}


const uint8 *
DataView::DataAt(int32 start)
{
	if (start < 0 || start >= int32(fSizeInView) || fData == NULL)
		return NULL;

	return fData + start;
}


/*static*/ int32
DataView::WidthForFontSize(float size)
{
	BFont font = be_fixed_font;
	font.SetSize(size);

	float charWidth = font.StringWidth("w");
	return (int32)ceilf(charWidth * (kBlockSize * 4 + kPositionLength + 6)
		+ 2 * kHorizontalSpace);
}


void
DataView::SetBase(base_type type)
{
	if (fBase == type)
		return;

	fBase = type;
	Invalidate();
}


void
DataView::SetFocus(view_focus which)
{
	if (which == fFocus)
		return;

	DrawSelection();
	fFocus = which;
	DrawSelection();
}


void
DataView::SetActive(bool active)
{
	if (active == fIsActive)
		return;

	fIsActive = active;

	// only redraw the focussed part

	if (IsFocus() && active) {
		DrawSelectionFrame(fFocus);
		DrawSelectionBlock(fFocus);
	} else {
		DrawSelectionBlock(fFocus);
		DrawSelectionFrame(fFocus);
	}
}


void
DataView::WindowActivated(bool active)
{
	BView::WindowActivated(active);
	SetActive(active);
}


void
DataView::MakeFocus(bool focus)
{
	bool previous = IsFocus();
	BView::MakeFocus(focus);

	if (focus == previous)
		return;

	if (Window()->IsActive() && focus)
		SetActive(true);
	else if (!Window()->IsActive() || !focus)
		SetActive(false);
}


void
DataView::UpdateScroller()
{
	float width, height;
	GetPreferredSize(&width, &height);

	SetExplicitMinSize(BSize(250, 200));
	SetExplicitMaxSize(BSize(B_SIZE_UNSET, height));
	SetExplicitPreferredSize(BSize(width, height));

	BScrollBar *bar;
	if ((bar = ScrollBar(B_HORIZONTAL)) != NULL) {
		float delta = width - Bounds().Width();
		if (delta < 0)
			delta = 0;

		bar->SetRange(0, delta);
		bar->SetSteps(fCharWidth, Bounds().Width());
		bar->SetProportion(Bounds().Width() / width);
	}
	if ((bar = ScrollBar(B_VERTICAL)) != NULL) {
		float delta = height - Bounds().Height();
		if (delta < 0)
			delta = 0;

		bar->SetRange(0, delta);
		bar->SetSteps(fFontHeight, Bounds().Height());
		bar->SetProportion(Bounds().Height() / height);
	}
}


void
DataView::FrameResized(float width, float height)
{
	if (fFitFontSize) {
		// adapt the font size to fit in the view's bounds
		float oldSize = FontSize();
		float steps = 0.5f;

		float size;
		for (size = 1.f; size < 100; size += steps) {
			int32 preferredWidth = WidthForFontSize(size);
			if (preferredWidth > width)
				break;

			if (size > 6)
				steps = 1.0f;
		}
		size -= steps;

		if (oldSize != size) {
			BFont font = be_fixed_font;
			font.SetSize(size);
			SetFont(&font);

			Invalidate();
		}
	}

	UpdateScroller();
}


void
DataView::InitiateDrag(view_focus focus)
{
	BMessage *drag = new BMessage(B_MIME_DATA);

	// Add originator and action
	drag->AddPointer("be:originator", this);
	//drag->AddString("be:clip_name", "Byte Clipping");
	//drag->AddInt32("be_actions", B_TRASH_TARGET);

	// Add data (just like in Copy())
	uint8 *data = fData + fStart;
	size_t length = fEnd + 1 - fStart;

	drag->AddData(B_FILE_MIME_TYPE, B_MIME_TYPE, data, length);
	if (is_valid_utf8(data, length))
		drag->AddData("text/plain", B_MIME_TYPE, data, length);

	// get a frame that contains the whole selection - SelectionFrame()
	// only spans a rectangle between the start and the end point, so
	// we have to pass it the correct input values

	BRect frame;
	const int32 width = kBlockSize - 1;
	int32 first = fStart & ~width;
	int32 last = ((fEnd + width) & ~width) - 1;
	if (first == (last & ~width))
		frame = SelectionFrame(focus, fStart, fEnd);
	else
		frame = SelectionFrame(focus, first, last);

	BRect bounds = Bounds();
	if (!bounds.Contains(frame))
		frame = bounds & frame;

	DragMessage(drag, frame, NULL);

	fStoredStart = fStart;
	fStoredEnd = fEnd;
	fDragMessageSize = length;
}


void
DataView::MouseDown(BPoint where)
{
	MakeFocus(true);

	BMessage *message = Looper()->CurrentMessage();
	int32 buttons;
	if (message == NULL || message->FindInt32("buttons", &buttons) != B_OK)
		return;

	view_focus newFocus;
	int32 position = PositionAt(kNoFocus, where, &newFocus);

	if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0
		&& position >= fStart && position <= fEnd) {
		InitiateDrag(newFocus);
		return;
	}

	if ((buttons & B_PRIMARY_MOUSE_BUTTON) == 0)
		return;

	int32 modifiers = message->FindInt32("modifiers");

	fMouseSelectionStart = position;
	if (fMouseSelectionStart == -1) {
		// "where" is outside the valid frame
		return;
	}

	int32 selectionEnd = fMouseSelectionStart;
	if (modifiers & B_SHIFT_KEY) {
		// enlarge the current selection
		if (fStart < selectionEnd)
			fMouseSelectionStart = fStart;
		else if (fEnd > selectionEnd)
			fMouseSelectionStart = fEnd;
	}
	SetSelection(fMouseSelectionStart, selectionEnd, newFocus);

	SetMouseEventMask(B_POINTER_EVENTS,
		B_NO_POINTER_HISTORY | B_SUSPEND_VIEW_FOCUS | B_LOCK_WINDOW_FOCUS);
}


void
DataView::MouseMoved(BPoint where, uint32 transit, const BMessage *dragMessage)
{
	if (transit == B_EXITED_VIEW && fDragMessageSize > 0) {
		SetSelection(fStoredStart, fStoredEnd);
		fDragMessageSize = -1;
	}

	if (dragMessage && AcceptsDrop(dragMessage)) {
		// handle drag message and tracking

		if (transit == B_ENTERED_VIEW) {
			fStoredStart = fStart;
			fStoredEnd = fEnd;

			const void *data;
			ssize_t size;
			if (dragMessage->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK
				|| dragMessage->FindData("text/plain", B_MIME_TYPE, &data, &size) == B_OK)
				fDragMessageSize = size;
		} else if (fDragMessageSize > 0) {
			view_focus newFocus;
			int32 start = PositionAt(kNoFocus, where, &newFocus);
			int32 end = start + fDragMessageSize - 1;

			SetSelection(start, end);
			MakeVisible(start);
		}
		return;
	}

	if (fMouseSelectionStart == -1)
		return;

	int32 end = PositionAt(fFocus, where);
	if (end == -1)
		return;

	SetSelection(fMouseSelectionStart, end);
	MakeVisible(end);
}


void
DataView::MouseUp(BPoint where)
{
	fMouseSelectionStart = fKeySelectionStart = -1;
}


void
DataView::KeyDown(const char *bytes, int32 numBytes)
{
	int32 modifiers;
	if (Looper()->CurrentMessage() == NULL
		|| Looper()->CurrentMessage()->FindInt32("modifiers", &modifiers) != B_OK)
		modifiers = ::modifiers();

	// check if the selection is going to be changed
	switch (bytes[0]) {
		case B_LEFT_ARROW:
		case B_RIGHT_ARROW:
		case B_UP_ARROW:
		case B_DOWN_ARROW:
			if (modifiers & B_SHIFT_KEY) {
				if (fKeySelectionStart == -1)
					fKeySelectionStart = fStart;
			} else
				fKeySelectionStart = -1;
			break;
	}

	switch (bytes[0]) {
		case B_LEFT_ARROW:
		{
			int32 position = fStart - 1;

			if (modifiers & B_SHIFT_KEY) {
				if (fKeySelectionStart == fEnd)
					SetSelection(fStart - 1, fEnd);
				else {
					SetSelection(fStart, fEnd - 1);
					position = fEnd;
				}
			} else
				SetSelection(fStart - 1, fStart - 1);

			MakeVisible(position);
			break;
		}
		case B_RIGHT_ARROW:
		{
			int32 position = fEnd + 1;

			if (modifiers & B_SHIFT_KEY) {
				if (fKeySelectionStart == fStart)
					SetSelection(fStart, fEnd + 1);
				else
					SetSelection(fStart + 1, fEnd);
			} else
				SetSelection(fEnd + 1, fEnd + 1);

			MakeVisible(position);
			break;
		}
		case B_UP_ARROW:
		{
			int32 start, end;
			if (modifiers & B_SHIFT_KEY) {
				if (fKeySelectionStart == fStart) {
					start = fEnd - int32(kBlockSize);
					end = fStart;
				} else {
					start = fStart - int32(kBlockSize);
					end = fEnd;
				}
				if (start < 0)
					start = 0;
			} else {
				start = fStart - int32(kBlockSize);
				if (start < 0)
					start = fStart;

				end = start;
			}

			SetSelection(start, end);
			MakeVisible(start);
			break;
		}
		case B_DOWN_ARROW:
		{
			int32 start, end;
			if (modifiers & B_SHIFT_KEY) {
				if (fKeySelectionStart == fEnd) {
					start = fEnd;
					end = fStart + int32(kBlockSize);
				} else {
					start = fStart;
					end = fEnd + int32(kBlockSize);
				}
				if (end >= int32(fSizeInView))
					end = int32(fSizeInView) - 1;
			} else {
				end = fEnd + int32(kBlockSize);
				if (end >= int32(fSizeInView))
					start = fEnd;

				start = end;
			}

			SetSelection(start, end);
			MakeVisible(end);
			break;
		}

		case B_PAGE_UP:
		{
			// scroll one page up, but keep the same cursor column

			BRect frame = SelectionFrame(fFocus, fStart, fStart);
			frame.OffsetBy(0, -Bounds().Height());
			if (frame.top <= kVerticalSpace)
				frame.top = kVerticalSpace + 1;
			ScrollBy(0, -Bounds().Height());

			int32 position = PositionAt(fFocus, frame.LeftTop());
			SetSelection(position, position);
			break;
		}
		case B_PAGE_DOWN:
		{
			// scroll one page down, but keep the same cursor column

			BRect frame = SelectionFrame(fFocus, fStart, fStart);
			frame.OffsetBy(0, Bounds().Height());

			float lastLine = DataBounds().Height() - 1 - kVerticalSpace;
			if (frame.top > lastLine)
				frame.top = lastLine;
			ScrollBy(0, Bounds().Height());

			int32 position = PositionAt(fFocus, frame.LeftTop());
			SetSelection(position, position);
			break;
		}
		case B_HOME:
			SetSelection(0, 0);
			MakeVisible(fStart);
			break;
		case B_END:
			SetSelection(fDataSize - 1, fDataSize - 1);
			MakeVisible(fStart);
			break;
		case B_TAB:
			SetFocus(fFocus == kHexFocus ? kAsciiFocus : kHexFocus);
			MakeVisible(fStart);
			break;

		case B_FUNCTION_KEY:
			// this is ignored
			break;

		case B_BACKSPACE:
			if (fBitPosition == 0)
				SetSelection(fStart - 1, fStart - 1);

			if (fFocus == kHexFocus)
				fBitPosition = (fBitPosition + 4) % 8;

			// supposed to fall through
		case B_DELETE:
			SetSelection(fStart, fStart);
				// to make sure only the cursor is selected

			if (fFocus == kHexFocus) {
				const uint8 *data = DataAt(fStart);
				if (data == NULL)
					break;

				uint8 c = data[0] & (fBitPosition == 0 ? 0x0f : 0xf0);
					// mask out region to be cleared

				fEditor.Replace(fOffset + fStart, &c, 1);
			} else
				fEditor.Replace(fOffset + fStart, (const uint8 *)"", 1);
			break;

		default:
			if (fFocus == kHexFocus) {
				// only hexadecimal characters are allowed to be entered
				const uint8 *data = DataAt(fStart);
				uint8 c = bytes[0];
				if (c >= 'A' && c <= 'F')
					c += 'A' - 'a';
				const char *hexNumbers = "0123456789abcdef";
				addr_t number;
				if (data == NULL
						|| (number = (addr_t)strchr(hexNumbers, c)) == 0)
					break;

				SetSelection(fStart, fStart);
					// to make sure only the cursor is selected

				number -= (addr_t)hexNumbers;
				fBitPosition = (fBitPosition + 4) % 8;

				c = (data[0] & (fBitPosition ? 0x0f : 0xf0))
					| (number << fBitPosition);
					// mask out overwritten region and bit-wise or the number
					// to be inserted

				if (fEditor.Replace(fOffset + fStart, &c, 1) == B_OK
						&& fBitPosition == 0)
					SetSelection(fStart + 1, fStart + 1);
			} else {
				if (fEditor.Replace(fOffset + fStart, (const uint8 *)bytes,
						numBytes) == B_OK)
					SetSelection(fStart + 1, fStart + 1);
			}
			break;
	}
}


void
DataView::SetFont(const BFont *font, uint32 properties)
{
	// Even in a full and hal fixed font, the characters we use (all in the
	// Latin-1 range as everything else is filtered out) will all have the same
	// width.
	if (!font->IsFixed() && !font->IsFullAndHalfFixed())
		return;

	BView::SetFont(font, properties);

	font_height fontHeight;
	font->GetHeight(&fontHeight);

	fFontHeight = int32(fontHeight.ascent + fontHeight.descent
		+ fontHeight.leading);
	fAscent = fontHeight.ascent;
	fCharWidth = font->StringWidth("w");
}


float
DataView::FontSize() const
{
	BFont font;
	GetFont(&font);

	return font.Size();
}


void
DataView::SetFontSize(float point)
{
	bool fit = (point == 0.0f);
	if (fit) {
		if (!fFitFontSize)
			SendNotices(kDataViewPreferredSize);
		fFitFontSize = fit;

		FrameResized(Bounds().Width(), Bounds().Height());
		return;
	}

	fFitFontSize = false;

	BFont font = be_fixed_font;
	font.SetSize(point);

	SetFont(&font);
	UpdateScroller();
	Invalidate();

	SendNotices(kDataViewPreferredSize);
}


void
DataView::GetPreferredSize(float *_width, float *_height)
{
	BRect bounds = DataBounds();

	if (_width)
		*_width = bounds.Width();

	if (_height)
		*_height = bounds.Height();
}