fractorium/Source/Fractorium/FractoriumLibrary.cpp

#include "FractoriumPch.h"
#include "Fractorium.h"

/// <summary>
/// Initialize the library tree UI.
/// </summary>
void Fractorium::InitLibraryUI()
{
	ui.LibraryTree->SetMainWindow(this);
	connect(ui.LibraryTree, SIGNAL(itemChanged(QTreeWidgetItem*, int)),		  this, SLOT(OnEmberTreeItemChanged(QTreeWidgetItem*, int)),	   Qt::QueuedConnection);
	connect(ui.LibraryTree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(OnEmberTreeItemDoubleClicked(QTreeWidgetItem*, int)), Qt::QueuedConnection);
	connect(ui.LibraryTree, SIGNAL(itemActivated(QTreeWidgetItem*, int)),	  this, SLOT(OnEmberTreeItemDoubleClicked(QTreeWidgetItem*, int)), Qt::QueuedConnection);
}

/// <summary>
/// Get the index of the currently selected ember in the library tree.
/// </summary>
/// <returns>A pair containing the index of the item clicked and a pointer to the item</param>
pair<size_t, QTreeWidgetItem*> Fractorium::GetCurrentEmberIndex()
{
	int index = 0;
	QTreeWidgetItem* item = nullptr;
	auto tree = ui.LibraryTree;

	if (auto top = tree->topLevelItem(0))
	{
		for (int i = 0; i < top->childCount(); i++)//Iterate through all of the children, which will represent the open embers.
		{
			item = top->child(index);

			if (item && !item->isSelected())
				index++;
			else
				break;
		}
	}

	return make_pair(index, item);
}

/// <summary>
/// Slot function to be called via QMetaObject::invokeMethod() to update preview images in the preview thread.
/// </summary>
/// <param name="item">The item double clicked on</param>
/// <param name="v">The vector holding the RGBA bitmap</param>
/// <param name="w">The width of the bitmap</param>
/// <param name="h">The height of the bitmap</param>
void Fractorium::SetLibraryTreeItemData(EmberTreeWidgetItemBase* item, vector<byte>& v, uint w, uint h)
{
	item->SetImage(v, w, h);
}

/// <summary>
/// Set all libary tree entries to the name of the corresponding ember they represent.
/// Set all libary tree entries to point to the underlying ember they represent.
/// </summary>
template <typename T>
void FractoriumEmberController<T>::SyncLibrary(eLibraryUpdate update)
{
	auto it = m_EmberFile.m_Embers.begin();
	auto tree = m_Fractorium->ui.LibraryTree;
	tree->blockSignals(true);

	if (auto top = tree->topLevelItem(0))
	{
		for (int i = 0; i < top->childCount() && it != m_EmberFile.m_Embers.end(); ++i, ++it)//Iterate through all of the children, which will represent the open embers.
		{
			if (auto item = dynamic_cast<EmberTreeWidgetItem<T>*>(top->child(i)))//Cast the child widget to the EmberTreeWidgetItem type.
			{
				if (update & eLibraryUpdate::INDEX)
					it->m_Index = i;

				if (update & eLibraryUpdate::NAME)
					item->setText(0, QString::fromStdString(it->m_Name));

				if (update & eLibraryUpdate::POINTER)
					item->SetEmberPointer(&(*it));
			}
		}
	}

	tree->blockSignals(false);
}

/// <summary>
/// Fill the library tree with the names of the embers in the
/// currently opened file.
/// Start preview render thread.
/// </summary>
/// <param name="selectIndex">After the tree is filled, select this index. Pass -1 to omit selecting an index.</param>
template <typename T>
void FractoriumEmberController<T>::FillLibraryTree(int selectIndex)
{
	uint size = 64;
	uint i = 0;
	auto tree = m_Fractorium->ui.LibraryTree;
	vector<byte> v(size * size * 4);
	StopPreviewRender();
	tree->clear();
	QCoreApplication::flush();
	tree->blockSignals(true);
	auto fileItem = new QTreeWidgetItem(tree);
	QFileInfo info(m_EmberFile.m_Filename);
	fileItem->setText(0, info.fileName());
	fileItem->setToolTip(0, m_EmberFile.m_Filename);
	fileItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled);

	for (auto& it : m_EmberFile.m_Embers)
	{
		auto emberItem = new EmberTreeWidgetItem<T>(&it, fileItem);

		if (it.m_Name.empty())
			emberItem->setText(0, ToString(i++));
		else
			emberItem->setText(0, it.m_Name.c_str());

		emberItem->setToolTip(0, emberItem->text(0));
		emberItem->SetImage(v, size, size);
	}

	tree->blockSignals(false);

	if (selectIndex != -1)
		if (auto top = tree->topLevelItem(0))
			if (auto emberItem = dynamic_cast<EmberTreeWidgetItem<T>*>(top->child(selectIndex)))
				emberItem->setSelected(true);

	QCoreApplication::flush();
	RenderPreviews(0, uint(m_EmberFile.Size()));
	tree->expandAll();
}

