haiku.git

/*
 * Copyright 2006-2012, 2023, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */

#include "PathListView.h"

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

#include <Application.h>
#include <Catalog.h>
#include <ListItem.h>
#include <Locale.h>
#include <Menu.h>
#include <MenuItem.h>
#include <Message.h>
#include <Mime.h>
#include <Window.h>

#include "AddPathsCommand.h"
#include "CleanUpPathCommand.h"
#include "CommandStack.h"
#include "MovePathsCommand.h"
#include "Observer.h"
#include "PathSourceShape.h"
#include "RemovePathsCommand.h"
#include "ReversePathCommand.h"
#include "RotatePathIndicesCommand.h"
#include "Shape.h"
#include "Selection.h"
#include "UnassignPathCommand.h"
#include "Util.h"
#include "VectorPath.h"


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Icon-O-Matic-PathsList"


using std::nothrow;

static const float kMarkWidth		= 14.0;
static const float kBorderOffset	= 3.0;
static const float kTextOffset		= 4.0;


class PathListItem : public SimpleItem, public Observer {
public:
	PathListItem(VectorPath* p, PathListView* listView, bool markEnabled)
		:
		SimpleItem(""),
		path(NULL),
		fListView(listView),
		fMarkEnabled(markEnabled),
		fMarked(false)
	{
		SetPath(p);
	}


	virtual ~PathListItem()
	{
		SetPath(NULL);
	}


	// SimpleItem interface
	virtual	void DrawItem(BView* owner, BRect itemFrame, bool even)
	{
		SimpleItem::DrawBackground(owner, itemFrame, even);

		float offset = kBorderOffset + kMarkWidth + kTextOffset;
		SimpleItem::DrawItem(owner, itemFrame.OffsetByCopy(offset, 0), even);

		if (!fMarkEnabled)
			return;

		// mark
		BRect markRect = itemFrame;
		float markRectBorderTint = B_DARKEN_1_TINT;
		float markRectFillTint = 1.04;
		float markTint = B_DARKEN_4_TINT;
					// Dark Themes
		rgb_color lowColor = owner->LowColor();
		if (lowColor.red + lowColor.green + lowColor.blue < 128 * 3) {
			markRectBorderTint = B_LIGHTEN_2_TINT;
			markRectFillTint = 0.85;
			markTint = 0.1;
		}
		markRect.left += kBorderOffset;
		markRect.right = markRect.left + kMarkWidth;
		markRect.top = (markRect.top + markRect.bottom - kMarkWidth) / 2.0;
		markRect.bottom = markRect.top + kMarkWidth;
		owner->SetHighColor(tint_color(owner->LowColor(), markRectBorderTint));
		owner->StrokeRect(markRect);
		markRect.InsetBy(1, 1);
		owner->SetHighColor(tint_color(owner->LowColor(), markRectFillTint));
		owner->FillRect(markRect);
		if (fMarked) {
			markRect.InsetBy(2, 2);
			owner->SetHighColor(tint_color(owner->LowColor(),
				markTint));
			owner->SetPenSize(2);
			owner->StrokeLine(markRect.LeftTop(), markRect.RightBottom());
			owner->StrokeLine(markRect.LeftBottom(), markRect.RightTop());
			owner->SetPenSize(1);
		}
	}


	// Observer interface
	virtual	void ObjectChanged(const Observable* object)
	{
		UpdateText();
	}


	// PathListItem
	void SetPath(VectorPath* p)
	{
		if (p == path)
			return;

		if (path) {
			path->RemoveObserver(this);
			path->ReleaseReference();
		}

		path = p;

		if (path) {
			path->AcquireReference();
			path->AddObserver(this);
			UpdateText();
		}
	}


	void UpdateText()
	{
		SetText(path->Name());
		Invalidate();
	}


	void SetMarkEnabled(bool enabled)
	{
		if (fMarkEnabled == enabled)
			return;
		fMarkEnabled = enabled;
		Invalidate();
	}


	void SetMarked(bool marked)
	{
		if (fMarked == marked)
			return;
		fMarked = marked;
		Invalidate();
	}


