edn/sources/appl/widget/BufferTree.cpp

/** @file
 * @author Edouard DUPIN
 * @copyright 2010, Edouard DUPIN, all right reserved
 * @license GPL v3 (see license file)
 */
#include <appl/debug.hpp>
#include <appl/global.hpp>
#include <appl/widget/BufferTree.hpp>
#include <appl/BufferManager.hpp>
//#include <ColorizeManager.hpp>
#include <appl/Gui/MainWindows.hpp>
#include <ewol/object/Object.hpp>
#include <ewol/compositing/Image.hpp>
#include <etk/algorithm.hpp>

appl::widget::BufferTree::BufferTree() :
  propertyShowUnNeeded(this, "show-un-needed",
                             false,
                             "show element that is not open",
                             &appl::widget::BufferTree::onChangePropertyShowUnNeeded),
  m_openOrderMode(false) {
	addObjectType("appl::BufferTree");
	m_selectedID = -1;
	m_selectedIdRequested = -1;
	// load buffer manager:
	m_bufferManager = appl::BufferManager::create();
	// load color properties
	m_paintingProperties = appl::GlyphPainting::create("THEME_COLOR:///bufferList.json");
	// get all id properties ...
	m_colorBackground1 = m_paintingProperties->request("backgroung1");
	m_colorBackground2 = m_paintingProperties->request("backgroung2");
	m_colorBackgroundHide = m_paintingProperties->request("backgroundhide");
	m_colorBackgroundSelect = m_paintingProperties->request("backgroungSelected");
	m_colorTextNormal = m_paintingProperties->request("textNormal");
	m_colorTextModify = m_paintingProperties->request("textModify");
	m_colorTextNotOpen = m_paintingProperties->request("textNotOpen");
}

void appl::widget::BufferTree::init() {
	ewol::widget::TreeView::init();
	//propertyHide.set(true);
	propertyCanFocus.set(true);
	propertyTextIsDecorated.set(false);
	if (m_bufferManager != null) {
		m_bufferManager->signalNewBuffer.connect(sharedFromThis(), &appl::widget::BufferTree::onNewBuffer);
		m_bufferManager->signalSelectFile.connect(sharedFromThis(), &appl::widget::BufferTree::onSelectBuffer);
		m_bufferManager->signalRemoveBuffer.connect(sharedFromThis(), &appl::widget::BufferTree::onRemoveBuffer);
	}
	addComposeElemnent("image_folder", ememory::makeShared<ewol::compositing::Image>("THEME_GUI:///Folder.svg?lib=ewol"));
	addComposeElemnent("image_file", ememory::makeShared<ewol::compositing::Image>("THEME_GUI:///File.svg?lib=ewol"));

}

static etk::String getCommonPathPart(const etk::Path& _left, const etk::Path& _right) {
	etk::String out;
	for (size_t iii=0; iii < etk::min(_left.getString().size(), _right.getString().size()); ++iii) {
		if (_left.getString()[iii] == _right.getString()[iii]) {
			out += _left.getString()[iii];
			continue;
		}
		break;
	}
	size_t pos = out.rfind('/');
	if (pos != etk::String::npos) {
		out = out.extract(0, pos);
	}
	return out;
}



void appl::widget::BufferTree::generateFlatTree() {
	// Brut Force Mode...
	etk::Path upperParent = getRootPath();
	// Now we have the root path...
	// Need to feed all elements needed.
	m_tree = etk::TreeNode<appl::TreeElement>::create(TreeElement(upperParent, true));
	populateNodeIfNeeded(m_tree);
	updateFlatTree();
}

static bool localSort(const etk::Path& _left, const etk::Path& _right) {
	return _left.getString().toUpper() <= _right.getString().toUpper();
}

void appl::widget::BufferTree::populateNodeIfNeeded(ememory::SharedPtr<etk::TreeNode<appl::TreeElement>> _node) {
	if (_node == null) {
		return;
	}
	appl::TreeElement& value = _node->getData();
	if (value.m_isFolder == false) {
		// nothing to expand...
		return;
	}
	if (_node->haveChild() == true) {
		// already populated...
		return;
	}
	etk::Vector<etk::Path> child = etk::path::list(value.m_path, etk::path::LIST_FOLDER|etk::path::LIST_FILE);
	etk::algorithm::quickSort(child, localSort);
	APPL_ERROR("    nbChilds: " << child.size() << " for path: " << value.m_path);
	for (auto& it: child) {
		APPL_ERROR("add element: " << it);
		auto elem = etk::TreeNode<appl::TreeElement>::create(TreeElement(it, false));
		_node->addChild(elem);
		// TODO: ETK_FREE(etk::FSNode, it);
	}
}