/// <summary>
/// Update the library tree with the newly added embers (most likely from pasting) and
/// only render previews for the new ones, without clearing the entire tree.
/// </summary>
template <typename T>
void FractoriumEmberController<T>::UpdateLibraryTree()
{
	uint size = 64;
	vector<byte> v(size * size * 4);
	auto tree = m_Fractorium->ui.LibraryTree;

	if (auto top = tree->topLevelItem(0))
	{
		int origChildCount = top->childCount();
		int i = origChildCount;
		tree->blockSignals(true);

		for (auto it = Advance(m_EmberFile.m_Embers.begin(), i); it != m_EmberFile.m_Embers.end(); ++it)
		{
			auto emberItem = new EmberTreeWidgetItem<T>(&(*it), top);

			if (it->m_Name.empty())
				emberItem->setText(0, ToString(i++));
			else
				emberItem->setText(0, it->m_Name.c_str());

			emberItem->setToolTip(0, emberItem->text(0));
			emberItem->SetImage(v, size, size);
		}

		//When adding elements, ensure all indices are sequential.
		SyncLibrary(eLibraryUpdate::INDEX);
		tree->blockSignals(false);
		RenderPreviews(origChildCount, uint(m_EmberFile.Size()));
	}
}

/// <summary>
/// Copy the text of the item which was changed to the name of the current ember.
/// Ensure all names are unique in the opened file.
/// This seems to be called spuriously, so we do a check inside to make sure
/// the text was actually changed.
/// We also have to wrap the dynamic_cast call in a try/catch block  because this can
/// be called on a widget that has already been deleted.
/// </summary>
/// <param name="item">The libary tree item changed</param>
/// <param name="col">The column clicked, ignored.</param>
template <typename T>
void FractoriumEmberController<T>::EmberTreeItemChanged(QTreeWidgetItem* item, int col)
{
	try
	{
		auto tree = m_Fractorium->ui.LibraryTree;

		if (auto emberItem = dynamic_cast<EmberTreeWidgetItem<T>*>(item))
		{
			if (emberItem->text(0).isEmpty())//Prevent empty string.
			{
				emberItem->UpdateEditText();
				return;
			}

			string oldName = emberItem->GetEmber()->m_Name;//First preserve the previous name.
			tree->blockSignals(true);
			emberItem->UpdateEmberName();//Copy edit text to the ember's name variable.
			m_EmberFile.MakeNamesUnique();//Ensure all names remain unique.
			SyncLibrary(eLibraryUpdate::NAME);//Copy all ember names to the tree items since some might have changed to be made unique.
			string newName = emberItem->GetEmber()->m_Name;//Get the new, final, unique name.

			if (m_EmberFilePointer == emberItem->GetEmber() && oldName != newName)//If the ember edited was the current one, and the name was indeed changed, update the name of the current one.
			{
				m_Ember.m_Name = newName;
				m_LastSaveCurrent = "";//Reset will force the dialog to show on the next save current since the user probably wants a different name.
			}

			tree->blockSignals(false);
		}
		else if (auto parentItem = dynamic_cast<QTreeWidgetItem*>(item))
		{
			QString text = parentItem->text(0);

			if (text != "")
			{
				m_EmberFile.m_Filename = text;
				m_LastSaveAll = "";//Reset will force the dialog to show on the next save all since the user probably wants a different name.
			}
		}
	}
	catch (const std::exception& e)
	{
		qDebug() << "FractoriumEmberController<T>::EmberTreeItemChanged() : Exception thrown: " << e.what();
	}
}

void Fractorium::OnEmberTreeItemChanged(QTreeWidgetItem* item, int col) { m_Controller->EmberTreeItemChanged(item, col); }

/// <summary>
/// Set the current ember to the selected item.
/// Clears the undo state.
/// Resets the rendering process.
/// Called when the user double clicks on a library tree item.
/// This will get called twice for some reason, and there's no way to prevent it.
/// Doesn't seem to cause any problems.
/// </summary>
/// <param name="item">The item double clicked on</param>
/// <param name="col">The column clicked, ignored.</param>
template <typename T>
void FractoriumEmberController<T>::EmberTreeItemDoubleClicked(QTreeWidgetItem* item, int col)
{
	if (auto emberItem = dynamic_cast<EmberTreeWidgetItem<T>*>(item))
	{
		//qDebug() << "Setting current ember to: " << QString::fromStdString(emberItem->GetEmber()->m_Name);
		ClearUndo();
		SetEmber(*emberItem->GetEmber(), false, true);
	}
}