	void Invalidate()
	{
		if (fListView->LockLooper()) {
			fListView->InvalidateItem(
				fListView->IndexOf(this));
			fListView->UnlockLooper();
		}
	}

public:
	VectorPath* 	path;

private:
	PathListView*	fListView;
	bool			fMarkEnabled;
	bool			fMarked;
};


class ShapePathListener : public ContainerListener<VectorPath>,
	public ContainerListener<Shape> {
public:
	ShapePathListener(PathListView* listView)
		:
		fListView(listView),
		fShape(NULL)
	{
	}


	virtual ~ShapePathListener()
	{
		SetShape(NULL);
	}


	// ContainerListener<VectorPath> interface
	virtual void ItemAdded(VectorPath* path, int32 index)
	{
		fListView->_SetPathMarked(path, true);
	}


	virtual void ItemRemoved(VectorPath* path)
	{
		fListView->_SetPathMarked(path, false);
	}


	// ContainerListener<Shape> interface
	virtual void ItemAdded(Shape* shape, int32 index)
	{
	}


	virtual void ItemRemoved(Shape* shape)
	{
		fListView->SetCurrentShape(NULL);
	}


	// ShapePathListener
	void SetShape(PathSourceShape* shape)
	{
		if (fShape == shape)
			return;

		if (fShape)
			fShape->Paths()->RemoveListener(this);

		fShape = shape;

		if (fShape)
			fShape->Paths()->AddListener(this);
	}


	Shape* CurrentShape() const
	{
		return fShape;
	}

private:
	PathListView*		fListView;
	PathSourceShape*	fShape;
};


// #pragma mark -


enum {
	MSG_ADD					= 'addp',

	MSG_ADD_RECT			= 'addr',
	MSG_ADD_CIRCLE			= 'addc',
	MSG_ADD_ARC				= 'adda',

	MSG_DUPLICATE			= 'dupp',

	MSG_REVERSE				= 'rvrs',
	MSG_CLEAN_UP			= 'clup',
	MSG_ROTATE_INDICES_CW	= 'ricw',
	MSG_ROTATE_INDICES_CCW	= 'ricc',

	MSG_REMOVE				= 'remp',
};


PathListView::PathListView(BRect frame, const char* name, BMessage* message,
	BHandler* target)
	:
	SimpleListView(frame, name, NULL, B_SINGLE_SELECTION_LIST),
	fMessage(message),
	fMenu(NULL),

	fPathContainer(NULL),
	fShapeContainer(NULL),
	fCommandStack(NULL),

	fCurrentShape(NULL),
	fShapePathListener(new ShapePathListener(this))
{
	SetTarget(target);
}


PathListView::~PathListView()
{
	_MakeEmpty();
	delete fMessage;

	if (fPathContainer != NULL)
		fPathContainer->RemoveListener(this);

	if (fShapeContainer != NULL)
		fShapeContainer->RemoveListener(fShapePathListener);

	delete fShapePathListener;
}


void
PathListView::SelectionChanged()
{
	SimpleListView::SelectionChanged();

	if (!fSyncingToSelection) {
		// NOTE: single selection list
		PathListItem* item
			= dynamic_cast<PathListItem*>(ItemAt(CurrentSelection(0)));
		if (fMessage != NULL) {
			BMessage message(*fMessage);
			message.AddPointer("path", item ? (void*)item->path : NULL);
			Invoke(&message);
		}
	}

	_UpdateMenu();
}


