virtualx-engine/editor/dependency_editor.cpp

/*************************************************************************/
/*  dependency_editor.cpp                                                */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include "dependency_editor.h"

#include "editor_node.h"
#include "io/resource_loader.h"
#include "os/file_access.h"
#include "scene/gui/margin_container.h"

void DependencyEditor::_notification(int p_what) {
}

void DependencyEditor::_searched(const String &p_path) {

	Map<String, String> dep_rename;
	dep_rename[replacing] = p_path;

	ResourceLoader::rename_dependencies(editing, dep_rename);

	_update_list();
	_update_file();
}

void DependencyEditor::_load_pressed(Object *p_item, int p_cell, int p_button) {

	TreeItem *ti = Object::cast_to<TreeItem>(p_item);
	String fname = ti->get_text(0);
	replacing = ti->get_text(1);

	search->set_title(TTR("Search Replacement For:") + " " + replacing.get_file());

	search->clear_filters();
	List<String> ext;
	ResourceLoader::get_recognized_extensions_for_type(ti->get_metadata(0), &ext);
	for (List<String>::Element *E = ext.front(); E; E = E->next()) {
		search->add_filter("*" + E->get());
	}
	search->popup_centered_ratio();
}

void DependencyEditor::_fix_and_find(EditorFileSystemDirectory *efsd, Map<String, Map<String, String> > &candidates) {

	for (int i = 0; i < efsd->get_subdir_count(); i++) {
		_fix_and_find(efsd->get_subdir(i), candidates);
	}

	for (int i = 0; i < efsd->get_file_count(); i++) {

		String file = efsd->get_file(i);
		if (!candidates.has(file))
			continue;

		String path = efsd->get_file_path(i);

		for (Map<String, String>::Element *E = candidates[file].front(); E; E = E->next()) {

			if (E->get() == String()) {
				E->get() = path;
				continue;
			}

			//must match the best, using subdirs
			String existing = E->get().replace_first("res://", "");
			String current = path.replace_first("res://", "");
			String lost = E->key().replace_first("res://", "");

			Vector<String> existingv = existing.split("/");
			existingv.invert();
			Vector<String> currentv = current.split("/");
			currentv.invert();
			Vector<String> lostv = lost.split("/");
			lostv.invert();

			int existing_score = 0;
			int current_score = 0;

			for (int j = 0; j < lostv.size(); j++) {

				if (j < existingv.size() && lostv[j] == existingv[j]) {
					existing_score++;
				}
				if (j < currentv.size() && lostv[j] == currentv[j]) {
					current_score++;
				}
			}

			if (current_score > existing_score) {

				//if it was the same, could track distance to new path but..

				E->get() = path; //replace by more accurate
			}
		}
	}
}

void DependencyEditor::_fix_all() {

	if (!EditorFileSystem::get_singleton()->get_filesystem())
		return;

	Map<String, Map<String, String> > candidates;

	for (List<String>::Element *E = missing.front(); E; E = E->next()) {

		String base = E->get().get_file();
		if (!candidates.has(base)) {
			candidates[base] = Map<String, String>();
		}

		candidates[base][E->get()] = "";
	}

	_fix_and_find(EditorFileSystem::get_singleton()->get_filesystem(), candidates);

	Map<String, String> remaps;

	for (Map<String, Map<String, String> >::Element *E = candidates.front(); E; E = E->next()) {

		for (Map<String, String>::Element *F = E->get().front(); F; F = F->next()) {

			if (F->get() != String()) {
				remaps[F->key()] = F->get();
			}
		}
	}

	if (remaps.size()) {

		ResourceLoader::rename_dependencies(editing, remaps);

		_update_list();
		_update_file();
	}
}

void DependencyEditor::_update_file() {

	EditorFileSystem::get_singleton()->update_file(editing);
}