void appl::widget::BufferTree::goUpper() {
	APPL_ERROR("Go upper ...");
	if (m_tree == null) {
		generateFlatTree();
		return;
	}
	// generate new futur root node ...
	etk::Path path = m_tree->getData().m_path.getParent();
	if (path == m_tree->getData().m_path) {
		APPL_ERROR("No more parent in upper ... '" << path << "'");
		return;
	}
	auto treeElement = etk::TreeNode<appl::TreeElement>::create(TreeElement(path, true));
	// Add all sub-items
	populateNodeIfNeeded(treeElement);
	// find old root node in the sublist:
	for (auto& it: treeElement->getChilds()) {
		if (it->getData().m_nodeName == m_tree->getData().m_nodeName) {
			it = m_tree;
			it->setParent(treeElement);
			break;
		}
	}
	// set new root node:
	m_tree = treeElement;
	// update display:
	updateFlatTree();
}

bool appl::widget::BufferTree::updateChildOpen(ememory::SharedPtr<etk::TreeNode<appl::TreeElement>> _node) {
	if (_node == null) {
		return false;
	}
	appl::TreeElement& value = _node->getData();
	if (value.m_isFolder == false) {
		// nothing to reset...
		return value.m_buffer != null;
	}
	value.m_haveChildOpen = false;
	for (auto& it: _node->getChilds()) {
		if (updateChildOpen(it) == true) {
			value.m_haveChildOpen = true;
		}
	}
	return value.m_haveChildOpen;
}

void appl::widget::BufferTree::updateFlatTree() {
	// Enable parent with child open:
	updateChildOpen(m_tree);
	// flat tree element enable
	if (propertyShowUnNeeded.get() == false) {
		m_flatTree.setRoot(m_tree,
		    [&](const TreeElement& _value){
		    	if (    _value.m_isFolder == true
		    	     && _value.m_haveChildOpen == true) {
		    		return true;
		    	}
		    	if (    _value.m_buffer != null) {
		    		return true;
		    	}
		    	return false;
		    },
		    [&](const TreeElement& _value){
		    	return _value.m_isExpand;
		    });
	} else {
		m_flatTree.setRoot(m_tree,
		    [&](const TreeElement& _value){
		    	return true;
		    },
		    [&](const TreeElement& _value){
		    	return _value.m_isExpand;
		    });
	}
	
	markToRedraw();
}


void appl::widget::BufferTree::expandToPath(ememory::SharedPtr<etk::TreeNode<appl::TreeElement>> _node, const etk::Path& _path) {
	if (_node == null) {
		return;
	}
	appl::TreeElement& value = _node->getData();
	if (value.m_isFolder == false) {
		return;
	}
	if (_path.getString().startWith(value.m_path.getString() + "/") == false) {
		return;
	}
	// force expand
	value.m_isExpand = true;
	populateNodeIfNeeded(_node);
	for (auto& it: _node->getChilds()) {
		expandToPath(it, _path);
	}
}


appl::widget::BufferTree::~BufferTree() {
	removeAllElement();
}


void appl::widget::BufferTree::calculateMinMaxSize() {
	/*int32_t fontId = getDefaultFontId();
	int32_t minWidth = ewol::getWidth(fontId, m_label);
	int32_t minHeight = ewol::getHeight(fontId);
	m_minSize.x = 3+minWidth;
	m_minSize.y = 3+minHeight;
	*/
	m_minSize.setValue(300, 150);
}

void appl::widget::BufferTree::removeAllElement() {
	//m_list.clear();
}

etk::Path appl::widget::BufferTree::getRootPath() {
	etk::Path upperParent = "";
	etk::Vector<appl::BufferShared> tmpNewBuffer;
	for (auto& it : *m_bufferManager) {
		if (it == null) {
			continue;
		}
		if (it->hasFileName() == false) {
			tmpNewBuffer.pushBack(it);
			continue;
		}
		etk::Path nodeName = it->getFileName();
		if (upperParent.isEmpty() == true) {
			upperParent = nodeName.getParent();
			APPL_ERROR("init root: " << nodeName << " root=" << upperParent);
			continue;
		}
		upperParent = getCommonPathPart(upperParent, nodeName.getParent());
		APPL_ERROR("Update: " << nodeName << "   " << nodeName.getParent() << "    root=" << upperParent);
	}
	if (upperParent == "") {
		APPL_ERROR("Nothing find ==> get home path...");
		upperParent = etk::path::getHomePath();
	}
	APPL_ERROR("update tree: " << upperParent);
	return upperParent;
}

