haiku.git

/*
 * Copyright 2001-2006 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Marc Flerackers, mflerackers@androme.be
 *		Stefano Ceccherini, burton666@libero.it
 */

/**	Style storage used by BTextView */


#include "InlineInput.h"
#include "StyleBuffer.h"

#include <View.h>

#include <stdio.h>


//	#pragma mark - _BStyleRunDescBuffer_


_BStyleRunDescBuffer_::_BStyleRunDescBuffer_()
	:
	_BTextViewSupportBuffer_<STEStyleRunDesc>(20)
{
}


void
_BStyleRunDescBuffer_::InsertDesc(STEStyleRunDesc* inDesc, int32 index)
{
	InsertItemsAt(1, index, inDesc);
}


void
_BStyleRunDescBuffer_::RemoveDescs(int32 index, int32 count)
{
	RemoveItemsAt(count, index);
}


int32
_BStyleRunDescBuffer_::OffsetToRun(int32 offset) const
{
	if (fItemCount <= 1)
		return 0;

	int32 minIndex = 0;
	int32 maxIndex = fItemCount;
	int32 index = 0;

	while (minIndex < maxIndex) {
		index = (minIndex + maxIndex) >> 1;
		if (offset >= fBuffer[index].offset) {
			if (index >= fItemCount - 1
				|| offset < fBuffer[index + 1].offset) {
				break;
			} else
				minIndex = index + 1;
		} else
			maxIndex = index;
	}

	return index;
}


void
_BStyleRunDescBuffer_::BumpOffset(int32 delta, int32 index)
{
	for (int32 i = index; i < fItemCount; i++)
		fBuffer[i].offset += delta;
}


//	#pragma mark - _BStyleRecordBuffer_


_BStyleRecordBuffer_::_BStyleRecordBuffer_()
	:
	_BTextViewSupportBuffer_<STEStyleRecord>()
{
}


int32
_BStyleRecordBuffer_::InsertRecord(const BFont* inFont,
	const rgb_color* inColor)
{
	int32 index = 0;

	// look for style in buffer
	if (MatchRecord(inFont, inColor, &index))
		return index;

	// style not found, add it
	font_height fh;
	inFont->GetHeight(&fh);

	// check if there's any unused space
	for (index = 0; index < fItemCount; index++) {
		if (fBuffer[index].refs < 1) {
			fBuffer[index].refs = 0;
			fBuffer[index].ascent = fh.ascent;
			fBuffer[index].descent = fh.descent + fh.leading;
			fBuffer[index].style.font = *inFont;
			fBuffer[index].style.color = *inColor;
			return index;
		}
	}

	// no unused space, expand the buffer
	const STEStyle style = { *inFont, *inColor };
	const STEStyleRecord newRecord = {
		0,
		fh.ascent,
		fh.descent + fh.leading,
		style
	};
	InsertItemsAt(1, fItemCount, &newRecord);

	return index;
}


void
_BStyleRecordBuffer_::CommitRecord(int32 index)
{
	fBuffer[index].refs++;
}


void
_BStyleRecordBuffer_::RemoveRecord(int32 index)
{
	fBuffer[index].refs--;
}


bool
_BStyleRecordBuffer_::MatchRecord(const BFont* inFont, const rgb_color* inColor,
	int32* outIndex)
{
	for (int32 i = 0; i < fItemCount; i++) {
		if (*inFont == fBuffer[i].style.font
			&& *inColor == fBuffer[i].style.color) {
			*outIndex = i;
			return true;
		}
	}

	return false;
}


//	#pragma mark - SetStyleFromMode


static void
SetStyleFromMode(uint32 mode, const BFont* fromFont, BFont* toFont,
	const rgb_color* fromColor, rgb_color* toColor)
{
	if (fromFont != NULL && toFont != NULL) {
		if ((mode & B_FONT_FAMILY_AND_STYLE) != 0)
			toFont->SetFamilyAndStyle(fromFont->FamilyAndStyle());

		if ((mode & B_FONT_FACE) != 0)
			toFont->SetFace(fromFont->Face());

		if ((mode & B_FONT_SIZE) != 0)
			toFont->SetSize(fromFont->Size());

		if ((mode & B_FONT_SHEAR) != 0)
			toFont->SetShear(fromFont->Shear());

		if ((mode & B_FONT_FALSE_BOLD_WIDTH) != 0)
			toFont->SetFalseBoldWidth(fromFont->FalseBoldWidth());
	}

	if (fromColor != NULL && toColor != NULL
		&& (mode == 0 || mode == B_FONT_ALL)) {
		*toColor = *fromColor;
	}
}