void DependencyEditor::_update_list() {

	List<String> deps;
	ResourceLoader::get_dependencies(editing, &deps, true);

	tree->clear();
	missing.clear();

	TreeItem *root = tree->create_item();

	Ref<Texture> folder = get_icon("folder", "FileDialog");

	bool broken = false;

	for (List<String>::Element *E = deps.front(); E; E = E->next()) {

		TreeItem *item = tree->create_item(root);

		String n = E->get();
		String path;
		String type;

		if (n.find("::") != -1) {
			path = n.get_slice("::", 0);
			type = n.get_slice("::", 1);
		} else {
			path = n;
			type = "Resource";
		}
		String name = path.get_file();

		Ref<Texture> icon;
		if (has_icon(type, "EditorIcons")) {
			icon = get_icon(type, "EditorIcons");
		} else {
			icon = get_icon("Object", "EditorIcons");
		}
		item->set_text(0, name);
		item->set_icon(0, icon);
		item->set_metadata(0, type);
		item->set_text(1, path);

		if (!FileAccess::exists(path)) {
			item->set_custom_color(1, Color(1, 0.4, 0.3));
			missing.push_back(path);
			broken = true;
		}

		item->add_button(1, folder, 0);
	}

	fixdeps->set_disabled(!broken);
}

void DependencyEditor::edit(const String &p_path) {

	editing = p_path;
	set_title(TTR("Dependencies For:") + " " + p_path.get_file());

	_update_list();
	popup_centered_ratio();

	if (EditorNode::get_singleton()->is_scene_open(p_path)) {
		EditorNode::get_singleton()->show_warning(vformat(TTR("Scene '%s' is currently being edited.\nChanges will not take effect unless reloaded."), p_path.get_file()));
	} else if (ResourceCache::has(p_path)) {
		EditorNode::get_singleton()->show_warning(vformat(TTR("Resource '%s' is in use.\nChanges will take effect when reloaded."), p_path.get_file()));
	}
}

void DependencyEditor::_bind_methods() {

	ClassDB::bind_method(D_METHOD("_searched"), &DependencyEditor::_searched);
	ClassDB::bind_method(D_METHOD("_load_pressed"), &DependencyEditor::_load_pressed);
	ClassDB::bind_method(D_METHOD("_fix_all"), &DependencyEditor::_fix_all);
}

DependencyEditor::DependencyEditor() {

	VBoxContainer *vb = memnew(VBoxContainer);
	vb->set_name(TTR("Dependencies"));
	add_child(vb);

	tree = memnew(Tree);
	tree->set_columns(2);
	tree->set_column_titles_visible(true);
	tree->set_column_title(0, TTR("Resource"));
	tree->set_column_title(1, TTR("Path"));
	tree->set_hide_root(true);
	tree->connect("button_pressed", this, "_load_pressed");

	HBoxContainer *hbc = memnew(HBoxContainer);
	Label *label = memnew(Label(TTR("Dependencies:")));
	hbc->add_child(label);
	hbc->add_spacer();
	fixdeps = memnew(Button(TTR("Fix Broken")));
	hbc->add_child(fixdeps);
	fixdeps->connect("pressed", this, "_fix_all");

	vb->add_child(hbc);

	MarginContainer *mc = memnew(MarginContainer);
	mc->set_v_size_flags(SIZE_EXPAND_FILL);

	mc->add_child(tree);
	vb->add_child(mc);

	set_title(TTR("Dependency Editor"));
	search = memnew(EditorFileDialog);
	search->connect("file_selected", this, "_searched");
	search->set_mode(EditorFileDialog::MODE_OPEN_FILE);
	search->set_title(TTR("Search Replacement Resource:"));
	add_child(search);
}

/////////////////////////////////////
void DependencyEditorOwners::_list_rmb_select(int p_item, const Vector2 &p_pos) {

	file_options->clear();
	file_options->set_size(Size2(1, 1));
	if (p_item >= 0) {
		file_options->add_item(TTR("Open"), FILE_OPEN);
	}

	file_options->set_position(owners->get_global_position() + p_pos);
	file_options->popup();
}

void DependencyEditorOwners::_select_file(int p_idx) {

	String fpath = owners->get_item_text(p_idx);

	if (ResourceLoader::get_resource_type(fpath) == "PackedScene") {
		editor->open_request(fpath);
		hide();
		emit_signal("confirmed");
	}
}

void DependencyEditorOwners::_file_option(int p_option) {

	switch (p_option) {
		case FILE_OPEN: {
			int idx = owners->get_current();
			if (idx < 0 || idx >= owners->get_item_count())
				break;
			_select_file(idx);
		} break;
	}
}