void Fractorium::OnEmberTreeItemDoubleClicked(QTreeWidgetItem* item, int col) { m_Controller->EmberTreeItemDoubleClicked(item, col); }

/// <summary>
/// Move a library item at one index to the next index.
/// </summary>
/// <param name="startRow">The index of the source item to move</param>
/// <param name="destRow">The destination index to move the item to</param>
template <typename T>
void FractoriumEmberController<T>::MoveLibraryItems(int startRow, int destRow)
{
	int i = 0;
	auto tree = m_Fractorium->ui.LibraryTree;
	auto top = tree->topLevelItem(0);
	auto b = m_EmberFile.m_Embers.begin();
	auto s = Advance(b, startRow);
	auto d = Advance(b, destRow);
	m_EmberFile.m_Embers.splice(d, m_EmberFile.m_Embers, s);
	SyncLibrary(eLibraryUpdate::INDEX);//Only indices need syncing.
}

/// <summary>
/// Delete the currently selected item in the tree.
/// Note this is not necessarilly the current ember, it's just the item
/// in the tree that is selected.
/// </summary>
/// <param name="p">A pair containing the index of the item clicked and a pointer to the item</param>
template <typename T>
void FractoriumEmberController<T>::Delete(const pair<size_t, QTreeWidgetItem*>& p)
{
	if (m_EmberFile.Delete(p.first))
	{
		delete p.second;
		SyncLibrary(eLibraryUpdate::INDEX);
	}

	//If there is now only one item left and it wasn't selected, select it.
	if (auto top = m_Fractorium->ui.LibraryTree->topLevelItem(0))
		if (top->childCount() == 1)
			if (auto item = dynamic_cast<EmberTreeWidgetItem<T>*>(top->child(0)))
				if (item->GetEmber()->m_Name != m_Ember.m_Name)
					EmberTreeItemDoubleClicked(top->child(0), 0);
}

/// <summary>
/// Called when the user presses and releases the delete key while the library tree has the focus,
/// and an item is selected.
/// </summary>
/// <param name="p">A pair containing the index of the item clicked and a pointer to the item</param>
void Fractorium::OnDelete(const pair<size_t, QTreeWidgetItem*>& p)
{
	m_Controller->Delete(p);
}

/// <summary>
/// Stop the preview renderer if it's already running.
/// Clear all of the existing preview images, then start the preview rendering thread.
/// Optionally only render previews for a subset of all open embers.
/// </summary>
/// <param name="start">The 0-based index to start rendering previews for</param>
/// <param name="end">The 0-based index which is one beyond the last ember to render a preview for</param>
template <typename T>
void FractoriumEmberController<T>::RenderPreviews(uint start, uint end)
{
	StopPreviewRender();

	if (start == UINT_MAX && end == UINT_MAX)
	{
		auto tree = m_Fractorium->ui.LibraryTree;
		tree->blockSignals(true);

		if (auto top = tree->topLevelItem(0))
		{
			int childCount = top->childCount();
			vector<byte> emptyPreview(PREVIEW_SIZE * PREVIEW_SIZE * 4);

			for (int i = 0; i < childCount; i++)
				if (auto treeItem = dynamic_cast<EmberTreeWidgetItem<T>*>(top->child(i)))
					treeItem->SetImage(emptyPreview, PREVIEW_SIZE, PREVIEW_SIZE);
		}

		tree->blockSignals(false);
		m_PreviewResult = QtConcurrent::run(m_PreviewRenderFunc, 0, uint(m_EmberFile.Size()));
	}
	else
		m_PreviewResult = QtConcurrent::run(m_PreviewRenderFunc, start, end);
}

/// <summary>
/// Stop the preview rendering thread.
/// </summary>
template <typename T>
void FractoriumEmberController<T>::StopPreviewRender()
{
	m_PreviewRun = false;
	m_PreviewRenderer->Abort();

	while (m_PreviewRunning)
		QApplication::processEvents();

	m_PreviewResult.cancel();

	while (m_PreviewResult.isRunning())
		QApplication::processEvents();

	QCoreApplication::sendPostedEvents(m_Fractorium->ui.LibraryTree);
	QCoreApplication::flush();
}

template class FractoriumEmberController<float>;

#ifdef DO_DOUBLE
template class FractoriumEmberController<double>;
#endif