void
PathListView::MouseDown(BPoint where)
{
	if (fCurrentShape == NULL) {
		SimpleListView::MouseDown(where);
		return;
	}

	bool handled = false;
	int32 index = IndexOf(where);
	PathListItem* item = dynamic_cast<PathListItem*>(ItemAt(index));
	if (item != NULL) {
		BRect itemFrame(ItemFrame(index));
		itemFrame.right = itemFrame.left + kBorderOffset + kMarkWidth
			+ kTextOffset / 2.0;

		VectorPath* path = item->path;
		if (itemFrame.Contains(where) && fCommandStack) {
			// add or remove the path to the shape
			::Command* command;
			if (fCurrentShape->Paths()->HasItem(path)) {
				command = new UnassignPathCommand(fCurrentShape, path);
			} else {
				VectorPath* paths[1];
				paths[0] = path;
				command = new AddPathsCommand(fCurrentShape->Paths(),
					paths, 1, false, fCurrentShape->Paths()->CountItems());
			}
			fCommandStack->Perform(command);
			handled = true;
		}
	}

	if (!handled)
		SimpleListView::MouseDown(where);
}


void
PathListView::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_ADD:
			if (fCommandStack != NULL) {
				VectorPath* path;
				AddPathsCommand* command;
				new_path(fPathContainer, &path, &command);
				fCommandStack->Perform(command);
			}
			break;

		case MSG_ADD_RECT:
			if (fCommandStack != NULL) {
				VectorPath* path;
				AddPathsCommand* command;
				new_path(fPathContainer, &path, &command);
				if (path != NULL) {
					path->AddPoint(BPoint(16, 16));
					path->AddPoint(BPoint(16, 48));
					path->AddPoint(BPoint(48, 48));
					path->AddPoint(BPoint(48, 16));
					path->SetClosed(true);
				}
				fCommandStack->Perform(command);
			}
			break;

		case MSG_ADD_CIRCLE:
			// TODO: ask for number of secions
			if (fCommandStack != NULL) {
				VectorPath* path;
				AddPathsCommand* command;
				new_path(fPathContainer, &path, &command);
				if (path != NULL) {
					// add four control points defining a circle:
					//   a 
					// b   d
					//   c
					BPoint a(32, 16);
					BPoint b(16, 32);
					BPoint c(32, 48);
					BPoint d(48, 32);
					
					path->AddPoint(a);
					path->AddPoint(b);
					path->AddPoint(c);
					path->AddPoint(d);
			
					path->SetClosed(true);
			
					float controlDist = 0.552284 * 16;
					path->SetPoint(0, a, a + BPoint(controlDist, 0.0),
										 a + BPoint(-controlDist, 0.0), true);
					path->SetPoint(1, b, b + BPoint(0.0, -controlDist),
										 b + BPoint(0.0, controlDist), true);
					path->SetPoint(2, c, c + BPoint(-controlDist, 0.0),
										 c + BPoint(controlDist, 0.0), true);
					path->SetPoint(3, d, d + BPoint(0.0, controlDist),
										 d + BPoint(0.0, -controlDist), true);
				}
				fCommandStack->Perform(command);
			}
			break;

		case MSG_DUPLICATE:
			if (fCommandStack != NULL) {
				PathListItem* item = dynamic_cast<PathListItem*>(
					ItemAt(CurrentSelection(0)));
				if (item == NULL)
					break;

				VectorPath* path;
				AddPathsCommand* command;
				new_path(fPathContainer, &path, &command, item->path);
				fCommandStack->Perform(command);
			}
			break;

		case MSG_REVERSE:
			if (fCommandStack != NULL) {
				PathListItem* item = dynamic_cast<PathListItem*>(
					ItemAt(CurrentSelection(0)));
				if (item == NULL)
					break;

				ReversePathCommand* command
					= new (nothrow) ReversePathCommand(item->path);
				fCommandStack->Perform(command);
			}
			break;

		case MSG_CLEAN_UP:
			if (fCommandStack != NULL) {
				PathListItem* item = dynamic_cast<PathListItem*>(
					ItemAt(CurrentSelection(0)));
				if (item == NULL)
					break;

				CleanUpPathCommand* command
					= new (nothrow) CleanUpPathCommand(item->path);
				fCommandStack->Perform(command);
			}
			break;

		case MSG_ROTATE_INDICES_CW:
		case MSG_ROTATE_INDICES_CCW:
			if (fCommandStack != NULL) {
				PathListItem* item = dynamic_cast<PathListItem*>(
					ItemAt(CurrentSelection(0)));
				if (item == NULL)
					break;

				RotatePathIndicesCommand* command
					= new (nothrow) RotatePathIndicesCommand(item->path,
					message->what == MSG_ROTATE_INDICES_CW);
				fCommandStack->Perform(command);
			}
			break;

		case MSG_REMOVE:
			RemoveSelected();
			break;

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