//	#pragma mark - BTextView::StyleBuffer


BTextView::StyleBuffer::StyleBuffer(const BFont* inFont,
	const rgb_color* inColor)
	:
	fValidNullStyle(true)
{
	fNullStyle.font = *inFont;
	fNullStyle.color = *inColor;
}


void
BTextView::StyleBuffer::InvalidateNullStyle()
{
	fValidNullStyle = false;
}


bool
BTextView::StyleBuffer::IsValidNullStyle() const
{
	return fValidNullStyle;
}


void
BTextView::StyleBuffer::SyncNullStyle(int32 offset)
{
	if (fValidNullStyle || fStyleRunDesc.ItemCount() < 1)
		return;

	int32 index = OffsetToRun(offset);
	fNullStyle = fStyleRecord[fStyleRunDesc[index]->index]->style;

	fValidNullStyle = true;
}


void
BTextView::StyleBuffer::SetNullStyle(uint32 inMode, const BFont* inFont,
	const rgb_color* inColor, int32 offset)
{
	if (fValidNullStyle || fStyleRunDesc.ItemCount() < 1) {
		SetStyleFromMode(inMode, inFont, &fNullStyle.font, inColor,
			&fNullStyle.color);
	} else {
		int32 index = OffsetToRun(offset - 1);
		fNullStyle = fStyleRecord[fStyleRunDesc[index]->index]->style;
		SetStyleFromMode(inMode, inFont, &fNullStyle.font, inColor,
			&fNullStyle.color);
	}

	fValidNullStyle = true;
}


void
BTextView::StyleBuffer::GetNullStyle(const BFont** font,
	const rgb_color** color) const
{
	if (font != NULL)
		*font = &fNullStyle.font;

	if (color != NULL)
		*color = &fNullStyle.color;
}


STEStyleRange*
BTextView::StyleBuffer::AllocateStyleRange(const int32 numStyles) const
{
	STEStyleRange* range = (STEStyleRange*)malloc(sizeof(int32)
		+ sizeof(STEStyleRun) * numStyles);
	if (range != NULL)
		range->count = numStyles;

	return range;
}


void
BTextView::StyleBuffer::SetStyleRange(int32 fromOffset, int32 toOffset,
	int32 textLen, uint32 inMode, const BFont* inFont,
	const rgb_color* inColor)
{
	if (inFont == NULL)
		inFont = &fNullStyle.font;

	if (inColor == NULL)
		inColor = &fNullStyle.color;

	if (fromOffset == toOffset) {
		SetNullStyle(inMode, inFont, inColor, fromOffset);
		return;
	}

	if (fStyleRunDesc.ItemCount() < 1) {
		STEStyleRunDesc newDesc;
		newDesc.offset = fromOffset;
		newDesc.index = fStyleRecord.InsertRecord(inFont, inColor);
		fStyleRunDesc.InsertDesc(&newDesc, 0);
		fStyleRecord.CommitRecord(newDesc.index);
		return;
	}

	int32 offset = fromOffset;
	int32 runIndex = OffsetToRun(offset);
	int32 styleIndex = 0;
	do {
		const STEStyleRunDesc runDesc = *fStyleRunDesc[runIndex];
		int32 runEnd = textLen;
		if (runIndex < fStyleRunDesc.ItemCount() - 1)
			runEnd = fStyleRunDesc[runIndex + 1]->offset;

		STEStyle style = fStyleRecord[runDesc.index]->style;
		SetStyleFromMode(inMode, inFont, &style.font, inColor, &style.color);

		styleIndex = fStyleRecord.InsertRecord(&style.font, &style.color);

		if (runDesc.offset == offset && runIndex > 0
			&& fStyleRunDesc[runIndex - 1]->index == styleIndex) {
			RemoveStyles(runIndex);
			runIndex--;
		}

		if (styleIndex != runDesc.index) {
			if (offset > runDesc.offset) {
				STEStyleRunDesc newDesc;
				newDesc.offset = offset;
				newDesc.index = styleIndex;
				fStyleRunDesc.InsertDesc(&newDesc, runIndex + 1);
				fStyleRecord.CommitRecord(newDesc.index);
				runIndex++;
			} else {
				fStyleRunDesc[runIndex]->index = styleIndex;
				fStyleRecord.CommitRecord(styleIndex);
			}

			if (toOffset < runEnd) {
				STEStyleRunDesc newDesc;
				newDesc.offset = toOffset;
				newDesc.index = runDesc.index;
				fStyleRunDesc.InsertDesc(&newDesc, runIndex + 1);
				fStyleRecord.CommitRecord(newDesc.index);
			}
		}

		runIndex++;
		offset = runEnd;
	} while (offset < toOffset);

	if (offset == toOffset && runIndex < fStyleRunDesc.ItemCount()
		&& fStyleRunDesc[runIndex]->index == styleIndex) {
		RemoveStyles(runIndex);
	}
}


