haiku.git

/*
 * Copyright 2006-2007, 2023, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Zardshard
 */
#ifndef MOVE_COMMAND_H
#define MOVE_COMMAND_H

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

#include <Catalog.h>
#include <Locale.h>
#include <StringFormat.h>

#include "Command.h"
#include "Container.h"
#include "IconBuild.h"

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

using std::nothrow;

_USING_ICON_NAMESPACE


/*! Moves a set of \c items to a different location in a \c container.

	\note This class should be subclassed and the \c GetName member overridden.
*/
template <class Type>
class MoveCommand : public Command {
 public:
								MoveCommand(
									Container<Type>* container,
									Type** items,
									int32 count,
									int32 toIndex);
	virtual						~MoveCommand();

	virtual	status_t			InitCheck();

	virtual	status_t			Perform();
	virtual status_t			Undo();

	virtual void				GetName(BString& name);

 protected:
			Container<Type>*	fContainer;
			Type**				fItems;
			int32*				fIndices;
			int32				fToIndex;
			int32				fCount;
};


template <class Type>
MoveCommand<Type>::MoveCommand(Container<Type>* container,
		Type** items,
		int32 count,
		int32 toIndex)
	: Command(),
	  fContainer(container),
	  fItems(items),
	  fIndices(count > 0 ? new (nothrow) int32[count] : NULL),
	  fToIndex(toIndex),
	  fCount(count)
{
	if (!fContainer || !fItems || !fIndices)
		return;

	// init original shape indices and
	// adjust toIndex compensating for items that
	// are removed before that index
	int32 itemsBeforeIndex = 0;
	for (int32 i = 0; i < fCount; i++) {
		fIndices[i] = fContainer->IndexOf(fItems[i]);
		if (fIndices[i] >= 0 && fIndices[i] < fToIndex)
			itemsBeforeIndex++;
	}
	fToIndex -= itemsBeforeIndex;
}


template <class Type>
MoveCommand<Type>::~MoveCommand()
{
	delete[] fItems;
	delete[] fIndices;
}


template <class Type>
status_t
MoveCommand<Type>::InitCheck()
{
	if (!fContainer || !fItems || !fIndices)
		return B_NO_INIT;

	// analyse the move, don't return B_OK in case
	// the container state does not change...

	int32 index = fIndices[0];
		// NOTE: fIndices == NULL if fCount < 1

	if (index != fToIndex) {
		// a change is guaranteed
		return B_OK;
	}

	// the insertion index is the same as the index of the first
	// moved item, a change only occures if the indices of the
	// moved items is not contiguous
	bool isContiguous = true;
	for (int32 i = 1; i < fCount; i++) {
		if (fIndices[i] != index + 1) {
			isContiguous = false;
			break;
		}
		index = fIndices[i];
	}
	if (isContiguous) {
		// the container state will not change because of the move
		return B_ERROR;
	}

	return B_OK;
}


template <class Type>
status_t
MoveCommand<Type>::Perform()
{
	status_t ret = B_OK;

	// remove paths from container
	for (int32 i = 0; i < fCount; i++) {
		if (fItems[i] && !fContainer->RemoveItem(fItems[i])) {
			ret = B_ERROR;
			break;
		}
	}
	if (ret < B_OK)
		return ret;

	// add paths to container at the insertion index
	int32 index = fToIndex;
	for (int32 i = 0; i < fCount; i++) {
		if (fItems[i] && !fContainer->AddItem(fItems[i], index++)) {
			ret = B_ERROR;
			break;
		}
	}

	return ret;
}


template <class Type>
status_t
MoveCommand<Type>::Undo()
{
	status_t ret = B_OK;

	// remove paths from container
	for (int32 i = 0; i < fCount; i++) {
		if (fItems[i] && !fContainer->RemoveItem(fItems[i])) {
			ret = B_ERROR;
			break;
		}
	}
	if (ret < B_OK)
		return ret;

	// add paths to container at remembered indices
	for (int32 i = 0; i < fCount; i++) {
		if (fItems[i] && !fContainer->AddItem(fItems[i], fIndices[i])) {
			ret = B_ERROR;
			break;
		}
	}

	return ret;
}


template <class Type>
void
MoveCommand<Type>::GetName(BString& name)
{
	static BStringFormat format(B_TRANSLATE("Move {0, plural, "
		"one{item} other{items}}"));
	format.Format(name, fCount);
}
#endif // MOVE_COMMAND_H