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

String dname = p_dir->get_name();

if (dname == "")

dname = "res://";

item->set_text(0, dname);

item->set_icon(0, get_icon("Folder", "EditorIcons"));

item->set_selectable(0, true);

String lpath = p_dir->get_path();

if (lpath != "res://" && lpath.ends_with("/")) {

lpath = lpath.substr(0, lpath.length() - 1);

}

item->set_metadata(0, lpath);

if (lpath == path) {

item->select(0);

}

if ((path.begins_with(lpath) && path != lpath)) {

item->set_collapsed(false);

} else {

bool is_collapsed = true;

for (int i = 0; i < uncollapsed_paths.size(); i++) {

if (lpath == uncollapsed_paths[i]) {

is_collapsed = false;

break;

}

}

item->set_collapsed(is_collapsed);

}

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

_create_tree(item, p_dir->get_subdir(i), uncollapsed_paths);

return true;

Vector<String> uncollapsed_paths;

if (keep_collapse_state) {

TreeItem *root = tree->get_root();

if (root) {

TreeItem *resTree = root->get_children()->get_next();

Vector<TreeItem *> needs_check;

needs_check.push_back(resTree);

while (needs_check.size()) {

if (!needs_check[0]->is_collapsed()) {

uncollapsed_paths.push_back(needs_check[0]->get_metadata(0));

TreeItem *child = needs_check[0]->get_children();

while (child) {

needs_check.push_back(child);

child = child->get_next();

}

}

needs_check.remove(0);

}

}

}

tree->clear();

updating_tree = true;

TreeItem *root = tree->create_item();

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

favorites->set_icon(0, get_icon("Favorites", "EditorIcons"));

favorites->set_text(0, TTR("Favorites:"));

favorites->set_selectable(0, false);

Vector<String> favorite_paths = EditorSettings::get_singleton()->get_favorite_dirs();

String res_path = "res://";

Ref<Texture> folder_icon = get_icon("Folder", "EditorIcons");

for (int i = 0; i < favorite_paths.size(); i++) {

String fave = favorite_paths[i];

if (!fave.begins_with(res_path))

continue;

TreeItem *ti = tree->create_item(favorites);

if (fave == res_path)

ti->set_text(0, "/");

else

ti->set_text(0, fave.get_file());

ti->set_icon(0, folder_icon);

ti->set_selectable(0, true);

ti->set_metadata(0, fave);

}

if (p_uncollapse_root) {

uncollapsed_paths.push_back("res://");

}

_create_tree(root, EditorFileSystem::get_singleton()->get_filesystem(), uncollapsed_paths);

tree->ensure_cursor_is_visible();

updating_tree = false;

switch (p_what) {

case NOTIFICATION_RESIZED: {

bool new_mode = get_size().height < get_viewport_rect().size.height / 2;

if (new_mode != low_height_mode) {

low_height_mode = new_mode;

if (low_height_mode) {

tree->hide();

tree->set_v_size_flags(SIZE_EXPAND_FILL);

button_tree->show();

} else {

tree->set_v_size_flags(SIZE_FILL);

button_tree->hide();

if (!tree->is_visible()) {

tree->show();

button_favorite->show();

_update_tree(true);

}

tree->ensure_cursor_is_visible();

if (!file_list_vb->is_visible()) {

file_list_vb->show();

_update_files(true);

}

}

}

} break;

case NOTIFICATION_ENTER_TREE: {

if (initialized)

return;

initialized = true;

EditorFileSystem::get_singleton()->connect("filesystem_changed", this, "_fs_changed");

EditorResourcePreview::get_singleton()->connect("preview_invalidated", this, "_preview_invalidated");

String ei = "EditorIcons";

button_reload->set_icon(get_icon("Reload", ei));

button_favorite->set_icon(get_icon("Favorites", ei));

//button_instance->set_icon(get_icon("Add", ei));

//button_open->set_icon(get_icon("Folder", ei));

button_tree->set_icon(get_icon("Filesystem", ei));

_update_file_display_toggle_button();

button_display_mode->connect("pressed", this, "_change_file_display");

//file_options->set_icon( get_icon("Tools","ei"));

files->connect("item_activated", this, "_select_file");

button_hist_next->connect("pressed", this, "_fw_history");

button_hist_prev->connect("pressed", this, "_bw_history");

search_box->add_icon_override("right_icon", get_icon("Search", ei));

button_hist_next->set_icon(get_icon("Forward", ei));

button_hist_prev->set_icon(get_icon("Back", ei));

file_options->connect("id_pressed", this, "_file_option");

folder_options->connect("id_pressed", this, "_folder_option");

button_tree->connect("pressed", this, "_go_to_tree", varray(), CONNECT_DEFERRED);

current_path->connect("text_entered", this, "navigate_to_path");

if (EditorFileSystem::get_singleton()->is_scanning()) {

_set_scanning_mode();

} else {

_update_tree(false, true);

}

} break;

case NOTIFICATION_PROCESS: {

if (EditorFileSystem::get_singleton()->is_scanning()) {

scanning_progress->set_value(EditorFileSystem::get_singleton()->get_scanning_progress() * 100);

}

} break;

case NOTIFICATION_EXIT_TREE: {

} break;

case NOTIFICATION_DRAG_BEGIN: {

Dictionary dd = get_viewport()->gui_get_drag_data();

if (tree->is_visible_in_tree() && dd.has("type")) {

if ((String(dd["type"]) == "files") || (String(dd["type"]) == "files_and_dirs") || (String(dd["type"]) == "resource")) {

tree->set_drop_mode_flags(Tree::DROP_MODE_ON_ITEM);

} else if ((String(dd["type"]) == "favorite")) {

tree->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN);

}

}

} break;