void appl::widget::BufferTree::onNewBuffer(const ememory::SharedPtr<appl::Buffer>& _buffer) {
	APPL_INFO("New Buffer open: '" << _buffer->getFileName() << "'");
	if (m_tree == null) {
		generateFlatTree();
	} else {
		etk::Path rootPath = getRootPath();
		while (rootPath != m_tree->getData().m_path ) {
			APPL_ERROR("rootPath=" << rootPath << "  !=  " << m_tree->getData().m_path);
			goUpper();
		}
	}
	expandToPath(m_tree, _buffer->getFileName());
	auto listElements = m_tree->findIf([&](const etk::TreeNode<TreeElement>& _node) {
	    	APPL_WARNING("Compare : '" << _node.getData().m_path << "' =?= '" << _buffer->getFileName() << "'");
	    	if (_node.getData().m_path == _buffer->getFileName()) {
	    		return true;
	    	}
	    	return false;
	    });
	if (listElements.size() == 0) {
		APPL_ERROR("    ==> Can not find BUFFER ...");
	} else {
		listElements[0]->getData().m_buffer = _buffer;
	}
	
	updateFlatTree();
	/*
	ememory::SharedPtr<appl::Buffer> buffer = m_bufferManager->get(_value);
	if (buffer == null) {
		APPL_ERROR("event on element nor exist : " << _value);
		return;
	}
	buffer->signalIsSave.connect(sharedFromThis(), &BufferTree::onCallbackIsSave);
	buffer->signalIsModify.connect(sharedFromThis(), &BufferTree::onCallbackIsModify);
	buffer->signalChangeName.connect(sharedFromThis(), &BufferTree::onCallbackChangeName);
	appl::dataBufferStruct tmp(_value, buffer);
	if (m_openOrderMode == true) {
		m_list.pushBack(tmp);
	} else {
		insertAlphabetic(tmp);
	}
	if (m_list.size() <= 1) {
		propertyHide.set(true);
		propertySetOnWidgetNamed("appl-Buffer-viewer-separator", "hide", "true");
	} else {
		propertyHide.set(false);
		propertySetOnWidgetNamed("appl-Buffer-viewer-separator", "hide", "false");
	}
	markToRedraw();
	*/
}

void appl::widget::BufferTree::onSelectBuffer(const ememory::SharedPtr<appl::Buffer>& _buffer) {
	#if 1
		m_selection = _buffer;
		updateFlatTree();
	#else
		auto elem = m_tree.findIf([&](const TreeNode<TreeElement>& _element) {
		    	if (_element.getData().m_buffer == _buffer) {
		    		return true;
		    	}
		    	return false;
		    });
		for (auto& it: elem) {
			_element.getData().m_isSelected = true;
			// TODO: expand all this parents...
		}
		updateFlatTree();
	#endif
}

void appl::widget::BufferTree::onCallbackChangeName() {
	/*
	for (size_t iii = 0; iii < m_list.size(); ++iii) {
		if (m_list[iii].m_bufferName != m_list[iii].m_buffer->getFileName()) {
			m_list[iii].m_bufferName = m_list[iii].m_buffer->getFileName();
			if (m_openOrderMode == false) {
				// re-order the fine in the correct position
				appl::dataBufferStruct tmp = m_list[iii];
				m_list.erase(m_list.begin() + iii);
				insertAlphabetic(tmp, ((int64_t)iii == m_selectedID));
				break;
			}
		}
	}
	*/
	markToRedraw();
}

void appl::widget::BufferTree::onRemoveBuffer(const ememory::SharedPtr<appl::Buffer>& _buffer) {
	APPL_ERROR("request remove buffer:");
	auto elem = m_tree->findIf([&](const etk::TreeNode<TreeElement>& _element) {
	    	if (_element.getData().m_buffer == _buffer) {
	    		return true;
	    	}
	    	return false;
	    });
	for (auto& it: elem) {
		it->getData().m_isSelected = false;
		it->getData().m_buffer = null;
	}
	markToRedraw();
}

void appl::widget::BufferTree::onCallbackIsSave() {
	markToRedraw();
}

void appl::widget::BufferTree::onCallbackIsModify() {
	markToRedraw();
}

etk::Color<> appl::widget::BufferTree::getBasicBG() {
	return (*m_paintingProperties)[m_colorBackground1].getForeground();
}

ivec2 appl::widget::BufferTree::getMatrixSize() const {
	return ivec2(1, m_flatTree.size());
}