void DependencyEditorOwners::_bind_methods() {

	ClassDB::bind_method(D_METHOD("_list_rmb_select"), &DependencyEditorOwners::_list_rmb_select);
	ClassDB::bind_method(D_METHOD("_file_option"), &DependencyEditorOwners::_file_option);
	ClassDB::bind_method(D_METHOD("_select_file"), &DependencyEditorOwners::_select_file);
}

void DependencyEditorOwners::_fill_owners(EditorFileSystemDirectory *efsd) {

	if (!efsd)
		return;

	for (int i = 0; i < efsd->get_subdir_count(); i++) {
		_fill_owners(efsd->get_subdir(i));
	}

	for (int i = 0; i < efsd->get_file_count(); i++) {

		Vector<String> deps = efsd->get_file_deps(i);
		bool found = false;
		for (int j = 0; j < deps.size(); j++) {
			if (deps[j] == editing) {
				found = true;
				break;
			}
		}
		if (!found)
			continue;

		Ref<Texture> icon;
		String type = efsd->get_file_type(i);
		if (!has_icon(type, "EditorIcons")) {
			icon = get_icon("Object", "EditorIcons");
		} else {
			icon = get_icon(type, "EditorIcons");
		}

		owners->add_item(efsd->get_file_path(i), icon);
	}
}

void DependencyEditorOwners::show(const String &p_path) {

	editing = p_path;
	owners->clear();
	_fill_owners(EditorFileSystem::get_singleton()->get_filesystem());
	popup_centered_ratio();

	set_title(TTR("Owners Of:") + " " + p_path.get_file());
}

DependencyEditorOwners::DependencyEditorOwners(EditorNode *p_editor) {

	editor = p_editor;

	file_options = memnew(PopupMenu);
	add_child(file_options);
	file_options->connect("id_pressed", this, "_file_option");

	owners = memnew(ItemList);
	owners->set_select_mode(ItemList::SELECT_SINGLE);
	owners->connect("item_rmb_selected", this, "_list_rmb_select");
	owners->connect("item_activated", this, "_select_file");
	owners->set_allow_rmb_select(true);
	add_child(owners);
}

///////////////////////

void DependencyRemoveDialog::_find_files_in_removed_folder(EditorFileSystemDirectory *efsd, const String &p_folder) {
	if (!efsd)
		return;

	for (int i = 0; i < efsd->get_subdir_count(); ++i) {
		_find_files_in_removed_folder(efsd->get_subdir(i), p_folder);
	}
	for (int i = 0; i < efsd->get_file_count(); i++) {
		String file = efsd->get_file_path(i);
		ERR_FAIL_COND(all_remove_files.has(file)); //We are deleting a directory which is contained in a directory we are deleting...
		all_remove_files[file] = p_folder; //Point the file to the ancestor directory we are deleting so we know what to parent it under in the tree.
	}
}

void DependencyRemoveDialog::_find_all_removed_dependencies(EditorFileSystemDirectory *efsd, Vector<RemovedDependency> &p_removed) {
	if (!efsd)
		return;

	for (int i = 0; i < efsd->get_subdir_count(); i++) {
		_find_all_removed_dependencies(efsd->get_subdir(i), p_removed);
	}

	for (int i = 0; i < efsd->get_file_count(); i++) {
		const String path = efsd->get_file_path(i);

		//It doesn't matter if a file we are about to delete will have some of its dependencies removed too
		if (all_remove_files.has(path))
			continue;

		Vector<String> all_deps = efsd->get_file_deps(i);
		for (int j = 0; j < all_deps.size(); ++j) {
			if (all_remove_files.has(all_deps[j])) {
				RemovedDependency dep;
				dep.file = path;
				dep.file_type = efsd->get_file_type(i);
				dep.dependency = all_deps[j];
				dep.dependency_folder = all_remove_files[all_deps[j]];
				p_removed.push_back(dep);
			}
		}
	}
}