case NOTIFICATION_DRAG_END: {

tree->set_drop_mode_flags(0);

} break;

case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {

String ei = "EditorIcons";

int new_mode = int(EditorSettings::get_singleton()->get("docks/filesystem/display_mode"));

//_update_icons

button_reload->set_icon(get_icon("Reload", ei));

button_favorite->set_icon(get_icon("Favorites", ei));

button_tree->set_icon(get_icon("Filesystem", ei));

button_hist_next->set_icon(get_icon("Forward", ei));

button_hist_prev->set_icon(get_icon("Back", ei));

search_box->add_icon_override("right_icon", get_icon("Search", ei));

if (new_mode != display_mode) {

set_display_mode(new_mode);

} else {

_update_file_display_toggle_button();

_update_files(true);

}

_update_tree(true);

} break;

}

TreeItem *sel = tree->get_selected();

if (!sel)

return;

path = sel->get_metadata(0);

bool found = false;

Vector<String> favorites = EditorSettings::get_singleton()->get_favorite_dirs();

for (int i = 0; i < favorites.size(); i++) {

if (favorites[i] == path) {

found = true;

break;

}

}

button_favorite->set_pressed(found);

current_path->set_text(path);

_push_to_history();

if (!low_height_mode) {

_update_files(false);

}

TreeItem *sel = tree->get_selected();

if (!sel)

return;

path = sel->get_metadata(0);

int idx = -1;

Vector<String> favorites = EditorSettings::get_singleton()->get_favorite_dirs();

for (int i = 0; i < favorites.size(); i++) {

if (favorites[i] == path) {

idx = i;

break;

}

}

if (idx == -1) {

favorites.push_back(path);

} else {

favorites.remove(idx);

}

EditorSettings::get_singleton()->set_favorite_dirs(favorites);

_update_tree(true);

TreeItem *sel = tree->get_selected();

if (!sel)

return "";

return sel->get_metadata(0);

// If the path is a file, do not only go to the directory in the tree, also select the file in the file list.

String file_name = "";

DirAccess *dirAccess = DirAccess::open("res://");

if (dirAccess->file_exists(p_path)) {

path = p_path.get_base_dir();

file_name = p_path.get_file();

} else if (dirAccess->dir_exists(p_path)) {

path = p_path;

} else {

ERR_EXPLAIN(vformat(TTR("Cannot navigate to '%s' as it has not been found in the file system!"), p_path));

ERR_FAIL();

}

current_path->set_text(path);

_push_to_history();

if (!low_height_mode) {

_update_tree(true);

_update_files(false);

} else {

_go_to_file_list();

}

if (!file_name.empty()) {

for (int i = 0; i < files->get_item_count(); i++) {

if (files->get_item_text(i) == file_name) {

files->select(i, true);

files->ensure_current_is_visible();

break;

}

}

}

