haiku.git

#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include "KUndoBuffer.h"


KUndoItem::KUndoItem(const char* redo_text, int32 length, int32 offset,
	undo_type history, int32 cursor_pos)
{
	Offset = offset;
	Length = length;
	History = history;
	CursorPos = cursor_pos;

	if (redo_text != NULL) {
		RedoText = (char*)malloc(length);

		if (RedoText != NULL) {
			memcpy(RedoText, redo_text, length);
			fStatus = B_OK;
		} else
			fStatus = B_ERROR;
	}
}


KUndoItem::~KUndoItem()
{
	free(RedoText);
}


status_t
KUndoItem::InitCheck()
{
	return fStatus;
}


void
KUndoItem::Merge(const char* text, int32 length)
{
	RedoText = (char*)realloc(RedoText, Length + length);
	memcpy(&RedoText[Length], text, length);
	Length += length;
}


KUndoBuffer::KUndoBuffer():BList(1024)
{
	fIndex = 0;
	Off();
	fNewItem = true;
}


KUndoBuffer::~KUndoBuffer()
{
	MakeEmpty();
}


bool
KUndoBuffer::AddItem(KUndoItem* item, int32 index)
{
	for (int32 i = CountItems() - 1; i >= index; i--)
		RemoveItem(i);

	return AddItem(item);
}


bool
KUndoBuffer::AddItem(KUndoItem* item)
{
	return BList::AddItem(item);
}


void
KUndoBuffer::MakeEmpty(void)
{
	for (int32 i = CountItems() - 1; i >= 0; i--)
		RemoveItem(i);
}


KUndoItem*
KUndoBuffer::RemoveItem(int32 index)
{
	if (fIndex >= CountItems())
		fIndex--;
	delete this->ItemAt(index);
	return (KUndoItem*)BList::RemoveItem(index);
}


KUndoItem*
KUndoBuffer::ItemAt(int32 index) const
{
	return (KUndoItem*)BList::ItemAt(index);
}


void
KUndoBuffer::On()
{
	fNoTouch = false;
}


void
KUndoBuffer::Off()
{
	fNoTouch = true;
}


status_t
KUndoBuffer::NewUndo(const char* text, int32 length, int32 offset,
	undo_type history, int32 cursor_pos)
{
	KUndoItem* NewUndoItem = new KUndoItem(text, length, offset, history,
		cursor_pos);

	status_t status = NewUndoItem->InitCheck();
	if (status != B_OK) {
		delete NewUndoItem;
		return status;
	}
	AddItem(NewUndoItem, fIndex);
	fIndex++;
	return status;
}


status_t
KUndoBuffer::AddUndo(const char* text, int32 length, int32 offset,
	undo_type history, int32 cursor_pos)
{
	if (fNoTouch)
		return B_OK;

	status_t status = B_OK;

	if (fNewItem || fIndex < CountItems() || CountItems() == 0) {
		status = NewUndo(text, length, offset, history, cursor_pos);
		fNewItem = false;
	} else {
		KUndoItem* CurrentUndoItem;
		CurrentUndoItem = ItemAt(fIndex - 1);
		if (CurrentUndoItem != NULL) {
			int32 c_length = CurrentUndoItem->Length;
			int32 c_offset = CurrentUndoItem->Offset;
			undo_type c_history = CurrentUndoItem->History;
			if (c_history == history) {
				switch (c_history) {
					case K_INSERTED:
					case K_REPLACED:
						if ((c_offset + c_length) == offset)
							CurrentUndoItem->Merge(text, length);
						else {
							status = NewUndo(text, length, offset, history,
								cursor_pos);
						}
						break;
					case K_DELETED:
						status = NewUndo(text, length, offset, history,
							cursor_pos);
						break;
				}
			} else
				status = NewUndo(text, length, offset, history, cursor_pos);
		}
	}

	return status;
}


status_t
KUndoBuffer::MakeNewUndoItem()
{
	if (fIndex >= CountItems()) {
		fNewItem = true;
		return B_OK;
	}
	return B_ERROR;
}


status_t
KUndoBuffer::Undo(char** text, int32* length, int32* offset,
	undo_type* history, int32* cursor_pos)
{
	KUndoItem* undoItem;
	status_t status = B_ERROR;

	if (fIndex > 0) {
		undoItem = ItemAt(fIndex - 1);
		if (undoItem != NULL) {
			*text = undoItem->RedoText;
			*length = undoItem->Length;
			*offset = undoItem->Offset;
			*history = undoItem->History;
			*cursor_pos = undoItem->CursorPos + undoItem->Length;
			status = B_OK;
		}
		fIndex--;
	}
	return status;
}


status_t
KUndoBuffer::Redo(char** text, int32* length, int32* offset,
	undo_type* history, int32* cursor_pos, bool* replaced)
{
	KUndoItem* undoItem;
	status_t status = B_ERROR;
	
	if (fIndex < CountItems()) {
		undoItem = ItemAt(fIndex);
		if (undoItem != NULL) {
			*text = undoItem->RedoText;
			*length = undoItem->Length;
			*offset = undoItem->Offset;
			*history = undoItem->History;
			*cursor_pos = undoItem->CursorPos;
			if (fIndex + 1 < CountItems())
				*replaced = ItemAt(fIndex + 1)->History == K_REPLACED;
			else
				*replaced = false;
			status = B_OK;
		}
		fIndex++;
	}
	return status;
}


void
KUndoBuffer::PrintToStream()
{
	for (int32 i = 0; i < CountItems(); i++) {
		KUndoItem* item = ItemAt(i);
		printf("%3.3d   ", (int)i);
		switch (item->History) {
			case K_INSERTED:
				printf("INSERTED  ");
				break;
			case K_DELETED:
				printf("DELETED   ");
				break;
			case K_REPLACED:
				printf("REPLACED  ");
				break;
		}
		printf("Offset = %d  ", (int)item->Offset);
		printf("Length = %d  ", (int)item->Length);
		printf("CursorPos = %d  ", (int)item->CursorPos);
		printf("RedoText = '");
		for (int32 j = 0; j < item->Length; j++) {
			uchar c = (uchar)item->RedoText[j];
			if (c >= 0x20)
				printf("%c", c);
			else
				printf("?");
		}
		printf("'\n");
	}
}