void
BTextView::StyleBuffer::GetStyle(int32 inOffset, BFont* outFont,
	rgb_color* outColor) const
{
	if (fStyleRunDesc.ItemCount() < 1) {
		if (outFont != NULL)
			*outFont = fNullStyle.font;

		if (outColor != NULL)
			*outColor = fNullStyle.color;

		return;
	}

	int32 runIndex = OffsetToRun(inOffset);
	int32 styleIndex = fStyleRunDesc[runIndex]->index;

	if (outFont != NULL)
		*outFont = fStyleRecord[styleIndex]->style.font;

	if (outColor != NULL)
		*outColor = fStyleRecord[styleIndex]->style.color;
}


STEStyleRange*
BTextView::StyleBuffer::GetStyleRange(int32 startOffset, int32 endOffset) const
{
	int32 startIndex = OffsetToRun(startOffset);
	int32 endIndex = OffsetToRun(endOffset);

	int32 numStyles = endIndex - startIndex + 1;
	if (numStyles < 1)
		numStyles = 1;

	STEStyleRange* result = AllocateStyleRange(numStyles);
	if (result == NULL)
		return NULL;

	STEStyleRun* run = &result->runs[0];
	for (int32 index = 0; index < numStyles; index++) {
		*run = (*this)[startIndex + index];
		run->offset -= startOffset;
		if (run->offset < 0)
			run->offset = 0;

		run++;
	}

	return result;
}


void
BTextView::StyleBuffer::RemoveStyleRange(int32 fromOffset, int32 toOffset)
{
	int32 fromIndex = fStyleRunDesc.OffsetToRun(fromOffset);
	int32 toIndex = fStyleRunDesc.OffsetToRun(toOffset) - 1;

	int32 count = toIndex - fromIndex;
	if (count > 0) {
		RemoveStyles(fromIndex + 1, count);
		toIndex = fromIndex;
	}

	fStyleRunDesc.BumpOffset(fromOffset - toOffset, fromIndex + 1);

	if (toIndex == fromIndex && toIndex < fStyleRunDesc.ItemCount() - 1) {
		STEStyleRunDesc* runDesc = fStyleRunDesc[toIndex + 1];
		runDesc->offset = fromOffset;
	}

	if (fromIndex < fStyleRunDesc.ItemCount() - 1) {
		STEStyleRunDesc* runDesc = fStyleRunDesc[fromIndex];
		if (runDesc->offset == (runDesc + 1)->offset) {
			RemoveStyles(fromIndex);
			fromIndex--;
		}
	}

	if (fromIndex >= 0 && fromIndex < fStyleRunDesc.ItemCount() - 1) {
		STEStyleRunDesc* runDesc = fStyleRunDesc[fromIndex];
		if (runDesc->index == (runDesc + 1)->index)
			RemoveStyles(fromIndex + 1);
	}
}


void
BTextView::StyleBuffer::RemoveStyles(int32 index, int32 count)
{
	for (int32 i = index; i < index + count; i++)
		fStyleRecord.RemoveRecord(fStyleRunDesc[i]->index);

	fStyleRunDesc.RemoveDescs(index, count);
}


int32
BTextView::StyleBuffer::Iterate(int32 fromOffset, int32 length,
	InlineInput* input,
	const BFont** outFont, const rgb_color** outColor,
	float* outAscent, float* outDescent, uint32*) const
{
	// TODO: Handle the InlineInput style here in some way
	int32 numRuns = fStyleRunDesc.ItemCount();
	if (length < 1 || numRuns < 1)
		return 0;

	int32 result = length;
	int32 runIndex = fStyleRunDesc.OffsetToRun(fromOffset);
	STEStyleRunDesc* run = fStyleRunDesc[runIndex];

	if (outFont != NULL)
		*outFont = &fStyleRecord[run->index]->style.font;

	if (outColor != NULL)
		*outColor = &fStyleRecord[run->index]->style.color;

	if (outAscent != NULL)
		*outAscent = fStyleRecord[run->index]->ascent;

	if (outDescent != NULL)
		*outDescent = fStyleRecord[run->index]->descent;

	if (runIndex < numRuns - 1) {
		int32 nextOffset = (run + 1)->offset - fromOffset;
		result = min_c(result, nextOffset);
	}

	return result;
}