if ((file_list_vb->is_visible_in_tree() || path == p_path.get_base_dir()) && p_preview.is_valid()) {

Array uarr = p_udata;

int idx = uarr[0];

String file = uarr[1];

if (idx < files->get_item_count() && files->get_item_text(idx) == file && files->get_item_metadata(idx) == p_path)

files->set_item_icon(idx, p_preview);

}

if (button_display_mode->is_pressed()) {

display_mode = DISPLAY_LIST;

button_display_mode->set_icon(get_icon("FileThumbnail", "EditorIcons"));

button_display_mode->set_tooltip(TTR("View items as a grid of thumbnails"));

} else {

display_mode = DISPLAY_THUMBNAILS;

button_display_mode->set_icon(get_icon("FileList", "EditorIcons"));

button_display_mode->set_tooltip(TTR("View items as a list"));

}

_update_file_display_toggle_button();

EditorSettings::get_singleton()->set("docks/filesystem/display_mode", display_mode);

_update_files(true);

if (matches->size() > p_max_items)

return;

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

_search(p_path->get_subdir(i), matches, p_max_items);

}

String match = search_box->get_text().to_lower();

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

String file = p_path->get_file(i);

if (file.to_lower().find(match) != -1) {

FileInfo fi;

fi.name = file;

fi.type = p_path->get_file_type(i);

fi.path = p_path->get_file_path(i);

fi.import_broken = !p_path->get_file_import_is_valid(i);

fi.import_status = 0;

matches->push_back(fi);

if (matches->size() > p_max_items)

return;

}

}

Set<String> cselection;

if (p_keep_selection) {

for (int i = 0; i < files->get_item_count(); i++) {

if (files->is_selected(i))

cselection.insert(files->get_item_text(i));

}

}

files->clear();

current_path->set_text(path);

EditorFileSystemDirectory *efd = EditorFileSystem::get_singleton()->get_filesystem_path(path);

if (!efd)

return;

String ei = "EditorIcons";

int thumbnail_size = EditorSettings::get_singleton()->get("docks/filesystem/thumbnail_size");

thumbnail_size *= EDSCALE;

Ref<Texture> folder_thumbnail;

Ref<Texture> file_thumbnail;

Ref<Texture> file_thumbnail_broken;

bool always_show_folders = EditorSettings::get_singleton()->get("docks/filesystem/always_show_folders");

bool use_thumbnails = (display_mode == DISPLAY_THUMBNAILS);

bool use_folders = search_box->get_text().length() == 0 && (low_height_mode || always_show_folders);

if (use_thumbnails) {

files->set_max_columns(0);

files->set_icon_mode(ItemList::ICON_MODE_TOP);

files->set_fixed_column_width(thumbnail_size * 3 / 2);

files->set_max_text_lines(2);

files->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size));

if (thumbnail_size < 64) {

folder_thumbnail = get_icon("FolderMediumThumb", ei);

file_thumbnail = get_icon("FileMediumThumb", ei);

file_thumbnail_broken = get_icon("FileDeadMediumThumb", ei);

} else {

folder_thumbnail = get_icon("FolderBigThumb", ei);

file_thumbnail = get_icon("FileBigThumb", ei);

file_thumbnail_broken = get_icon("FileDeadBigThumb", ei);

}

} else {

files->set_icon_mode(ItemList::ICON_MODE_LEFT);

files->set_max_columns(1);

files->set_max_text_lines(1);

files->set_fixed_column_width(0);

files->set_fixed_icon_size(Size2());

}

if (use_folders) {

Ref<Texture> folderIcon = (use_thumbnails) ? folder_thumbnail : get_icon("folder", "FileDialog");

if (path != "res://") {

files->add_item("..", folderIcon, true);

String bd = path.get_base_dir();

if (bd != "res://" && !bd.ends_with("/"))

bd += "/";

files->set_item_metadata(files->get_item_count() - 1, bd);

}

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

String dname = efd->get_subdir(i)->get_name();

files->add_item(dname, folderIcon, true);

files->set_item_metadata(files->get_item_count() - 1, path.plus_file(dname) + "/");

if (cselection.has(dname))

files->select(files->get_item_count() - 1, false);

}

}

List<FileInfo> filelist;

if (search_box->get_text().length() > 0) {

_search(EditorFileSystem::get_singleton()->get_filesystem(), &filelist, 128);

filelist.sort();

} else {

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

FileInfo fi;

fi.name = efd->get_file(i);

fi.path = path.plus_file(fi.name);

fi.type = efd->get_file_type(i);

fi.import_broken = !efd->get_file_import_is_valid(i);

fi.import_status = 0;

filelist.push_back(fi);

}