void DependencyRemoveDialog::_build_removed_dependency_tree(const Vector<RemovedDependency> &p_removed) {
	owners->clear();
	owners->create_item(); // root

	Map<String, TreeItem *> tree_items;
	for (int i = 0; i < p_removed.size(); i++) {
		RemovedDependency rd = p_removed[i];

		//Ensure that the dependency is already in the tree
		if (!tree_items.has(rd.dependency)) {
			if (rd.dependency_folder.length() > 0) {
				//Ensure the ancestor folder is already in the tree
				if (!tree_items.has(rd.dependency_folder)) {
					TreeItem *folder_item = owners->create_item(owners->get_root());
					folder_item->set_text(0, rd.dependency_folder);
					folder_item->set_icon(0, get_icon("Folder", "EditorIcons"));
					tree_items[rd.dependency_folder] = folder_item;
				}
				TreeItem *dependency_item = owners->create_item(tree_items[rd.dependency_folder]);
				dependency_item->set_text(0, rd.dependency);
				dependency_item->set_icon(0, get_icon("Warning", "EditorIcons"));
				tree_items[rd.dependency] = dependency_item;
			} else {
				TreeItem *dependency_item = owners->create_item(owners->get_root());
				dependency_item->set_text(0, rd.dependency);
				dependency_item->set_icon(0, get_icon("Warning", "EditorIcons"));
				tree_items[rd.dependency] = dependency_item;
			}
		}

		//List this file under this dependency
		Ref<Texture> icon = has_icon(rd.file_type, "EditorIcons") ? get_icon(rd.file_type, "EditorIcons") : get_icon("Object", "EditorIcons");
		TreeItem *file_item = owners->create_item(tree_items[rd.dependency]);
		file_item->set_text(0, rd.file);
		file_item->set_icon(0, icon);
	}
}

void DependencyRemoveDialog::show(const Vector<String> &p_folders, const Vector<String> &p_files) {
	all_remove_files.clear();
	dirs_to_delete.clear();
	files_to_delete.clear();
	owners->clear();

	for (int i = 0; i < p_folders.size(); ++i) {
		String folder = p_folders[i].ends_with("/") ? p_folders[i] : (p_folders[i] + "/");
		_find_files_in_removed_folder(EditorFileSystem::get_singleton()->get_filesystem_path(folder), folder);
		dirs_to_delete.push_back(folder);
	}
	for (int i = 0; i < p_files.size(); ++i) {
		all_remove_files[p_files[i]] = String();
		files_to_delete.push_back(p_files[i]);
	}

	Vector<RemovedDependency> removed_deps;
	_find_all_removed_dependencies(EditorFileSystem::get_singleton()->get_filesystem(), removed_deps);
	removed_deps.sort();

	if (removed_deps.empty()) {
		owners->hide();
		text->set_text(TTR("Remove selected files from the project? (no undo)"));
		popup_centered_minsize(Size2(400, 100));
	} else {
		_build_removed_dependency_tree(removed_deps);
		owners->show();
		text->set_text(TTR("The files being removed are required by other resources in order for them to work.\nRemove them anyway? (no undo)"));
		popup_centered_minsize(Size2(500, 350));
	}
}

void DependencyRemoveDialog::ok_pressed() {

	for (int i = 0; i < files_to_delete.size(); ++i) {
		if (ResourceCache::has(files_to_delete[i])) {
			Resource *res = ResourceCache::get(files_to_delete[i]);
			res->set_path("");
		}
		String path = OS::get_singleton()->get_resource_dir() + files_to_delete[i].replace_first("res://", "/");
		print_verbose("Moving to trash: " + path);
		Error err = OS::get_singleton()->move_to_trash(path);
		if (err != OK) {
			EditorNode::get_singleton()->add_io_error(TTR("Cannot remove:") + "\n" + files_to_delete[i] + "\n");
		}
	}

	if (dirs_to_delete.size() == 0) {
		//If we only deleted files we should only need to tell the file system about the files we touched.
		for (int i = 0; i < files_to_delete.size(); ++i)
			EditorFileSystem::get_singleton()->update_file(files_to_delete[i]);
	} else {

		for (int i = 0; i < dirs_to_delete.size(); ++i) {
			String path = OS::get_singleton()->get_resource_dir() + dirs_to_delete[i].replace_first("res://", "/");
			print_verbose("Moving to trash: " + path);
			Error err = OS::get_singleton()->move_to_trash(path);
			if (err != OK) {
				EditorNode::get_singleton()->add_io_error(TTR("Cannot remove:") + "\n" + dirs_to_delete[i] + "\n");
			}
		}

		// if some dirs would be deleted, favorite dirs need to be updated
		Vector<String> previous_favorite_dirs = EditorSettings::get_singleton()->get_favorite_dirs();
		Vector<String> new_favorite_dirs;

		for (int i = 0; i < previous_favorite_dirs.size(); ++i) {
			if (dirs_to_delete.find(previous_favorite_dirs[i] + "/") < 0) {
				new_favorite_dirs.push_back(previous_favorite_dirs[i]);
			}
		}

		if (new_favorite_dirs.size() < previous_favorite_dirs.size()) {
			EditorSettings::get_singleton()->set_favorite_dirs(new_favorite_dirs);
		}

		EditorFileSystem::get_singleton()->scan_changes();
	}
}