int32
BTextView::StyleBuffer::OffsetToRun(int32 offset) const
{
	return fStyleRunDesc.OffsetToRun(offset);
}


void
BTextView::StyleBuffer::BumpOffset(int32 delta, int32 index)
{
	fStyleRunDesc.BumpOffset(delta, index);
}


STEStyleRun
BTextView::StyleBuffer::operator[](int32 index) const
{
	STEStyleRun run;

	if (fStyleRunDesc.ItemCount() < 1) {
		run.offset = 0;
		run.style = fNullStyle;
	} else {
		STEStyleRunDesc* runDesc = fStyleRunDesc[index];
		run.offset = runDesc->offset;
		run.style = fStyleRecord[runDesc->index]->style;
	}

	return run;
}


// TODO: Horrible name, but can't think of a better one
// ? CompareStyles ?
// ? FilterStyles ?
static void
FixupMode(const STEStyle &firstStyle, const STEStyle &otherStyle, uint32 &mode,
	bool &sameColor)
{
	if ((mode & B_FONT_FAMILY_AND_STYLE) != 0) {
		if (firstStyle.font != otherStyle.font)
			mode &= ~B_FONT_FAMILY_AND_STYLE;
	}
	if ((mode & B_FONT_SIZE) != 0) {
		if (firstStyle.font.Size() != otherStyle.font.Size())
			mode &= ~B_FONT_SIZE;
	}
	if ((mode & B_FONT_SHEAR) != 0) {
		if (firstStyle.font.Shear() != otherStyle.font.Shear())
			mode &= ~B_FONT_SHEAR;
	}
	if ((mode & B_FONT_FALSE_BOLD_WIDTH) != 0) {
		if (firstStyle.font.FalseBoldWidth()
				!= otherStyle.font.FalseBoldWidth()) {
			mode &= ~B_FONT_FALSE_BOLD_WIDTH;
		}
	}
	if (firstStyle.color != otherStyle.color)
		sameColor = false;

	// TODO: Finish this: handle B_FONT_FACE, B_FONT_FLAGS, etc.
	// if needed
}


void
BTextView::StyleBuffer::ContinuousGetStyle(BFont *outFont, uint32* ioMode,
	rgb_color* outColor, bool* sameColor, int32 fromOffset,
	int32 toOffset) const
{
	uint32 mode = B_FONT_ALL;

	if (fStyleRunDesc.ItemCount() < 1) {
		if (ioMode)
			*ioMode = mode;

		if (outFont != NULL)
			*outFont = fNullStyle.font;

		if (outColor != NULL)
			*outColor = fNullStyle.color;

		if (sameColor != NULL)
			*sameColor = true;

		return;
	}

	int32 fromIndex = OffsetToRun(fromOffset);
	int32 toIndex = OffsetToRun(toOffset - 1);

	if (fromIndex == toIndex) {
		int32 styleIndex = fStyleRunDesc[fromIndex]->index;
		const STEStyle* style = &fStyleRecord[styleIndex]->style;

		if (ioMode != NULL)
			*ioMode = mode;

		if (outFont != NULL)
			*outFont = style->font;

		if (outColor != NULL)
			*outColor = style->color;

		if (sameColor != NULL)
			*sameColor = true;
	} else {
		bool oneColor = true;
		int32 styleIndex = fStyleRunDesc[toIndex]->index;
		STEStyle theStyle = fStyleRecord[styleIndex]->style;

		for (int32 i = fromIndex; i < toIndex; i++) {
			styleIndex = fStyleRunDesc[i]->index;
			FixupMode(fStyleRecord[styleIndex]->style, theStyle, mode,
				oneColor);
		}

		if (ioMode != NULL)
			*ioMode = mode;

		if (outFont != NULL)
			*outFont = theStyle.font;

		if (outColor != NULL)
			*outColor = theStyle.color;

		if (sameColor != NULL)
			*sameColor = oneColor;
	}
}