filelist.sort();

}

String oi = "Object";

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

FileInfo *finfo = &(E->get());

String fname = finfo->name;

String fpath = finfo->path;

String ftype = finfo->type;

Ref<Texture> type_icon;

Ref<Texture> big_icon;

String tooltip = fname;

if (!finfo->import_broken) {

type_icon = (has_icon(ftype, ei)) ? get_icon(ftype, ei) : get_icon(oi, ei);

big_icon = file_thumbnail;

} else {

type_icon = get_icon("ImportFail", ei);

big_icon = file_thumbnail_broken;

tooltip += "\n" + TTR("Status: Import of file failed. Please fix file and reimport manually.");

}

int item_index;

if (use_thumbnails) {

files->add_item(fname, big_icon, true);

item_index = files->get_item_count() - 1;

files->set_item_metadata(item_index, fpath);

files->set_item_tag_icon(item_index, type_icon);

if (!finfo->import_broken) {

Array udata;

udata.resize(2);

udata[0] = item_index;

udata[1] = fname;

EditorResourcePreview::get_singleton()->queue_resource_preview(fpath, this, "_thumbnail_done", udata);

}

} else {

files->add_item(fname, type_icon, true);

item_index = files->get_item_count() - 1;

files->set_item_metadata(item_index, fpath);

}

if (cselection.has(fname))

files->select(item_index, false);

if (finfo->sources.size()) {

for (int j = 0; j < finfo->sources.size(); j++) {

tooltip += "\nSource: " + finfo->sources[j];

}

}

files->set_item_tooltip(item_index, tooltip);

}

String fpath = files->get_item_metadata(p_idx);

if (fpath.ends_with("/")) {

if (fpath != "res://") {

fpath = fpath.substr(0, fpath.length() - 1);

}

navigate_to_path(fpath);

} else {

if (ResourceLoader::get_resource_type(fpath) == "PackedScene") {

editor->open_request(fpath);

} else {

editor->load_resource(fpath);

}

}

if (low_height_mode) {

tree->show();

button_favorite->show();

file_list_vb->hide();

}

_update_tree(true);

tree->grab_focus();

tree->ensure_cursor_is_visible();

//button_open->hide();

//file_options->hide();

if (display_mode == DISPLAY_THUMBNAILS && p_path.get_base_dir() == path && search_box->get_text() == String() && file_list_vb->is_visible_in_tree()) {

for (int i = 0; i < files->get_item_count(); i++) {

if (files->get_item_metadata(i) == p_path) {

//re-request preview

Array udata;

udata.resize(2);

udata[0] = i;

udata[1] = files->get_item_text(i);

EditorResourcePreview::get_singleton()->queue_resource_preview(p_path, this, "_thumbnail_done", udata);

break;

}

}

}

button_hist_prev->set_disabled(history_pos == 0);

button_hist_next->set_disabled(history_pos == history.size() - 1);

scanning_vb->hide();

split_box->show();

if (tree->is_visible()) {

_update_tree(true);

}

if (file_list_vb->is_visible()) {

_update_files(true);

}

set_process(false);

button_hist_prev->set_disabled(true);

button_hist_next->set_disabled(true);

split_box->hide();

scanning_vb->show();

set_process(true);

if (EditorFileSystem::get_singleton()->is_scanning()) {

scanning_progress->set_value(EditorFileSystem::get_singleton()->get_scanning_progress() * 100);

} else {

scanning_progress->set_value(0);

}

if (history_pos < history.size() - 1)

history_pos++;

_update_history();

if (history_pos > 0)

history_pos--;

_update_history();

path = history[history_pos];

current_path->set_text(path);

if (tree->is_visible()) {

_update_tree(true);

tree->grab_focus();

tree->ensure_cursor_is_visible();

}

if (file_list_vb->is_visible()) {

_update_files(false);

}

button_hist_prev->set_disabled(history_pos == 0);

button_hist_next->set_disabled(history_pos == history.size() - 1);

if (history[history_pos] != path) {

history.resize(history_pos + 1);

history.push_back(path);

history_pos++;

if (history.size() > history_max_size) {

history.remove(0);

history_pos = history_max_size - 1;

}

}