status_t
PathListView::ArchiveSelection(BMessage* into, bool deep) const
{
	into->what = PathListView::kSelectionArchiveCode;

	int32 count = CountSelectedItems();
	for (int32 i = 0; i < count; i++) {
		PathListItem* item = dynamic_cast<PathListItem*>(
			ItemAt(CurrentSelection(i)));
		if (item != NULL) {
			BMessage archive;
			if (item->path->Archive(&archive, deep) == B_OK)
				into->AddMessage("path", &archive);
		} else
			return B_ERROR;
	}

	return B_OK;
}


bool
PathListView::InstantiateSelection(const BMessage* archive, int32 dropIndex)
{
	if (archive->what != PathListView::kSelectionArchiveCode
		|| fCommandStack == NULL || fPathContainer == NULL)
		return false;

	// Drag may have come from another instance, like in another window.
	// Reconstruct the Styles from the archive and add them at the drop
	// index.
	int index = 0;
	BList paths;
	while (true) {
		BMessage pathArchive;
		if (archive->FindMessage("path", index, &pathArchive) != B_OK)
			break;

		VectorPath* path = new(std::nothrow) VectorPath(&pathArchive);
		if (path == NULL)
			break;

		if (!paths.AddItem(path)) {
			delete path;
			break;
		}

		index++;
	}

	int32 count = paths.CountItems();
	if (count == 0)
		return false;

	AddPathsCommand* command = new(nothrow) AddPathsCommand(fPathContainer,
		(VectorPath**)paths.Items(), count, true, dropIndex);
	if (command == NULL) {
		for (int32 i = 0; i < count; i++)
			delete (VectorPath*)paths.ItemAtFast(i);
		return false;
	}

	fCommandStack->Perform(command);

	return true;
}


void
PathListView::MoveItems(BList& items, int32 toIndex)
{
	if (fCommandStack == NULL || fPathContainer == NULL)
		return;

	int32 count = items.CountItems();
	VectorPath** paths = new (nothrow) VectorPath*[count];
	if (paths == NULL)
		return;

	for (int32 i = 0; i < count; i++) {
		PathListItem* item
			= dynamic_cast<PathListItem*>((BListItem*)items.ItemAtFast(i));
		paths[i] = item ? item->path : NULL;
	}

	MovePathsCommand* command = new (nothrow) MovePathsCommand(fPathContainer,
		paths, count, toIndex);
	if (command == NULL) {
		delete[] paths;
		return;
	}

	fCommandStack->Perform(command);
}


void
PathListView::CopyItems(BList& items, int32 toIndex)
{
	if (fCommandStack == NULL || fPathContainer == NULL)
		return;

	int32 count = items.CountItems();
	VectorPath* paths[count];

	for (int32 i = 0; i < count; i++) {
		PathListItem* item
			= dynamic_cast<PathListItem*>((BListItem*)items.ItemAtFast(i));
		paths[i] = item ? new (nothrow) VectorPath(*item->path) : NULL;
	}

	AddPathsCommand* command = new(nothrow) AddPathsCommand(fPathContainer,
		paths, count, true, toIndex);
	if (command == NULL) {
		for (int32 i = 0; i < count; i++)
			delete paths[i];
		return;
	}

	fCommandStack->Perform(command);
}


void
PathListView::RemoveItemList(BList& items)
{
	if (fCommandStack == NULL || fPathContainer == NULL)
		return;

	int32 count = items.CountItems();
	int32 indices[count];
	for (int32 i = 0; i < count; i++)
		indices[i] = IndexOf((BListItem*)items.ItemAtFast(i));

	RemovePathsCommand* command = new (nothrow) RemovePathsCommand(
		fPathContainer, indices, count);

	fCommandStack->Perform(command);
}