DependencyRemoveDialog::DependencyRemoveDialog() {

	VBoxContainer *vb = memnew(VBoxContainer);
	add_child(vb);

	text = memnew(Label);
	vb->add_child(text);

	owners = memnew(Tree);
	owners->set_hide_root(true);
	vb->add_child(owners);
	owners->set_v_size_flags(SIZE_EXPAND_FILL);
	get_ok()->set_text(TTR("Remove"));
}

//////////////

void DependencyErrorDialog::show(const String &p_for_file, const Vector<String> &report) {

	for_file = p_for_file;
	set_title(TTR("Error loading:") + " " + p_for_file.get_file());
	files->clear();

	TreeItem *root = files->create_item(NULL);
	for (int i = 0; i < report.size(); i++) {

		String dep;
		String type = "Object";
		dep = report[i].get_slice("::", 0);
		if (report[i].get_slice_count("::") > 0)
			type = report[i].get_slice("::", 1);

		Ref<Texture> icon;
		if (!has_icon(type, "EditorIcons")) {
			icon = get_icon("Object", "EditorIcons");
		} else {
			icon = get_icon(type, "EditorIcons");
		}

		TreeItem *ti = files->create_item(root);
		ti->set_text(0, dep);
		ti->set_icon(0, icon);
	}

	popup_centered_minsize(Size2(500, 220));
}

void DependencyErrorDialog::ok_pressed() {

	EditorNode::get_singleton()->load_scene(for_file, true);
}

void DependencyErrorDialog::custom_action(const String &) {

	EditorNode::get_singleton()->fix_dependencies(for_file);
}

DependencyErrorDialog::DependencyErrorDialog() {

	VBoxContainer *vb = memnew(VBoxContainer);
	add_child(vb);

	files = memnew(Tree);
	files->set_hide_root(true);
	vb->add_margin_child(TTR("Scene failed to load due to missing dependencies:"), files, true);
	files->set_v_size_flags(SIZE_EXPAND_FILL);
	files->set_custom_minimum_size(Size2(1, 200));
	get_ok()->set_text(TTR("Open Anyway"));
	get_cancel()->set_text(TTR("Close"));

	text = memnew(Label);
	vb->add_child(text);
	text->set_text(TTR("Which action should be taken?"));

	fdep = add_button(TTR("Fix Dependencies"), true, "fixdeps");

	set_title(TTR("Errors loading!"));
}

//////////////////////////////////////////////////////////////////////

void OrphanResourcesDialog::ok_pressed() {

	paths.clear();

	_find_to_delete(files->get_root(), paths);
	if (paths.empty())
		return;

	delete_confirm->set_text(vformat(TTR("Permanently delete %d item(s)? (No undo!)"), paths.size()));
	delete_confirm->popup_centered_minsize();
}