button_hist_prev->set_disabled(history_pos == 0);

button_hist_next->set_disabled(history_pos == history.size() - 1);

if (efsd == NULL)

return;

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

folders.push_back(efsd->get_subdir(i)->get_path());

_get_all_items_in_dir(efsd->get_subdir(i), files, folders);

}

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

files.push_back(efsd->get_file_path(i));

}

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

_find_remaps(efsd->get_subdir(i), renames, to_remaps);

}

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

Vector<String> deps = efsd->get_file_deps(i);

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

if (renames.has(deps[j])) {

to_remaps.push_back(efsd->get_file_path(i));

break;

}

}

}

Map<String, String> &p_file_renames, Map<String, String> &p_folder_renames) const {

//Ensure folder paths end with "/"

String old_path = (p_item.is_file || p_item.path.ends_with("/")) ? p_item.path : (p_item.path + "/");

String new_path = (p_item.is_file || p_new_path.ends_with("/")) ? p_new_path : (p_new_path + "/");

if (new_path == old_path) {

return;

} else if (old_path == "res://") {

EditorNode::get_singleton()->add_io_error(TTR("Cannot move/rename resources root."));

return;

} else if (!p_item.is_file && new_path.begins_with(old_path)) {

//This check doesn't erroneously catch renaming to a longer name as folder paths always end with "/"

EditorNode::get_singleton()->add_io_error(TTR("Cannot move a folder into itself.") + "\n" + old_path + "\n");

return;

}

//Build a list of files which will have new paths as a result of this operation

Vector<String> file_changed_paths;

Vector<String> folder_changed_paths;

if (p_item.is_file) {

file_changed_paths.push_back(old_path);

} else {

folder_changed_paths.push_back(old_path);

_get_all_items_in_dir(EditorFileSystem::get_singleton()->get_filesystem_path(old_path), file_changed_paths, folder_changed_paths);

}

DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

print_line("Moving " + old_path + " -> " + new_path);

Error err = da->rename(old_path, new_path);

if (err == OK) {

//Move/Rename any corresponding import settings too

if (p_item.is_file && FileAccess::exists(old_path + ".import")) {

err = da->rename(old_path + ".import", new_path + ".import");

if (err != OK) {

EditorNode::get_singleton()->add_io_error(TTR("Error moving:") + "\n" + old_path + ".import\n");

}

}

// update scene if it is open

for (int i = 0; i < file_changed_paths.size(); ++i) {

String new_item_path = p_item.is_file ? new_path : file_changed_paths[i].replace_first(old_path, new_path);

if (ResourceLoader::get_resource_type(new_item_path) == "PackedScene" && editor->is_scene_open(file_changed_paths[i])) {

EditorData *ed = &editor->get_editor_data();

for (int j = 0; j < ed->get_edited_scene_count(); j++) {

if (ed->get_scene_path(j) == file_changed_paths[i]) {

ed->get_edited_scene_root(j)->set_filename(new_item_path);

break;

}

}

}

}

//Only treat as a changed dependency if it was successfully moved

for (int i = 0; i < file_changed_paths.size(); ++i) {

p_file_renames[file_changed_paths[i]] = file_changed_paths[i].replace_first(old_path, new_path);

print_line(" Remap: " + file_changed_paths[i] + " -> " + p_file_renames[file_changed_paths[i]]);

}

for (int i = 0; i < folder_changed_paths.size(); ++i) {

p_folder_renames[folder_changed_paths[i]] = folder_changed_paths[i].replace_first(old_path, new_path);

}

} else {

EditorNode::get_singleton()->add_io_error(TTR("Error moving:") + "\n" + old_path + "\n");

}

memdelete(da);

//Ensure folder paths end with "/"

String old_path = (p_item.is_file || p_item.path.ends_with("/")) ? p_item.path : (p_item.path + "/");

String new_path = (p_item.is_file || p_new_path.ends_with("/")) ? p_new_path : (p_new_path + "/");

if (new_path == old_path) {

return;

} else if (old_path == "res://") {

EditorNode::get_singleton()->add_io_error(TTR("Cannot move/rename resources root."));

return;

} else if (!p_item.is_file && new_path.begins_with(old_path)) {

//This check doesn't erroneously catch renaming to a longer name as folder paths always end with "/"

EditorNode::get_singleton()->add_io_error(TTR("Cannot move a folder into itself.") + "\n" + old_path + "\n");

return;

}

DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

print_line("Duplicating " + old_path + " -> " + new_path);

Error err = p_item.is_file ? da->copy(old_path, new_path) : da->copy_dir(old_path, new_path);

if (err == OK) {

//Move/Rename any corresponding import settings too

if (p_item.is_file && FileAccess::exists(old_path + ".import")) {

err = da->copy(old_path + ".import", new_path + ".import");

if (err != OK) {

EditorNode::get_singleton()->add_io_error(TTR("Error duplicating:") + "\n" + old_path + ".import\n");

}

}

} else {

EditorNode::get_singleton()->add_io_error(TTR("Error duplicating:") + "\n" + old_path + "\n");

}

memdelete(da);

//Rename all resources loaded, be it subresources or actual resources

List<Ref<Resource> > cached;

ResourceCache::get_cached_resources(&cached);

for (List<Ref<Resource> >::Element *E = cached.front(); E; E = E->next()) {

Ref<Resource> r = E->get();

String base_path = r->get_path();

String extra_path;

int sep_pos = r->get_path().find("::");

if (sep_pos >= 0) {

extra_path = base_path.substr(sep_pos, base_path.length());

base_path = base_path.substr(0, sep_pos);

}

if (p_renames.has(base_path)) {

base_path = p_renames[base_path];

}

r->set_path(base_path + extra_path);

}

for (int i = 0; i < EditorNode::get_editor_data().get_edited_scene_count(); i++) {

String path;

if (i == EditorNode::get_editor_data().get_edited_scene()) {

if (!get_tree()->get_edited_scene_root())

continue;

path = get_tree()->get_edited_scene_root()->get_filename();

} else {

path = EditorNode::get_editor_data().get_scene_path(i);

}

if (p_renames.has(path)) {

path = p_renames[path];

}

if (i == EditorNode::get_editor_data().get_edited_scene()) {

get_tree()->get_edited_scene_root()->set_filename(path);

} else {

EditorNode::get_editor_data().set_scene_path(i, path);

}

}

//The following code assumes that the following holds:

// 1) EditorFileSystem contains the old paths/folder structure from before the rename/move.

// 2) ResourceLoader can use the new paths without needing to call rescan.

Vector<String> remaps;

_find_remaps(EditorFileSystem::get_singleton()->get_filesystem(), p_renames, remaps);

for (int i = 0; i < remaps.size(); ++i) {

//Because we haven't called a rescan yet the found remap might still be an old path itself.

String file = p_renames.has(remaps[i]) ? p_renames[remaps[i]] : remaps[i];

print_line("Remapping dependencies for: " + file);

Error err = ResourceLoader::rename_dependencies(file, p_renames);

if (err == OK) {

if (ResourceLoader::get_resource_type(file) == "PackedScene")

editor->reload_scene(file);

} else {

EditorNode::get_singleton()->add_io_error(TTR("Unable to update dependencies:") + "\n" + remaps[i] + "\n");

}

}

Vector<String> favorite_dirs = EditorSettings::get_singleton()->get_favorite_dirs();

Vector<String> new_favorite_dirs;

for (int i = 0; i < favorite_dirs.size(); i++) {

String old_path = favorite_dirs[i] + "/";

if (p_renames.has(old_path)) {

String new_path = p_renames[old_path];

new_favorite_dirs.push_back(new_path.substr(0, new_path.length() - 1));

} else {

new_favorite_dirs.push_back(favorite_dirs[i]);

}

}

EditorSettings::get_singleton()->set_favorite_dirs(new_favorite_dirs);

String dir_name = make_dir_dialog_text->get_text().strip_edges();

if (dir_name.length() == 0) {

EditorNode::get_singleton()->show_warning(TTR("No name provided"));

return;

} else if (dir_name.find("/") != -1 || dir_name.find("\\") != -1 || dir_name.find(":") != -1 || dir_name.ends_with(".")) {

EditorNode::get_singleton()->show_warning(TTR("Provided name contains invalid characters"));

return;

}

print_line("Making folder " + dir_name + " in " + path);

DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);

Error err = da->change_dir(path);

if (err == OK) {

err = da->make_dir(dir_name);

}

memdelete(da);

if (err == OK) {

print_line("call rescan!");

_rescan();

} else {

EditorNode::get_singleton()->show_warning(TTR("Could not create folder."));

}