BListItem*
PathListView::CloneItem(int32 index) const
{
	if (PathListItem* item = dynamic_cast<PathListItem*>(ItemAt(index))) {
		return new(nothrow) PathListItem(item->path,
			const_cast<PathListView*>(this), fCurrentShape != NULL);
	}
	return NULL;
}


int32
PathListView::IndexOfSelectable(Selectable* selectable) const
{
	VectorPath* path = dynamic_cast<VectorPath*>(selectable);
	if (path == NULL)
		return -1;

	int32 count = CountItems();
	for (int32 i = 0; i < count; i++) {
		if (SelectableFor(ItemAt(i)) == path)
			return i;
	}

	return -1;
}


Selectable*
PathListView::SelectableFor(BListItem* item) const
{
	PathListItem* pathItem = dynamic_cast<PathListItem*>(item);
	if (pathItem != NULL)
		return pathItem->path;
	return NULL;
}


// #pragma mark -


void
PathListView::ItemAdded(VectorPath* path, int32 index)
{
	// NOTE: we are in the thread that messed with the
	// ShapeContainer, so no need to lock the
	// container, when this is changed to asynchronous
	// notifications, then it would need to be read-locked!
	if (!LockLooper())
		return;

	if (_AddPath(path, index))
		Select(index);

	UnlockLooper();
}


void
PathListView::ItemRemoved(VectorPath* path)
{
	// NOTE: we are in the thread that messed with the
	// ShapeContainer, so no need to lock the
	// container, when this is changed to asynchronous
	// notifications, then it would need to be read-locked!
	if (!LockLooper())
		return;

	// NOTE: we're only interested in VectorPath objects
	_RemovePath(path);

	UnlockLooper();
}


// #pragma mark -


void
PathListView::SetPathContainer(Container<VectorPath>* container)
{
	if (fPathContainer == container)
		return;

	// detach from old container
	if (fPathContainer != NULL)
		fPathContainer->RemoveListener(this);

	_MakeEmpty();

	fPathContainer = container;

	if (fPathContainer == NULL)
		return;

	fPathContainer->AddListener(this);

	// sync
//	if (!fPathContainer->ReadLock())
//		return;

	int32 count = fPathContainer->CountItems();
	for (int32 i = 0; i < count; i++)
		_AddPath(fPathContainer->ItemAtFast(i), i);

//	fPathContainer->ReadUnlock();
}


void
PathListView::SetShapeContainer(Container<Shape>* container)
{
	if (fShapeContainer == container)
		return;

	// detach from old container
	if (fShapeContainer != NULL)
		fShapeContainer->RemoveListener(fShapePathListener);

	fShapeContainer = container;

	if (fShapeContainer != NULL)
		fShapeContainer->AddListener(fShapePathListener);
}


void
PathListView::SetCommandStack(CommandStack* stack)
{
	fCommandStack = stack;
}


