haiku.git

/*
 * Copyright 2013-2015, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "TextDocumentLayout.h"

#include <new>
#include <stdio.h>

#include <View.h>


class LayoutTextListener : public TextListener {
public:
	LayoutTextListener(TextDocumentLayout* layout)
		:
		fLayout(layout)
	{
	}

	virtual	void TextChanging(TextChangingEvent& event)
	{
	}

	virtual	void TextChanged(const TextChangedEvent& event)
	{
//		printf("TextChanged(%" B_PRIi32 ", %" B_PRIi32 ")\n",
//			event.FirstChangedParagraph(),
//			event.ChangedParagraphCount());
		// TODO: The event does not contain useful data. Make the event
		// system work so only the affected paragraphs are updated.
		// I think we need "first affected", "last affected" (both relative
		// to the original paragraph count), and than how many new paragraphs
		// are between these. From the difference in old number of paragraphs
		// inbetween and the new count, we know how many new paragraphs are
		// missing, and the rest in the range needs to be updated.
//		fLayout->InvalidateParagraphs(event.FirstChangedParagraph(),
//			event.ChangedParagraphCount());
		fLayout->Invalidate();
	}

private:
	TextDocumentLayout*	fLayout;
};



TextDocumentLayout::TextDocumentLayout()
	:
	fWidth(0.0f),
	fLayoutValid(false),

	fDocument(),
	fTextListener(new(std::nothrow) LayoutTextListener(this), true),
	fParagraphLayouts()
{
}


TextDocumentLayout::TextDocumentLayout(const TextDocumentRef& document)
	:
	fWidth(0.0f),
	fLayoutValid(false),

	fDocument(),
	fTextListener(new(std::nothrow) LayoutTextListener(this), true),
	fParagraphLayouts()
{
	SetTextDocument(document);
}


TextDocumentLayout::TextDocumentLayout(const TextDocumentLayout& other)
	:
	fWidth(other.fWidth),
	fLayoutValid(other.fLayoutValid),

	fDocument(other.fDocument),
	fTextListener(new(std::nothrow) LayoutTextListener(this), true),
	fParagraphLayouts(other.fParagraphLayouts)
{
	if (fDocument.IsSet())
		fDocument->AddListener(fTextListener);
}


TextDocumentLayout::~TextDocumentLayout()
{
	SetTextDocument(NULL);
}


void
TextDocumentLayout::SetTextDocument(const TextDocumentRef& document)
{
	if (fDocument == document)
		return;

	if (fDocument.IsSet())
		fDocument->RemoveListener(fTextListener);

	fDocument = document;
	_Init();
	fLayoutValid = false;

	if (fDocument.IsSet())
		fDocument->AddListener(fTextListener);
}


void
TextDocumentLayout::Invalidate()
{
	if (fDocument.IsSet())
		InvalidateParagraphs(0, fDocument->CountParagraphs());
}


void
TextDocumentLayout::InvalidateParagraphs(int32 start, int32 count)
{
	if (start < 0 || count == 0 || !fDocument.IsSet())
		return;

	fLayoutValid = false;

	while (count > 0) {
		const int32 paragraphCount = fDocument->CountParagraphs();
		if (start >= paragraphCount)
			break;
		const Paragraph& paragraph = fDocument->ParagraphAtIndex(start);
		if (start >= static_cast<int32>(fParagraphLayouts.size())) {
			ParagraphLayoutRef layout(new(std::nothrow) ParagraphLayout(
				paragraph), true);
			if (!layout.IsSet()) {
				fprintf(stderr, "TextDocumentLayout::InvalidateParagraphs() - "
					"out of memory\n");
				return;
			}
			try {
				fParagraphLayouts.push_back(ParagraphLayoutInfo(0.0f, layout));
			}
			catch (std::bad_alloc& ba) {
				fprintf(stderr, "bad_alloc when invalidating paragraphs\n");
				return;
			}
		} else {
			const ParagraphLayoutInfo& info = fParagraphLayouts[start];
			info.layout->SetParagraph(paragraph);
		}

		start++;
		count--;
	}

	// Remove any extra paragraph layouts
	while (fDocument->CountParagraphs()
			< static_cast<int32>(fParagraphLayouts.size()))
		fParagraphLayouts.erase(fParagraphLayouts.end() - 1);
}


void
TextDocumentLayout::SetWidth(float width)
{
	if (fWidth != width) {
		fWidth = width;
		fLayoutValid = false;
	}
}


float
TextDocumentLayout::Height()
{
	_ValidateLayout();

	float height = 0.0f;

	if (fParagraphLayouts.size() > 0) {
		const ParagraphLayoutInfo& lastLayout
			= fParagraphLayouts[fParagraphLayouts.size() - 1];
		height = lastLayout.y + lastLayout.layout->Height();
	}

	return height;
}


void
TextDocumentLayout::Draw(BView* view, const BPoint& offset,
	const BRect& updateRect)
{
	_ValidateLayout();

	int layoutCount = fParagraphLayouts.size();
	for (int i = 0; i < layoutCount; i++) {
		const ParagraphLayoutInfo& layout = fParagraphLayouts[i];
		BPoint location(offset.x, offset.y + layout.y);
		if (location.y > updateRect.bottom)
			break;
		if (location.y + layout.layout->Height() > updateRect.top)
			layout.layout->Draw(view, location);
	}
}


int32
TextDocumentLayout::LineIndexForOffset(int32 textOffset)
{
	int32 index = _ParagraphLayoutIndexForOffset(textOffset);
	if (index >= 0) {
		int32 lineIndex = 0;
		for (int32 i = 0; i < index; i++) {
			lineIndex += fParagraphLayouts[i].layout->CountLines();
		}

		const ParagraphLayoutInfo& info = fParagraphLayouts[index];
		return lineIndex + info.layout->LineIndexForOffset(textOffset);
	}

	return 0;
}


int32
TextDocumentLayout::FirstOffsetOnLine(int32 lineIndex)
{
	int32 paragraphOffset;
	int32 index = _ParagraphLayoutIndexForLineIndex(lineIndex, paragraphOffset);
	if (index >= 0) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[index];
		return info.layout->FirstOffsetOnLine(lineIndex) + paragraphOffset;
	}

	return 0;
}


int32
TextDocumentLayout::LastOffsetOnLine(int32 lineIndex)
{
	int32 paragraphOffset;
	int32 index = _ParagraphLayoutIndexForLineIndex(lineIndex, paragraphOffset);
	if (index >= 0) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[index];
		return info.layout->LastOffsetOnLine(lineIndex) + paragraphOffset;
	}

	return 0;
}


int32
TextDocumentLayout::CountLines()
{
	_ValidateLayout();

	int32 lineCount = 0;

	int32 count = fParagraphLayouts.size();
	for (int32 i = 0; i < count; i++) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[i];
		lineCount += info.layout->CountLines();
	}

	return lineCount;
}


void
TextDocumentLayout::GetLineBounds(int32 lineIndex, float& x1, float& y1,
	float& x2, float& y2)
{
	int32 paragraphOffset;
	int32 index = _ParagraphLayoutIndexForLineIndex(lineIndex, paragraphOffset);
	if (index >= 0) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[index];
		info.layout->GetLineBounds(lineIndex, x1, y1, x2, y2);
		y1 += info.y;
		y2 += info.y;
		return;
	}

	x1 = 0.0f;
	y1 = 0.0f;
	x2 = 0.0f;
	y2 = 0.0f;
}


void
TextDocumentLayout::GetTextBounds(int32 textOffset, float& x1, float& y1,
	float& x2, float& y2)
{
	int32 index = _ParagraphLayoutIndexForOffset(textOffset);
	if (index >= 0) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[index];
		info.layout->GetTextBounds(textOffset, x1, y1, x2, y2);
		y1 += info.y;
		y2 += info.y;
		return;
	}

	x1 = 0.0f;
	y1 = 0.0f;
	x2 = 0.0f;
	y2 = 0.0f;
}


int32
TextDocumentLayout::TextOffsetAt(float x, float y, bool& rightOfCenter)
{
	_ValidateLayout();

	int32 textOffset = 0;
	rightOfCenter = false;

	int32 paragraphs = fParagraphLayouts.size();
	for (int32 i = 0; i < paragraphs; i++) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[i];
		if (y > info.y + info.layout->Height()) {
			textOffset += info.layout->CountGlyphs();
			continue;
		}

		textOffset += info.layout->TextOffsetAt(x, y - info.y, rightOfCenter);
		break;
	}

	return textOffset;
}

// #pragma mark - private


void
TextDocumentLayout::_ValidateLayout()
{
	if (!fLayoutValid) {
		_Layout();
		fLayoutValid = true;
	}
}


void
TextDocumentLayout::_Init()
{
	fParagraphLayouts.clear();

	if (!fDocument.IsSet())
		return;

	int paragraphCount = fDocument->CountParagraphs();
	for (int i = 0; i < paragraphCount; i++) {
		const Paragraph& paragraph = fDocument->ParagraphAtIndex(i);
		ParagraphLayoutRef layout(new(std::nothrow) ParagraphLayout(paragraph),
			true);
		if (!layout.IsSet()) {
			fprintf(stderr, "TextDocumentLayout::_Layout() - out of memory\n");
			return;
		}
		try {
			fParagraphLayouts.push_back(ParagraphLayoutInfo(0.0f, layout));
		}
		catch (std::bad_alloc& ba) {
			fprintf(stderr, "bad_alloc when inititalizing the text document "
				"layout\n");
			return;
		}
	}
}


void
TextDocumentLayout::_Layout()
{
	float y = 0.0f;

	int layoutCount = fParagraphLayouts.size();
	for (int i = 0; i < layoutCount; i++) {
		ParagraphLayoutInfo info = fParagraphLayouts[i];
		const ParagraphStyle& style = info.layout->Style();

		if (i > 0)
			y += style.SpacingTop();

		fParagraphLayouts[i] = ParagraphLayoutInfo(y, info.layout);

		info.layout->SetWidth(fWidth);
		y += info.layout->Height() + style.SpacingBottom();
	}
}


int32
TextDocumentLayout::_ParagraphLayoutIndexForOffset(int32& textOffset)
{
	_ValidateLayout();

	int32 paragraphs = fParagraphLayouts.size();
	for (int32 i = 0; i < paragraphs - 1; i++) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[i];

		int32 length = info.layout->CountGlyphs();
		if (textOffset >= length) {
			textOffset -= length;
			continue;
		}

		return i;
	}

	if (paragraphs > 0) {
		const ParagraphLayoutInfo& info
			= fParagraphLayouts[fParagraphLayouts.size() - 1];

		// Return last paragraph if the textOffset is still within or
		// exactly behind the last valid offset in that paragraph.
		int32 length = info.layout->CountGlyphs();
		if (textOffset <= length)
			return paragraphs - 1;
	}

	return -1;
}

int32
TextDocumentLayout::_ParagraphLayoutIndexForLineIndex(int32& lineIndex,
	int32& paragraphOffset)
{
	_ValidateLayout();

	paragraphOffset = 0;
	int32 paragraphs = fParagraphLayouts.size();
	for (int32 i = 0; i < paragraphs; i++) {
		const ParagraphLayoutInfo& info = fParagraphLayouts[i];

		int32 lineCount = info.layout->CountLines();
		if (lineIndex >= lineCount) {
			lineIndex -= lineCount;
			paragraphOffset += info.layout->CountGlyphs();
			continue;
		}

		return i;
	}

	return -1;
}