void appl::widget::BufferTree::onItemExpandEvent(const ivec2& _pos) {
	APPL_WARNING("Event on expand on " << _pos);
	m_flatTree[_pos.y()]->getData().m_isExpand = m_flatTree[_pos.y()]->getData().m_isExpand?false:true;
	updateFlatTree();
}

fluorine::Variant appl::widget::BufferTree::getData(int32_t _role, const ivec2& _pos) {
	auto elem = m_flatTree[_pos.y()];
	appl::TreeElement& value = elem->getData();
	switch (_role) {
		case ewol::widget::ListRole::Text:
			return value.m_nodeName;
		case ewol::widget::ListRole::FgColor:
			// Folder with child open element
			if (value.m_haveChildOpen == true) {
				return (*m_paintingProperties)[m_colorTextNormal].getForeground();
			}
			if (value.m_buffer == null) {
				//APPL_ERROR( m_colorBackgroundHide << " => " << (*m_paintingProperties)[m_colorBackgroundHide].getForeground());
				return (*m_paintingProperties)[m_colorTextNotOpen].getForeground();
			}
			if (value.m_buffer->isModify() == false) {
				return (*m_paintingProperties)[m_colorTextNormal].getForeground();
			}
			return (*m_paintingProperties)[m_colorTextModify].getForeground();
		case ewol::widget::ListRole::BgColor:
			//return fluorine::Variant();
			//APPL_ERROR( m_colorBackground1 << " => " << (*m_paintingProperties)[m_colorBackground1].getForeground());
			if (    value.m_buffer == m_selection
			     && m_selection != null) {
				return (*m_paintingProperties)[m_colorBackgroundSelect].getForeground();
			}
			if (_pos.y() % 2) {
				return (*m_paintingProperties)[m_colorBackground1].getForeground();
			}
			return (*m_paintingProperties)[m_colorBackground2].getForeground();
		case ewol::widget::ListRole::Icon:
			/*
			if (elem->countToRoot() == 0) {
				return "THEME_GUI:///Home.svg?lib=ewol";
			}*/
			
			if (value.m_isFolder == true) {
				return "image_folder";
			} else {
				return "image_file";
			}
			return "";
		case ewol::widget::ListRole::DistanceToRoot:
			return uint_t(elem->countToRoot());
		case ewol::widget::ListRole::HaveChild:
			if (elem->haveChild() == true) {
				return true;
			}
			return value.m_haveChild;
		case ewol::widget::ListRole::IsExpand:
			return value.m_isExpand;
		case ewol::widget::ListRole::IsSelected:
			return false;
	}
	return fluorine::Variant();
}


bool appl::widget::BufferTree::onItemEvent(const ewol::event::Input& _event, const ivec2& _pos, const vec2& _mousePosition) {
	if (ewol::widget::TreeView::onItemEvent(_event, _pos, _mousePosition) == true) {
		return true;
	}
	auto elem = m_flatTree[_pos.y()];
	appl::TreeElement& value = elem->getData();
	if (_event.getId() == 1) {
		if (_event.getStatus() == gale::key::status::pressDouble) {
			if (value.m_isFolder == true) {
				populateNodeIfNeeded(m_flatTree[_pos.y()]);
				if (value.m_isExpand == true) {
					value.m_isExpand = false;
				} else {
					value.m_isExpand = true;
				}
				updateFlatTree();
				return true;
			} else if (value.m_buffer == null) {
				if (m_bufferManager != null) {
					APPL_INFO("Select file: '" << value.m_path << "' in list");
					m_bufferManager->open(value.m_path);
					value.m_buffer = m_bufferManager->get(value.m_path);
				}
				return true;
			}
		}
		if (_event.getStatus() == gale::key::status::pressSingle) {
			APPL_INFO("Event on List: " << _event << " pos=" << _pos );
			if (value.m_buffer != null) {
				if (m_bufferManager != null) {
					APPL_INFO("Select file: '" << value.m_path << "' in list");
					m_bufferManager->open(value.m_path);
				}
				return true;
			}
		}
		/*
		if(    _pos.y() >= 0
		    && _pos.y() < (int64_t)m_list.size()) {
			if (m_list[_pos.y()].m_buffer != null) {
				if (m_bufferManager != null) {
					APPL_INFO("Select file: '" << m_list[_pos.y()].m_buffer->getFileName() << "' in list");
					m_bufferManager->open(m_list[_pos.y()].m_buffer->getFileName());
				}
				return true;
			}
		}
		*/
	}
	return false;
}

void appl::widget::BufferTree::onChangePropertyShowUnNeeded() {
	updateFlatTree();
	markToRedraw();
}