void
PathListView::SetMenu(BMenu* menu)
{
	fMenu = menu;
	if (fMenu == NULL)
		return;

	fAddItem = new BMenuItem(B_TRANSLATE("Add"),
		new BMessage(MSG_ADD));
	fAddRectItem = new BMenuItem(B_TRANSLATE("Add rect"),
		new BMessage(MSG_ADD_RECT));
	fAddCircleItem = new BMenuItem(B_TRANSLATE("Add circle"/*B_UTF8_ELLIPSIS*/),
		new BMessage(MSG_ADD_CIRCLE));
//	fAddArcItem = new BMenuItem("Add arc" B_UTF8_ELLIPSIS,
//		new BMessage(MSG_ADD_ARC));
	fDuplicateItem = new BMenuItem(B_TRANSLATE("Duplicate"),
		new BMessage(MSG_DUPLICATE));
	fReverseItem = new BMenuItem(B_TRANSLATE("Reverse"),
		new BMessage(MSG_REVERSE));
	fCleanUpItem = new BMenuItem(B_TRANSLATE("Clean up"),
		new BMessage(MSG_CLEAN_UP));
	fRotateIndicesRightItem = new BMenuItem(B_TRANSLATE("Rotate indices forwards"),
		new BMessage(MSG_ROTATE_INDICES_CCW), 'R');
	fRotateIndicesLeftItem = new BMenuItem(B_TRANSLATE("Rotate indices backwards"),
		new BMessage(MSG_ROTATE_INDICES_CW), 'R', B_SHIFT_KEY);
	fRemoveItem = new BMenuItem(B_TRANSLATE("Remove"),
		new BMessage(MSG_REMOVE));

	fMenu->AddItem(fAddItem);
	fMenu->AddItem(fAddRectItem);
	fMenu->AddItem(fAddCircleItem);
//	fMenu->AddItem(fAddArcItem);

	fMenu->AddSeparatorItem();

	fMenu->AddItem(fDuplicateItem);
	fMenu->AddItem(fReverseItem);
	fMenu->AddItem(fCleanUpItem);

	fMenu->AddSeparatorItem();

	fMenu->AddItem(fRotateIndicesRightItem);
	fMenu->AddItem(fRotateIndicesLeftItem);

	fMenu->AddSeparatorItem();

	fMenu->AddItem(fRemoveItem);

	fMenu->SetTargetForItems(this);

	_UpdateMenu();
}


void
PathListView::SetCurrentShape(Shape* shape)
{
	if (fCurrentShape == shape)
		return;

	fCurrentShape = dynamic_cast<PathSourceShape*>(shape);
	fShapePathListener->SetShape(fCurrentShape);

	_UpdateMarks();
}


// #pragma mark -


bool
PathListView::_AddPath(VectorPath* path, int32 index)
{
	if (path == NULL)
		return false;

	PathListItem* item = new(nothrow) PathListItem(path, this,
		fCurrentShape != NULL);
	if (item == NULL)
		return false;

	if (!AddItem(item, index)) {
		delete item;
		return false;
	}
	
	return true;
}


bool
PathListView::_RemovePath(VectorPath* path)
{
	PathListItem* item = _ItemForPath(path);
	if (item != NULL && RemoveItem(item)) {
		delete item;
		return true;
	}
	return false;
}


PathListItem*
PathListView::_ItemForPath(VectorPath* path) const
{
	int32 count = CountItems();
	for (int32 i = 0; i < count; i++) {
		 PathListItem* item = dynamic_cast<PathListItem*>(ItemAt(i));
		if (item == NULL)
			continue;
		if (item->path == path)
			return item;
	}
	return NULL;
}


// #pragma mark -


void
PathListView::_UpdateMarks()
{
	int32 count = CountItems();
	if (fCurrentShape != NULL) {
		// enable display of marks and mark items whoes
		// path is contained in fCurrentShape
		for (int32 i = 0; i < count; i++) {
			PathListItem* item = dynamic_cast<PathListItem*>(ItemAt(i));
			if (item == NULL)
				continue;
			item->SetMarkEnabled(true);
			item->SetMarked(fCurrentShape->Paths()->HasItem(item->path));
		}
	} else {
		// disable display of marks
		for (int32 i = 0; i < count; i++) {
			PathListItem* item = dynamic_cast<PathListItem*>(ItemAt(i));
			if (item == NULL)
				continue;
			item->SetMarkEnabled(false);
		}
	}

	Invalidate();
}


void
PathListView::_SetPathMarked(VectorPath* path, bool marked)
{
	PathListItem* item = _ItemForPath(path);
	if (item != NULL)
		item->SetMarked(marked);
}


void
PathListView::_UpdateMenu()
{
	if (fMenu == NULL)
		return;

	bool hasSelection = CurrentSelection(0) >= 0;

	fDuplicateItem->SetEnabled(hasSelection);
	fReverseItem->SetEnabled(hasSelection);
	fCleanUpItem->SetEnabled(hasSelection);
	fRotateIndicesLeftItem->SetEnabled(hasSelection);
	fRotateIndicesRightItem->SetEnabled(hasSelection);
	fRemoveItem->SetEnabled(hasSelection);
}