bool OrphanResourcesDialog::_fill_owners(EditorFileSystemDirectory *efsd, HashMap<String, int> &refs, TreeItem *p_parent) {

	if (!efsd)
		return false;

	bool has_children = false;

	for (int i = 0; i < efsd->get_subdir_count(); i++) {

		TreeItem *dir_item = NULL;
		if (p_parent) {
			dir_item = files->create_item(p_parent);
			dir_item->set_text(0, efsd->get_subdir(i)->get_name());
			dir_item->set_icon(0, get_icon("folder", "FileDialog"));
		}
		bool children = _fill_owners(efsd->get_subdir(i), refs, dir_item);

		if (p_parent) {
			if (!children) {
				memdelete(dir_item);
			} else {
				has_children = true;
			}
		}
	}

	for (int i = 0; i < efsd->get_file_count(); i++) {

		if (!p_parent) {
			Vector<String> deps = efsd->get_file_deps(i);
			for (int j = 0; j < deps.size(); j++) {

				if (!refs.has(deps[j])) {
					refs[deps[j]] = 1;
				}
			}
		} else {

			String path = efsd->get_file_path(i);
			if (!refs.has(path)) {
				TreeItem *ti = files->create_item(p_parent);
				ti->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
				ti->set_text(0, efsd->get_file(i));
				ti->set_editable(0, true);

				String type = efsd->get_file_type(i);

				Ref<Texture> icon;
				if (has_icon(type, "EditorIcons")) {
					icon = get_icon(type, "EditorIcons");
				} else {
					icon = get_icon("Object", "EditorIcons");
				}
				ti->set_icon(0, icon);
				int ds = efsd->get_file_deps(i).size();
				ti->set_text(1, itos(ds));
				if (ds) {
					ti->add_button(1, get_icon("GuiVisibilityVisible", "EditorIcons"));
				}
				ti->set_metadata(0, path);
				has_children = true;
			}
		}
	}

	return has_children;
}

void OrphanResourcesDialog::refresh() {
	HashMap<String, int> refs;
	_fill_owners(EditorFileSystem::get_singleton()->get_filesystem(), refs, NULL);
	files->clear();
	TreeItem *root = files->create_item();
	_fill_owners(EditorFileSystem::get_singleton()->get_filesystem(), refs, root);
}

void OrphanResourcesDialog::show() {

	refresh();
	popup_centered_ratio();
}

void OrphanResourcesDialog::_find_to_delete(TreeItem *p_item, List<String> &paths) {

	while (p_item) {

		if (p_item->get_cell_mode(0) == TreeItem::CELL_MODE_CHECK && p_item->is_checked(0)) {
			paths.push_back(p_item->get_metadata(0));
		}

		if (p_item->get_children()) {
			_find_to_delete(p_item->get_children(), paths);
		}

		p_item = p_item->get_next();
	}
}

void OrphanResourcesDialog::_delete_confirm() {

	DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
	for (List<String>::Element *E = paths.front(); E; E = E->next()) {

		da->remove(E->get());
		EditorFileSystem::get_singleton()->update_file(E->get());
	}
	memdelete(da);
	refresh();
}

void OrphanResourcesDialog::_button_pressed(Object *p_item, int p_column, int p_id) {

	TreeItem *ti = Object::cast_to<TreeItem>(p_item);

	String path = ti->get_metadata(0);
	dep_edit->edit(path);
}

void OrphanResourcesDialog::_bind_methods() {

	ClassDB::bind_method(D_METHOD("_delete_confirm"), &OrphanResourcesDialog::_delete_confirm);
	ClassDB::bind_method(D_METHOD("_button_pressed"), &OrphanResourcesDialog::_button_pressed);
}

OrphanResourcesDialog::OrphanResourcesDialog() {

	VBoxContainer *vbc = memnew(VBoxContainer);
	add_child(vbc);

	files = memnew(Tree);
	files->set_columns(2);
	files->set_column_titles_visible(true);
	files->set_column_min_width(1, 100);
	files->set_column_expand(0, true);
	files->set_column_expand(1, false);
	files->set_column_title(0, TTR("Resource"));
	files->set_column_title(1, TTR("Owns"));
	files->set_hide_root(true);
	vbc->add_margin_child(TTR("Resources Without Explicit Ownership:"), files, true);
	set_title(TTR("Orphan Resource Explorer"));
	delete_confirm = memnew(ConfirmationDialog);
	delete_confirm->set_text(TTR("Delete selected files?"));
	get_ok()->set_text(TTR("Delete"));
	add_child(delete_confirm);
	dep_edit = memnew(DependencyEditor);
	add_child(dep_edit);
	files->connect("button_pressed", this, "_button_pressed");
	delete_confirm->connect("confirmed", this, "_delete_confirm");
	set_hide_on_ok(false);
}