initial commit

1 files changed, 3516 insertions, 0 deletions

diff --git a/source/imgui/ImGuiFileDialog.cpp b/source/imgui/ImGuiFileDialog.cpp
new file mode 100644
index 0000000..fab78e8
--- /dev/null
+++ b/source/imgui/ImGuiFileDialog.cpp
@@ -0,0 +1,3516 @@
+// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
+// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+/*
+MIT License
+
+Copyright (c) 2019-2020 Stephane Cuillerdier (aka aiekick)
+
+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 "ImGuiFileDialog.h"
+
+#ifdef __cplusplus
+
+#include "imgui.h"
+
+#include <float.h>
+#include <string.h> // stricmp / strcasecmp
+#include <sstream>
+#include <iomanip>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <errno.h>
+#if defined (__EMSCRIPTEN__) // EMSCRIPTEN
+#include <emscripten.h>
+#endif // EMSCRIPTEN
+#if defined(__WIN32__) || defined(_WIN32)
+#ifndef WIN32
+#define WIN32
+#endif // WIN32
+#define stat _stat
+#define stricmp _stricmp
+#include <cctype>
+#include "dirent/dirent.h" // directly open the dirent file attached to this lib
+#define PATH_SEP '\\'
+#ifndef PATH_MAX
+#define PATH_MAX 260
+#endif // PATH_MAX
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__) || defined (__EMSCRIPTEN__)
+#define UNIX
+#define stricmp strcasecmp
+#include <sys/types.h>
+#include <dirent.h>
+#define PATH_SEP '/'
+#endif // defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+
+#include "imgui.h"
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+#define IMGUI_DEFINE_MATH_OPERATORS
+#endif // IMGUI_DEFINE_MATH_OPERATORS
+#include "imgui_internal.h"
+
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+
+namespace IGFD
+{
+	// float comparisons
+#ifndef IS_FLOAT_DIFFERENT
+#define IS_FLOAT_DIFFERENT(a,b) (fabs((a) - (b)) > FLT_EPSILON)
+#endif // IS_FLOAT_DIFFERENT
+#ifndef IS_FLOAT_EQUAL
+#define IS_FLOAT_EQUAL(a,b) (fabs((a) - (b)) < FLT_EPSILON)
+#endif // IS_FLOAT_EQUAL
+
+// width of filter combobox
+#ifndef FILTER_COMBO_WIDTH
+#define FILTER_COMBO_WIDTH 150.0f
+#endif // FILTER_COMBO_WIDTH
+
+// for lets you define your button widget
+// if you have like me a special bi-color button
+#ifndef IMGUI_PATH_BUTTON
+#define IMGUI_PATH_BUTTON ImGui::Button
+#endif // IMGUI_PATH_BUTTON
+#ifndef IMGUI_BUTTON
+#define IMGUI_BUTTON ImGui::Button
+#endif // IMGUI_BUTTON
+
+// locales
+#ifndef createDirButtonString
+#define createDirButtonString "+"
+#endif // createDirButtonString
+#ifndef okButtonString
+#define okButtonString "OK"
+#endif // okButtonString
+#ifndef cancelButtonString
+#define cancelButtonString "Cancel"
+#endif // cancelButtonString
+#ifndef resetButtonString
+#define resetButtonString "R"
+#endif // resetButtonString
+#ifndef drivesButtonString
+#define drivesButtonString "Drives"
+#endif // drivesButtonString
+#ifndef searchString
+#define searchString "Search :"
+#endif // searchString
+#ifndef dirEntryString
+#define dirEntryString "[Dir]"
+#endif // dirEntryString
+#ifndef linkEntryString
+#define linkEntryString "[Link]"
+#endif // linkEntryString
+#ifndef fileEntryString
+#define fileEntryString "[File]"
+#endif // fileEntryString
+#ifndef fileNameString
+#define fileNameString "File Name :"
+#endif // fileNameString
+#ifndef dirNameString
+#define dirNameString "Directory Path :"
+#endif // dirNameString
+#ifndef buttonResetSearchString
+#define buttonResetSearchString "Reset search"
+#endif // buttonResetSearchString
+#ifndef buttonDriveString
+#define buttonDriveString "Drives"
+#endif // buttonDriveString
+#ifndef buttonResetPathString
+#define buttonResetPathString "Reset to current directory"
+#endif // buttonResetPathString
+#ifndef buttonCreateDirString
+#define buttonCreateDirString "Create Directory"
+#endif // buttonCreateDirString
+#ifndef tableHeaderAscendingIcon
+#define tableHeaderAscendingIcon "A|"
+#endif // tableHeaderAscendingIcon
+#ifndef tableHeaderDescendingIcon
+#define tableHeaderDescendingIcon "D|"
+#endif // tableHeaderDescendingIcon
+#ifndef tableHeaderFileNameString
+#define tableHeaderFileNameString "File name"
+#endif // tableHeaderFileNameString
+#ifndef tableHeaderFileTypeString
+#define tableHeaderFileTypeString "Type"
+#endif // tableHeaderFileTypeString
+#ifndef tableHeaderFileSizeString
+#define tableHeaderFileSizeString "Size"
+#endif // tableHeaderFileSizeString
+#ifndef tableHeaderFileDateString
+#define tableHeaderFileDateString "Date"
+#endif // tableHeaderFileDateString
+#ifndef OverWriteDialogTitleString
+#define OverWriteDialogTitleString "The file Already Exist !"
+#endif // OverWriteDialogTitleString
+#ifndef OverWriteDialogMessageString
+#define OverWriteDialogMessageString "Would you like to OverWrite it ?"
+#endif // OverWriteDialogMessageString
+#ifndef OverWriteDialogConfirmButtonString
+#define OverWriteDialogConfirmButtonString "Confirm"
+#endif // OverWriteDialogConfirmButtonString
+#ifndef OverWriteDialogCancelButtonString
+#define OverWriteDialogCancelButtonString "Cancel"
+#endif // OverWriteDialogCancelButtonString
+// see strftime functionin <ctime> for customize
+#ifndef DateTimeFormat
+#define DateTimeFormat "%Y/%m/%d %H:%M"
+#endif // DateTimeFormat
+
+#ifdef USE_BOOKMARK
+
+#ifndef defaultBookmarkPaneWith
+#define defaultBookmarkPaneWith 150.0f
+#endif // defaultBookmarkPaneWith
+#ifndef bookmarksButtonString
+#define bookmarksButtonString "Bookmark"
+#endif // bookmarksButtonString
+#ifndef bookmarksButtonHelpString
+#define bookmarksButtonHelpString "Bookmark"
+#endif // bookmarksButtonHelpString
+#ifndef addBookmarkButtonString
+#define addBookmarkButtonString "+"
+#endif // addBookmarkButtonString
+#ifndef removeBookmarkButtonString
+#define removeBookmarkButtonString "-"
+#endif // removeBookmarkButtonString
+#ifndef IMGUI_TOGGLE_BUTTON
+	inline bool ToggleButton(const char* vLabel, bool* vToggled)
+	{
+		bool pressed = false;
+
+		if (vToggled && *vToggled)
+		{
+			ImVec4 bua = ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive);
+			//ImVec4 buh = ImGui::GetStyleColorVec4(ImGuiCol_ButtonHovered);
+			//ImVec4 bu = ImGui::GetStyleColorVec4(ImGuiCol_Button);
+			ImVec4 te = ImGui::GetStyleColorVec4(ImGuiCol_Text);
+			ImGui::PushStyleColor(ImGuiCol_Button, te);
+			ImGui::PushStyleColor(ImGuiCol_ButtonActive, te);
+			ImGui::PushStyleColor(ImGuiCol_ButtonHovered, te);
+			ImGui::PushStyleColor(ImGuiCol_Text, bua);
+		}
+
+		pressed = IMGUI_BUTTON(vLabel);
+
+		if (vToggled && *vToggled)
+		{
+			ImGui::PopStyleColor(4); //-V112
+		}
+
+		if (vToggled && pressed)
+			*vToggled = !*vToggled;
+
+		return pressed;
+	}
+#define IMGUI_TOGGLE_BUTTON ToggleButton
+#endif // IMGUI_TOGGLE_BUTTON
+#endif // USE_BOOKMARK
+
+	// https://github.com/ocornut/imgui/issues/1720
+	bool Splitter(bool split_vertically, float thickness, float* size1, float* size2, float min_size1, float min_size2, float splitter_long_axis_size = -1.0f)
+	{
+		using namespace ImGui;
+		ImGuiContext& g = *GImGui;
+		ImGuiWindow* window = g.CurrentWindow;
+		ImGuiID id = window->GetID("##Splitter");
+		ImRect bb;
+		bb.Min = window->DC.CursorPos + (split_vertically ? ImVec2(*size1, 0.0f) : ImVec2(0.0f, *size1));
+		bb.Max = bb.Min + CalcItemSize(split_vertically ? ImVec2(thickness, splitter_long_axis_size) : ImVec2(splitter_long_axis_size, thickness), 0.0f, 0.0f);
+		return SplitterBehavior(bb, id, split_vertically ? ImGuiAxis_X : ImGuiAxis_Y, size1, size2, min_size1, min_size2, 1.0f);
+	}
+
+	static std::string s_fs_root = std::string(1u, PATH_SEP);
+
+	inline int alphaSort(const struct dirent** a, const struct dirent** b)
+	{
+		return strcoll((*a)->d_name, (*b)->d_name);
+	}
+
+#ifdef WIN32
+	inline bool wreplaceString(std::wstring& str, const std::wstring& oldStr, const std::wstring& newStr)
+	{
+		bool found = false;
+		size_t pos = 0;
+		while ((pos = str.find(oldStr, pos)) != std::wstring::npos)
+		{
+			found = true;
+			str.replace(pos, oldStr.length(), newStr);
+			pos += newStr.length();
+		}
+		return found;
+	}
+
+	inline std::vector<std::wstring> wsplitStringToVector(const std::wstring& text, char delimiter, bool pushEmpty)
+	{
+		std::vector<std::wstring> arr;
+		if (!text.empty())
+		{
+			std::wstring::size_type start = 0;
+			std::wstring::size_type end = text.find(delimiter, start);
+			while (end != std::wstring::npos)
+			{
+				std::wstring token = text.substr(start, end - start);
+				if (!token.empty() || (token.empty() && pushEmpty)) //-V728
+					arr.push_back(token);
+				start = end + 1;
+				end = text.find(delimiter, start);
+			}
+			std::wstring token = text.substr(start);
+			if (!token.empty() || (token.empty() && pushEmpty)) //-V728
+				arr.push_back(token);
+		}
+		return arr;
+	}
+#endif
+
+	inline bool replaceString(std::string& str, const std::string& oldStr, const std::string& newStr)
+	{
+		bool found = false;
+		size_t pos = 0;
+		while ((pos = str.find(oldStr, pos)) != std::string::npos)
+		{
+			found = true;
+			str.replace(pos, oldStr.length(), newStr);
+			pos += newStr.length();
+		}
+		return found;
+	}
+
+	inline std::vector<std::string> splitStringToVector(const std::string& text, char delimiter, bool pushEmpty)
+	{
+		std::vector<std::string> arr;
+		if (!text.empty())
+		{
+			std::string::size_type start = 0;
+			std::string::size_type end = text.find(delimiter, start);
+			while (end != std::string::npos)
+			{
+				std::string token = text.substr(start, end - start);
+				if (!token.empty() || (token.empty() && pushEmpty)) //-V728
+					arr.push_back(token);
+				start = end + 1;
+				end = text.find(delimiter, start);
+			}
+			std::string token = text.substr(start);
+			if (!token.empty() || (token.empty() && pushEmpty)) //-V728
+				arr.push_back(token);
+		}
+		return arr;
+	}
+
+	inline std::vector<std::string> GetDrivesList()
+	{
+		std::vector<std::string> res;
+
+#ifdef WIN32
+		const DWORD mydrives = 2048;
+		char lpBuffer[2048];
+#define mini(a,b) (((a) < (b)) ? (a) : (b))
+		const DWORD countChars = mini(GetLogicalDriveStringsA(mydrives, lpBuffer), 2047);
+#undef mini
+		if (countChars > 0)
+		{
+			std::string var = std::string(lpBuffer, (size_t)countChars);
+			replaceString(var, "\\", "");
+			res = splitStringToVector(var, '\0', false);
+		}
+#endif // WIN32
+
+		return res;
+	}
+
+	inline bool IsDirectoryExist(const std::string& name)
+	{
+		bool bExists = false;
+
+		if (!name.empty())
+		{
+			DIR* pDir = nullptr;
+			pDir = opendir(name.c_str());
+			if (pDir != nullptr)
+			{
+				bExists = true;
+				(void)closedir(pDir);
+			}
+		}
+
+		return bExists;    // this is not a directory!
+	}
+
+#ifdef WIN32
+	inline std::wstring wGetString(const char* str)
+	{
+		std::wstring ret;
+		size_t sz;
+		if (!dirent_mbstowcs_s(&sz, nullptr, 0, str, 0))
+		{
+			ret.resize(sz);
+			dirent_mbstowcs_s(nullptr, (wchar_t*)ret.data(), sz, str, sz - 1);
+		}
+		return ret;
+	}
+#endif
+
+	inline bool CreateDirectoryIfNotExist(const std::string& name)
+	{
+		bool res = false;
+
+		if (!name.empty())
+		{
+			if (!IsDirectoryExist(name))
+			{
+#ifdef WIN32
+				std::wstring wname = wGetString(name.c_str());
+				if (CreateDirectoryW(wname.c_str(), nullptr))
+				{
+					res = true;
+				}
+#elif defined(__EMSCRIPTEN__)
+				std::string str = std::string("FS.mkdir('") + name + "');";
+				emscripten_run_script(str.c_str());
+				res = true;
+#elif defined(UNIX)
+				char buffer[PATH_MAX] = {};
+				snprintf(buffer, PATH_MAX, "mkdir -p %s", name.c_str());
+				const int dir_err = std::system(buffer);
+				if (dir_err != -1)
+				{
+					res = true;
+				}
+#endif // defined(UNIX)
+				if (!res) {
+					std::cout << "Error creating directory " << name << std::endl;
+				}
+		}
+	}
+
+		return res;
+	}
+
+	struct PathStruct
+	{
+		std::string path;
+		std::string name;
+		std::string ext;
+
+		bool isOk;
+
+		PathStruct()
+		{
+			isOk = false;
+		}
+	};
+
+	inline PathStruct ParsePathFileName(const std::string& vPathFileName)
+	{
+		PathStruct res;
+
+		if (!vPathFileName.empty())
+		{
+			std::string pfn = vPathFileName;
+			std::string separator(1u, PATH_SEP);
+			replaceString(pfn, "\\", separator);
+			replaceString(pfn, "/", separator);
+
+			size_t lastSlash = pfn.find_last_of(separator);
+			if (lastSlash != std::string::npos)
+			{
+				res.name = pfn.substr(lastSlash + 1);
+				res.path = pfn.substr(0, lastSlash);
+				res.isOk = true;
+			}
+
+			size_t lastPoint = pfn.find_last_of('.');
+			if (lastPoint != std::string::npos)
+			{
+				if (!res.isOk)
+				{
+					res.name = pfn;
+					res.isOk = true;
+				}
+				res.ext = pfn.substr(lastPoint + 1);
+				replaceString(res.name, "." + res.ext, "");
+			}
+		}
+
+		return res;
+	}
+
+	inline void AppendToBuffer(char* vBuffer, size_t vBufferLen, const std::string& vStr)
+	{
+		std::string st = vStr;
+		size_t len = vBufferLen - 1u;
+		size_t slen = strlen(vBuffer);
+
+		if (!st.empty() && st != "\n")
+		{
+			replaceString(st, "\n", "");
+			replaceString(st, "\r", "");
+		}
+		vBuffer[slen] = '\0';
+		std::string str = std::string(vBuffer);
+		//if (!str.empty()) str += "\n";
+		str += vStr;
+		if (len > str.size()) len = str.size();
+#ifdef MSVC
+		strncpy_s(vBuffer, vBufferLen, str.c_str(), len);
+#else // MSVC
+		strncpy(vBuffer, str.c_str(), len);
+#endif // MSVC
+		vBuffer[len] = '\0';
+	}
+
+	inline void ResetBuffer(char* vBuffer)
+	{
+		vBuffer[0] = '\0';
+	}
+
+	inline void SetBuffer(char* vBuffer, size_t vBufferLen, const std::string& vStr)
+	{
+		ResetBuffer(vBuffer);
+		AppendToBuffer(vBuffer, vBufferLen, vStr);
+	}
+
+	IGFD::FileDialog::FileDialog()
+	{
+		m_AnyWindowsHovered = false;
+		m_IsOk = false;
+		m_ShowDialog = false;
+		m_ShowDrives = false;
+		m_CreateDirectoryMode = false;
+		dlg_optionsPane = nullptr;
+		dlg_optionsPaneWidth = 250;
+		dlg_filters = "";
+		dlg_userDatas = 0;
+#ifdef USE_BOOKMARK
+		m_BookmarkPaneShown = false;
+		m_BookmarkWidth = defaultBookmarkPaneWith;
+#endif // USE_BOOKMARK
+	}
+
+	IGFD::FileDialog::~FileDialog() = default;
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	///// CUSTOM SELECTABLE (Flashing Support) ///////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	
+#ifdef USE_EXPLORATION_BY_KEYS
+	bool IGFD::FileDialog::FlashableSelectable(const char* label, bool selected,
+		ImGuiSelectableFlags flags, bool vFlashing, const ImVec2& size_arg)
+	{
+		using namespace ImGui;
+
+		ImGuiWindow* window = GetCurrentWindow();
+		if (window->SkipItems)
+			return false;
+
+		ImGuiContext& g = *GImGui;
+		const ImGuiStyle& style = g.Style;
+
+		// Submit label or explicit size to ItemSize(), whereas ItemAdd() will submit a larger/spanning rectangle.
+		ImGuiID id = window->GetID(label);
+		ImVec2 label_size = CalcTextSize(label, NULL, true);
+		ImVec2 size(size_arg.x != 0.0f ? size_arg.x : label_size.x, size_arg.y != 0.0f ? size_arg.y : label_size.y);
+		ImVec2 pos = window->DC.CursorPos;
+		pos.y += window->DC.CurrLineTextBaseOffset;
+		ItemSize(size, 0.0f);
+
+		// Fill horizontal space
+		// We don't support (size < 0.0f) in Selectable() because the ItemSpacing extension would make explicitly right-aligned sizes not visibly match other widgets.
+		const bool span_all_columns = (flags & ImGuiSelectableFlags_SpanAllColumns) != 0;
+		const float min_x = span_all_columns ? window->ParentWorkRect.Min.x : pos.x;
+		const float max_x = span_all_columns ? window->ParentWorkRect.Max.x : window->WorkRect.Max.x;
+		if (size_arg.x == 0.0f || (flags & ImGuiSelectableFlags_SpanAvailWidth))
+			size.x = ImMax(label_size.x, max_x - min_x);
+
+		// Text stays at the submission position, but bounding box may be extended on both sides
+		const ImVec2 text_min = pos;
+		const ImVec2 text_max(min_x + size.x, pos.y + size.y);
+
+		// Selectables are meant to be tightly packed together with no click-gap, so we extend their box to cover spacing between selectable.
+		ImRect bb(min_x, pos.y, text_max.x, text_max.y);
+		if ((flags & ImGuiSelectableFlags_NoPadWithHalfSpacing) == 0)
+		{
+			const float spacing_x = span_all_columns ? 0.0f : style.ItemSpacing.x;
+			const float spacing_y = style.ItemSpacing.y;
+			const float spacing_L = IM_FLOOR(spacing_x * 0.50f);
+			const float spacing_U = IM_FLOOR(spacing_y * 0.50f);
+			bb.Min.x -= spacing_L;
+			bb.Min.y -= spacing_U;
+			bb.Max.x += (spacing_x - spacing_L);
+			bb.Max.y += (spacing_y - spacing_U);
+		}
+		//if (g.IO.KeyCtrl) { GetForegroundDrawList()->AddRect(bb.Min, bb.Max, IM_COL32(0, 255, 0, 255)); }
+
+		// Modify ClipRect for the ItemAdd(), faster than doing a PushColumnsBackground/PushTableBackground for every Selectable..
+		const float backup_clip_rect_min_x = window->ClipRect.Min.x;
+		const float backup_clip_rect_max_x = window->ClipRect.Max.x;
+		if (span_all_columns)
+		{
+			window->ClipRect.Min.x = window->ParentWorkRect.Min.x;
+			window->ClipRect.Max.x = window->ParentWorkRect.Max.x;
+		}
+
+		bool item_add;
+		const bool disabled_item = (flags & ImGuiSelectableFlags_Disabled) != 0;
+		if (disabled_item)
+		{
+			ImGuiItemFlags backup_item_flags = g.CurrentItemFlags;
+			g.CurrentItemFlags |= ImGuiItemFlags_Disabled;
+			item_add = ItemAdd(bb, id);
+			g.CurrentItemFlags = backup_item_flags;
+		}
+		else
+		{
+			item_add = ItemAdd(bb, id);
+		}
+
+		if (span_all_columns)
+		{
+			window->ClipRect.Min.x = backup_clip_rect_min_x;
+			window->ClipRect.Max.x = backup_clip_rect_max_x;
+		}
+
+		if (!item_add)
+			return false;
+
+		const bool disabled_global = (g.CurrentItemFlags & ImGuiItemFlags_Disabled) != 0;
+		if (disabled_item && !disabled_global)
+			PushDisabled(true);
+
+		// FIXME: We can standardize the behavior of those two, we could also keep the fast path of override ClipRect + full push on render only,
+		// which would be advantageous since most selectable are not selected.
+		if (span_all_columns && window->DC.CurrentColumns)
+			PushColumnsBackground();
+		else if (span_all_columns && g.CurrentTable)
+			TablePushBackgroundChannel();
+
+		// We use NoHoldingActiveID on menus so user can click and _hold_ on a menu then drag to browse child entries
+		ImGuiButtonFlags button_flags = 0;
+		if (flags & ImGuiSelectableFlags_NoHoldingActiveID) { button_flags |= ImGuiButtonFlags_NoHoldingActiveId; }
+		if (flags & ImGuiSelectableFlags_SelectOnClick) { button_flags |= ImGuiButtonFlags_PressedOnClick; }
+		if (flags & ImGuiSelectableFlags_SelectOnRelease) { button_flags |= ImGuiButtonFlags_PressedOnRelease; }
+		if (flags & ImGuiSelectableFlags_AllowDoubleClick) { button_flags |= ImGuiButtonFlags_PressedOnClickRelease | ImGuiButtonFlags_PressedOnDoubleClick; }
+		if (flags & ImGuiSelectableFlags_AllowItemOverlap) { button_flags |= ImGuiButtonFlags_AllowItemOverlap; }
+
+		const bool was_selected = selected;
+		bool hovered, held;
+		bool pressed = ButtonBehavior(bb, id, &hovered, &held, button_flags);
+
+		// Auto-select when moved into
+		// - This will be more fully fleshed in the range-select branch
+		// - This is not exposed as it won't nicely work with some user side handling of shift/control
+		// - We cannot do 'if (g.NavJustMovedToId != id) { selected = false; pressed = was_selected; }' for two reasons
+		//   - (1) it would require focus scope to be set, need exposing PushFocusScope() or equivalent (e.g. BeginSelection() calling PushFocusScope())
+		//   - (2) usage will fail with clipped items
+		//   The multi-select API aim to fix those issues, e.g. may be replaced with a BeginSelection() API.
+		if ((flags & ImGuiSelectableFlags_SelectOnNav) && g.NavJustMovedToId != 0 && g.NavJustMovedToFocusScopeId == window->DC.NavFocusScopeIdCurrent)
+			if (g.NavJustMovedToId == id)
+				selected = pressed = true;
+
+		// Update NavId when clicking or when Hovering (this doesn't happen on most widgets), so navigation can be resumed with gamepad/keyboard
+		if (pressed || (hovered && (flags & ImGuiSelectableFlags_SetNavIdOnHover)))
+		{
+			if (!g.NavDisableMouseHover && g.NavWindow == window && g.NavLayer == window->DC.NavLayerCurrent)
+			{
+				SetNavID(id, window->DC.NavLayerCurrent, window->DC.NavFocusScopeIdCurrent, ImRect(bb.Min - window->Pos, bb.Max - window->Pos));
+				g.NavDisableHighlight = true;
+			}
+		}
+		if (pressed)
+			MarkItemEdited(id);
+
+		if (flags & ImGuiSelectableFlags_AllowItemOverlap)
+			SetItemAllowOverlap();
+
+		// In this branch, Selectable() cannot toggle the selection so this will never trigger.
+		if (selected != was_selected) //-V547
+			window->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_ToggledSelection;
+
+		// Render
+		if (held && (flags & ImGuiSelectableFlags_DrawHoveredWhenHeld) || vFlashing)
+			hovered = true;
+		if (hovered || selected)
+		{
+			const ImU32 col = GetColorU32((held && hovered) ? ImGuiCol_HeaderActive : hovered ? ImGuiCol_HeaderHovered : ImGuiCol_Header);
+			RenderFrame(bb.Min, bb.Max, col, false, 0.0f);
+		}
+		RenderNavHighlight(bb, id, ImGuiNavHighlightFlags_TypeThin | ImGuiNavHighlightFlags_NoRounding);
+
+		if (span_all_columns && window->DC.CurrentColumns)
+			PopColumnsBackground();
+		else if (span_all_columns && g.CurrentTable)
+			TablePopBackgroundChannel();
+
+		RenderTextClipped(text_min, text_max, label, NULL, &label_size, style.SelectableTextAlign, &bb);
+
+		// Automatically close popups
+		if (pressed && (window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiSelectableFlags_DontClosePopups) && !(g.CurrentItemFlags & ImGuiItemFlags_SelectableDontClosePopup))
+			CloseCurrentPopup();
+
+		if (disabled_item && !disabled_global)
+			PopDisabled();
+
+		IMGUI_TEST_ENGINE_ITEM_INFO(id, label, window->DC.LastItemStatusFlags);
+		return pressed;
+	}
+#endif // USE_EXPLORATION_BY_KEYS
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	///// STANDARD DIALOG ////////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+
+	// path and fileName can be specified
+	void IGFD::FileDialog::OpenDialog(
+		const std::string& vKey,			
+		const std::string& vTitle,			
+		const char *vFilters,				
+		const std::string& vPath,			
+		const std::string& vFileName,
+		const int& vCountSelectionMax,		
+		UserDatas vUserDatas,				
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		dlg_key = vKey;
+		dlg_title = vTitle;
+		dlg_path = vPath;
+		dlg_userDatas = vUserDatas;
+		dlg_flags = vFlags;
+		dlg_optionsPane = nullptr;
+		dlg_optionsPaneWidth = 0.0f;
+		dlg_countSelectionMax = vCountSelectionMax;
+		dlg_modal = false;
+		dlg_defaultExt.clear();
+
+		ParseFilters(vFilters);
+		SetDefaultFileName(vFileName);
+		SetPath(m_CurrentPath);
+
+		m_ShowDialog = true;					// open dialog
+#ifdef USE_BOOKMARK
+		m_BookmarkPaneShown = false;
+#endif // USE_BOOKMARK
+	}
+
+	// path and filename are obtained from filePathName
+	void IGFD::FileDialog::OpenDialog(
+		const std::string& vKey,	
+		const std::string& vTitle,	
+		const char *vFilters,			
+		const std::string& vFilePathName,	
+		const int& vCountSelectionMax,		
+		UserDatas vUserDatas,					
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		dlg_key = vKey;
+		dlg_title = vTitle;
+		
+		auto ps = ParsePathFileName(vFilePathName);
+		if (ps.isOk)
+		{
+			dlg_path = ps.path;
+			SetDefaultFileName(ps.name + "." + ps.ext);
+			m_SelectedFileNames.clear();
+			m_SelectedFileNames.emplace(ps.name + "." + ps.ext);
+			dlg_defaultExt = "." + ps.ext;
+		}
+		else
+		{
+			dlg_path = ".";
+			SetDefaultFileName("");
+			dlg_defaultExt.clear();
+		}
+
+		dlg_optionsPane = nullptr;
+		dlg_optionsPaneWidth = 0.0f;
+		dlg_userDatas = vUserDatas;
+		dlg_flags = vFlags;
+		dlg_countSelectionMax = vCountSelectionMax; //-V101
+		dlg_modal = false;
+
+		ParseFilters(vFilters);
+		SetSelectedFilterWithExt(dlg_defaultExt);
+		SetPath(m_CurrentPath);
+
+		m_ShowDialog = true;
+#ifdef USE_BOOKMARK
+		m_BookmarkPaneShown = false;
+#endif // USE_BOOKMARK
+	}
+	
+	// with pane
+	// path and fileName can be specified
+	void IGFD::FileDialog::OpenDialog(
+		const std::string& vKey,
+		const std::string& vTitle,
+		const char* vFilters,
+		const std::string& vPath,
+		const std::string& vFileName,
+		const PaneFun& vSidePane,
+		const float& vSidePaneWidth,
+		const int& vCountSelectionMax,
+		UserDatas vUserDatas,
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		dlg_key = vKey;
+		dlg_title = vTitle;
+		dlg_path = vPath;
+		dlg_userDatas = vUserDatas;
+		dlg_flags = vFlags;
+		dlg_optionsPane = vSidePane;
+		dlg_optionsPaneWidth = vSidePaneWidth;
+		dlg_countSelectionMax = vCountSelectionMax;
+		dlg_modal = false;
+		dlg_defaultExt.clear();
+
+		ParseFilters(vFilters);
+		SetDefaultFileName(vFileName);
+		SetPath(m_CurrentPath);
+
+		m_ShowDialog = true;					// open dialog
+#ifdef USE_BOOKMARK
+		m_BookmarkPaneShown = false;
+#endif // USE_BOOKMARK
+	}
+
+	// with pane
+	// path and filename are obtained from filePathName
+	void IGFD::FileDialog::OpenDialog(
+		const std::string& vKey,
+		const std::string& vTitle,
+		const char* vFilters,
+		const std::string& vFilePathName,
+		const PaneFun& vSidePane,
+		const float& vSidePaneWidth,
+		const int& vCountSelectionMax,
+		UserDatas vUserDatas,
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		dlg_key = vKey;
+		dlg_title = vTitle;
+
+		auto ps = ParsePathFileName(vFilePathName);
+		if (ps.isOk)
+		{
+			dlg_path = ps.path;
+			SetDefaultFileName(ps.name + "." + ps.ext);
+			m_SelectedFileNames.clear();
+			m_SelectedFileNames.emplace(ps.name + "." + ps.ext);
+			dlg_defaultExt = "." + ps.ext;
+		}
+		else
+		{
+			dlg_path = ".";
+			SetDefaultFileName("");
+			dlg_defaultExt.clear();
+		}
+
+		dlg_optionsPane = vSidePane;
+		dlg_optionsPaneWidth = vSidePaneWidth;
+		dlg_userDatas = vUserDatas;
+		dlg_flags = vFlags;
+		dlg_countSelectionMax = vCountSelectionMax; //-V101
+		dlg_modal = false;
+
+		ParseFilters(vFilters);
+		SetSelectedFilterWithExt(dlg_defaultExt);
+		SetPath(m_CurrentPath);
+
+		m_ShowDialog = true;
+#ifdef USE_BOOKMARK
+		m_BookmarkPaneShown = false;
+#endif // USE_BOOKMARK
+	}
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	///// MODAL DIALOG ///////////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+
+	void IGFD::FileDialog::OpenModal(
+		const std::string& vKey, 
+		const std::string& vTitle, 
+		const char* vFilters,
+		const std::string& vPath, 
+		const std::string& vFileName,
+		const int& vCountSelectionMax, 
+		UserDatas vUserDatas, 
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		OpenDialog(
+			vKey, vTitle, vFilters,
+			vPath, vFileName,
+			vCountSelectionMax, vUserDatas, vFlags);
+
+		dlg_modal = true;
+	}
+
+	void IGFD::FileDialog::OpenModal(
+		const std::string& vKey, 
+		const std::string& vTitle, 
+		const char *vFilters,
+		const std::string& vFilePathName,
+		const int& vCountSelectionMax, 
+		UserDatas vUserDatas, 
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		OpenDialog(
+			vKey, vTitle, vFilters,
+			vFilePathName,
+			vCountSelectionMax, vUserDatas, vFlags);
+
+		dlg_modal = true;
+	}
+
+	// with pane
+	// path and fileName can be specified
+	void IGFD::FileDialog::OpenModal(
+		const std::string& vKey,
+		const std::string& vTitle,
+		const char* vFilters,
+		const std::string& vPath,
+		const std::string& vFileName,
+		const PaneFun& vSidePane,
+		const float& vSidePaneWidth,
+		const int& vCountSelectionMax,
+		UserDatas vUserDatas,
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		OpenDialog(
+			vKey, vTitle, vFilters,
+			vPath, vFileName, 
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, vFlags);
+
+		dlg_modal = true;
+	}
+
+	// with pane
+	// path and filename are obtained from filePathName
+	void IGFD::FileDialog::OpenModal(
+		const std::string& vKey,
+		const std::string& vTitle,
+		const char* vFilters,
+		const std::string& vFilePathName,
+		const PaneFun& vSidePane,
+		const float& vSidePaneWidth,
+		const int& vCountSelectionMax,
+		UserDatas vUserDatas,
+		ImGuiFileDialogFlags vFlags)
+	{
+		if (m_ShowDialog) // if already opened, quit
+			return;
+
+		OpenDialog(
+			vKey, vTitle, vFilters,
+			vFilePathName,
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, vFlags);
+
+		dlg_modal = true;
+	}
+
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+	///// MAIN FUNCTION //////////////////////////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////////////////////////
+
+	bool IGFD::FileDialog::Display(const std::string& vKey, ImGuiWindowFlags vFlags, ImVec2 vMinSize, ImVec2 vMaxSize)
+	{
+		if (m_ShowDialog && dlg_key == vKey)
+		{
+			bool res = false;
+
+			// to be sure than only one dialog is displayed per frame
+			ImGuiContext& g = *GImGui;
+			if (g.FrameCount == m_LastImGuiFrameCount) // one instance was displayed this frame before for this key +> quit
+				return res;
+			m_LastImGuiFrameCount = g.FrameCount; // mark this instance as used this frame
+
+			std::string name = dlg_title + "##" + dlg_key;
+			if (m_Name != name)
+			{
+				m_FileList.clear();
+				m_CurrentPath_Decomposition.clear();
+			}
+
+			m_IsOk = false;			// reset dialog result
+			m_WantToQuit = false;	// reset var used for start the dialog quit process from anywhere
+
+			ResetEvents();
+
+			ImGui::SetNextWindowSizeConstraints(vMinSize, vMaxSize);
+
+			bool beg = false;
+			if (dlg_modal &&
+				!m_OkResultToConfirm) // disable modal because the confirm dialog for overwrite is a new modal
+			{
+				ImGui::OpenPopup(name.c_str());
+				beg = ImGui::BeginPopupModal(name.c_str(), (bool*)nullptr,
+					vFlags | ImGuiWindowFlags_NoScrollbar);
+			}
+			else
+			{
+				beg = ImGui::Begin(name.c_str(), (bool*)nullptr, vFlags | ImGuiWindowFlags_NoScrollbar);
+			}
+			if (beg)
+			{
+				m_Name = name; //-V820
+				m_AnyWindowsHovered |= ImGui::IsWindowHovered();
+
+				if (dlg_path.empty()) dlg_path = "."; // defaut path is '.'
+				if (m_SelectedFilter.empty() && // no filter selected
+					!m_Filters.empty()) // filter exist
+					m_SelectedFilter = *m_Filters.begin(); // we take the first filter
+
+				// init list of files
+				if (m_FileList.empty() && !m_ShowDrives)
+				{
+					replaceString(dlg_defaultFileName, dlg_path, ""); // local path
+					if (!dlg_defaultFileName.empty())
+					{
+						SetDefaultFileName(dlg_defaultFileName);
+						SetSelectedFilterWithExt(dlg_defaultExt);
+					}
+					else if (dlg_filters.empty()) // directory mode
+						SetDefaultFileName(".");
+					ScanDir(dlg_path);
+				}
+
+				// draw dialog parts
+				DrawHeader(); // bookmark, directory, path
+				DrawContent(); // bookmark, files view, side pane 
+				res = DrawFooter(); // file field, filter combobox, ok/cancel buttons
+
+				// for display in dialog center, the confirm to overwrite dlg
+				m_DialogCenterPos = ImGui::GetCurrentWindowRead()->ContentRegionRect.GetCenter();
+
+				// when the confirm to overwrite dialog will appear we need to 
+				// disable the modal mode of the main file dialog
+				// see m_OkResultToConfirm under
+				if (dlg_modal &&
+					!m_OkResultToConfirm)
+					ImGui::EndPopup();
+			}
+
+			// same things here regarding m_OkResultToConfirm
+			if (!dlg_modal || m_OkResultToConfirm)
+				ImGui::End();
+
+			// confirm the result and show the confirm to overwrite dialog if needed
+			return Confirm_Or_OpenOverWriteFileDialog_IfNeeded(res, vFlags);
+		}
+
+		return false;
+	}
+
+	void IGFD::FileDialog::ResetEvents()
+	{
+		// reset events
+		m_DrivesClicked = false;
+		m_PathClicked = false;
+		m_CanWeContinue = true;
+	}
+
+	void IGFD::FileDialog::DrawHeader()
+	{
+#ifdef USE_BOOKMARK
+		DrawBookMark();
+		ImGui::SameLine();
+#endif // USE_BOOKMARK
+		DrawDirectoryCreation();
+		DrawPathComposer();
+		DrawSearchBar();
+	}
+
+	void IGFD::FileDialog::DrawContent()
+	{
+		ImVec2 size = ImGui::GetContentRegionAvail() - ImVec2(0.0f, m_FooterHeight);
+
+#ifdef USE_BOOKMARK
+		if (m_BookmarkPaneShown)
+		{
+			//size.x -= m_BookmarkWidth;
+			ImGui::PushID("##splitterbookmark");
+			float otherWidth = size.x - m_BookmarkWidth;
+			Splitter(true, 4.0f, &m_BookmarkWidth, &otherWidth, 10.0f, 10.0f + dlg_optionsPaneWidth, size.y);
+			ImGui::PopID();
+			size.x -= otherWidth;
+			DrawBookmarkPane(size);
+			ImGui::SameLine();
+		}
+#endif // USE_BOOKMARK
+
+		size.x = ImGui::GetContentRegionAvail().x - dlg_optionsPaneWidth;
+
+		if (dlg_optionsPane)
+		{
+			ImGui::PushID("##splittersidepane");
+			Splitter(true, 4.0f, &size.x, &dlg_optionsPaneWidth, 10.0f, 10.0f, size.y);
+			ImGui::PopID();
+		}
+
+		DrawFileListView(size);
+
+		if (dlg_optionsPane)
+		{
+			DrawSidePane(size.y);
+		}
+	}
+
+	bool IGFD::FileDialog::DrawFooter()
+	{
+		float posY = ImGui::GetCursorPos().y; // height of last bar calc
+
+		if (!dlg_filters.empty())
+			ImGui::Text(fileNameString);
+		else // directory chooser
+			ImGui::Text(dirNameString);
+
+		ImGui::SameLine();
+
+		// Input file fields
+		float width = ImGui::GetContentRegionAvail().x;
+		if (!dlg_filters.empty())
+			width -= FILTER_COMBO_WIDTH;
+		ImGui::PushItemWidth(width);
+		ImGui::InputText("##FileName", FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER);
+		ImGui::PopItemWidth();
+
+		// combobox of filters
+		if (!dlg_filters.empty())
+		{
+			ImGui::SameLine();
+
+			bool needToApllyNewFilter = false;
+
+			ImGui::PushItemWidth(FILTER_COMBO_WIDTH);
+			if (ImGui::BeginCombo("##Filters", m_SelectedFilter.filter.c_str(), ImGuiComboFlags_None))
+			{
+				intptr_t i = 0;
+				for (auto filter : m_Filters)
+				{
+					const bool item_selected = (filter.filter == m_SelectedFilter.filter);
+					ImGui::PushID((void*)(intptr_t)i++);
+					if (ImGui::Selectable(filter.filter.c_str(), item_selected))
+					{
+						m_SelectedFilter = filter;
+						needToApllyNewFilter = true;
+					}
+					ImGui::PopID();
+				}
+
+				ImGui::EndCombo();
+			}
+			ImGui::PopItemWidth();
+
+			if (needToApllyNewFilter)
+			{
+				SetPath(m_CurrentPath);
+			}
+		}
+
+		bool res = false;
+
+		// OK Button
+		if (m_CanWeContinue && strlen(FileNameBuffer))
+		{
+			if (IMGUI_BUTTON(okButtonString))
+			{
+				m_IsOk = true;
+				res = true;
+			}
+
+			ImGui::SameLine();
+		}
+
+		// Cancel Button
+		if (IMGUI_BUTTON(cancelButtonString))
+		{
+			m_IsOk = false;
+			res = true;
+		}
+
+		m_FooterHeight = ImGui::GetCursorPosY() - posY;
+
+		if (m_WantToQuit && m_IsOk)
+		{
+			res = true;
+		}
+
+		return res;
+	}
+#ifdef USE_BOOKMARK
+	void IGFD::FileDialog::DrawBookMark()
+	{
+		IMGUI_TOGGLE_BUTTON(bookmarksButtonString, &m_BookmarkPaneShown);
+
+		if (ImGui::IsItemHovered())
+			ImGui::SetTooltip(bookmarksButtonHelpString);
+	}
+#endif // USE_BOOKMARK
+
+	void IGFD::FileDialog::DrawDirectoryCreation()
+	{
+		if (dlg_flags & ImGuiFileDialogFlags_DisableCreateDirectoryButton)
+			return;
+
+		if (IMGUI_BUTTON(createDirButtonString))
+		{
+			if (!m_CreateDirectoryMode)
+			{
+				m_CreateDirectoryMode = true;
+				ResetBuffer(DirectoryNameBuffer);
+			}
+		}
+		if (ImGui::IsItemHovered())
+			ImGui::SetTooltip(buttonCreateDirString);
+
+		if (m_CreateDirectoryMode)
+		{
+			ImGui::SameLine();
+
+			ImGui::PushItemWidth(100.0f);
+			ImGui::InputText("##DirectoryFileName", DirectoryNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER);
+			ImGui::PopItemWidth();
+
+			ImGui::SameLine();
+
+			if (IMGUI_BUTTON(okButtonString))
+			{
+				std::string newDir = std::string(DirectoryNameBuffer);
+				if (CreateDir(newDir))
+				{
+					SetPath(m_CurrentPath + PATH_SEP + newDir);
+				}
+
+				m_CreateDirectoryMode = false;
+			}
+
+			ImGui::SameLine();
+
+			if (IMGUI_BUTTON(cancelButtonString))
+			{
+				m_CreateDirectoryMode = false;
+			}
+		}
+
+		ImGui::SameLine();
+
+		ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
+
+		ImGui::SameLine();
+	}
+
+	void IGFD::FileDialog::DrawPathComposer()
+	{
+		if (IMGUI_BUTTON(resetButtonString))
+		{
+			SetPath(".");
+		}
+		if (ImGui::IsItemHovered())
+			ImGui::SetTooltip(buttonResetPathString);
+
+#ifdef WIN32
+		ImGui::SameLine();
+
+		if (IMGUI_BUTTON(drivesButtonString))
+		{
+			m_DrivesClicked = true;
+		}
+		if (ImGui::IsItemHovered())
+			ImGui::SetTooltip(buttonDriveString);
+#endif // WIN32
+
+		ImGui::SameLine();
+
+		ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
+
+		// show current path
+		if (!m_CurrentPath_Decomposition.empty())
+		{
+			ImGui::SameLine();
+
+			if (m_InputPathActivated)
+			{
+				ImGui::PushItemWidth(ImGui::GetContentRegionAvail().x);
+				ImGui::InputText("##pathedition", InputPathBuffer, MAX_PATH_BUFFER_SIZE);
+				ImGui::PopItemWidth();
+			}
+			else
+			{
+				int _id = 0;
+				for (auto itPathDecomp = m_CurrentPath_Decomposition.begin();
+					itPathDecomp != m_CurrentPath_Decomposition.end(); ++itPathDecomp)
+				{
+					if (itPathDecomp != m_CurrentPath_Decomposition.begin())
+						ImGui::SameLine();
+					ImGui::PushID(_id++);
+					bool click = IMGUI_PATH_BUTTON((*itPathDecomp).c_str());
+					ImGui::PopID();
+					if (click)
+					{
+						m_CurrentPath = ComposeNewPath(itPathDecomp);
+						m_PathClicked = true;
+						break;
+					}
+					// activate input for path
+					if (ImGui::IsItemClicked(ImGuiMouseButton_Right))
+					{
+						SetBuffer(InputPathBuffer, MAX_PATH_BUFFER_SIZE, ComposeNewPath(itPathDecomp));
+						m_InputPathActivated = true;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	void IGFD::FileDialog::DrawSearchBar()
+	{
+		// search field
+		if (IMGUI_BUTTON(resetButtonString "##BtnImGuiFileDialogSearchField"))
+		{
+			ResetBuffer(SearchBuffer);
+			searchTag.clear();
+			ApplyFilteringOnFileList();
+		}
+		if (ImGui::IsItemHovered())
+			ImGui::SetTooltip(buttonResetSearchString);
+		ImGui::SameLine();
+		ImGui::Text(searchString);
+		ImGui::SameLine();
+		ImGui::PushItemWidth(ImGui::GetContentRegionAvail().x);
+		bool edited = ImGui::InputText("##InputImGuiFileDialogSearchField", SearchBuffer, MAX_FILE_DIALOG_NAME_BUFFER);
+		ImGui::PopItemWidth();
+		if (edited)
+		{
+			searchTag = SearchBuffer;
+			ApplyFilteringOnFileList();
+		}
+	}
+
+	void IGFD::FileDialog::DrawFileListView(ImVec2 vSize)
+	{
+		ImGui::BeginChild("##FileDialog_FileList", vSize);
+
+		static ImGuiTableFlags flags = ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg |
+			ImGuiTableFlags_Hideable | ImGuiTableFlags_ScrollY |
+			ImGuiTableFlags_NoHostExtendY
+#ifndef USE_CUSTOM_SORTING_ICON
+			| ImGuiTableFlags_Sortable
+#endif // USE_CUSTOM_SORTING_ICON
+			;
+		if (ImGui::BeginTable("##fileTable", 4, flags, vSize))
+		{
+			ImGui::TableSetupScrollFreeze(0, 1); // Make header always visible
+			ImGui::TableSetupColumn(m_HeaderFileName.c_str(), ImGuiTableColumnFlags_WidthStretch, -1, 0);
+			ImGui::TableSetupColumn(m_HeaderFileType.c_str(), ImGuiTableColumnFlags_WidthFixed | ((dlg_flags & ImGuiFileDialogFlags_HideColumnType) ? ImGuiTableColumnFlags_DefaultHide : 0), -1, 1);
+			ImGui::TableSetupColumn(m_HeaderFileSize.c_str(), ImGuiTableColumnFlags_WidthFixed | ((dlg_flags & ImGuiFileDialogFlags_HideColumnSize) ? ImGuiTableColumnFlags_DefaultHide : 0), -1, 2);
+			ImGui::TableSetupColumn(m_HeaderFileDate.c_str(), ImGuiTableColumnFlags_WidthFixed | ((dlg_flags & ImGuiFileDialogFlags_HideColumnDate) ? ImGuiTableColumnFlags_DefaultHide : 0), -1, 3);
+
+#ifndef USE_CUSTOM_SORTING_ICON
+			// Sort our data if sort specs have been changed!
+			if (ImGuiTableSortSpecs* sorts_specs = ImGui::TableGetSortSpecs())
+			{
+				if (sorts_specs->SpecsDirty && !m_FileList.empty())
+				{
+					if (sorts_specs->Specs->ColumnUserID == 0)
+						SortFields(SortingFieldEnum::FIELD_FILENAME, true);
+					else if (sorts_specs->Specs->ColumnUserID == 1)
+						SortFields(SortingFieldEnum::FIELD_TYPE, true);
+					else if (sorts_specs->Specs->ColumnUserID == 2)
+						SortFields(SortingFieldEnum::FIELD_SIZE, true);
+					else //if (sorts_specs->Specs->ColumnUserID == 3) => alwayd true for the moment, to uncomment if we add a fourth column
+						SortFields(SortingFieldEnum::FIELD_DATE, true);
+
+					sorts_specs->SpecsDirty = false;
+				}
+			}
+
+			ImGui::TableHeadersRow();
+#else // USE_CUSTOM_SORTING_ICON
+			ImGui::TableNextRow(ImGuiTableRowFlags_Headers);
+			for (int column = 0; column < 4; column++)
+			{
+				ImGui::TableSetColumnIndex(column);
+				const char* column_name = ImGui::TableGetColumnName(column); // Retrieve name passed to TableSetupColumn()
+				ImGui::PushID(column);
+				ImGui::TableHeader(column_name);
+				ImGui::PopID();
+				if (ImGui::IsItemClicked())
+				{
+					if (column == 0)
+						SortFields(SortingFieldEnum::FIELD_FILENAME, true);
+					else if (column == 1)
+						SortFields(SortingFieldEnum::FIELD_TYPE, true);
+					else if (column == 2)
+						SortFields(SortingFieldEnum::FIELD_SIZE, true);
+					else //if (column == 3) => alwayd true for the moment, to uncomment if we add a fourth column
+						SortFields(SortingFieldEnum::FIELD_DATE, true);
+				}
+			}
+#endif // USE_CUSTOM_SORTING_ICON
+			
+			if (!m_FilteredFileList.empty())
+			{
+				m_FileListClipper.Begin((int)m_FilteredFileList.size(), ImGui::GetTextLineHeightWithSpacing());
+				while (m_FileListClipper.Step())
+				{
+					for (int i = m_FileListClipper.DisplayStart; i < m_FileListClipper.DisplayEnd; i++)
+					{
+						if (i < 0) continue;
+
+						const FileInfoStruct& infos = m_FilteredFileList[i];
+
+						ImVec4 c;
+						std::string icon;
+						bool showColor = GetExtentionInfos(infos.ext, &c, &icon);
+						if (showColor)
+							ImGui::PushStyleColor(ImGuiCol_Text, c);
+
+						std::string str = " " + infos.fileName;
+						if (infos.type == 'd') str = dirEntryString + str;
+						else if (infos.type == 'l') str = linkEntryString + str;
+						else if (infos.type == 'f')
+						{
+							if (showColor && !icon.empty())
+								str = icon + str;
+							else
+								str = fileEntryString + str;
+						}
+						bool selected = (m_SelectedFileNames.find(infos.fileName) != m_SelectedFileNames.end()); // found
+
+						ImGui::TableNextRow();
+
+						bool needToBreakTheloop = false;
+
+						if (ImGui::TableNextColumn()) // file name
+						{
+							needToBreakTheloop = SelectableItem(i, infos, selected, "%s", str.c_str());
+						}
+						if (ImGui::TableNextColumn()) // file type
+						{
+							ImGui::Text("%s", infos.ext.c_str());
+						}
+						if (ImGui::TableNextColumn()) // file size
+						{
+							if (infos.type != 'd')
+							{
+								ImGui::Text("%s ", infos.formatedFileSize.c_str());
+							}
+							else
+							{
+								ImGui::Text("%s ", "");
+							}
+						}
+						if (ImGui::TableNextColumn()) // file date + time
+						{
+							ImGui::Text("%s", infos.fileModifDate.c_str());
+						}
+
+						if (showColor)
+							ImGui::PopStyleColor();
+
+						if (needToBreakTheloop)
+							break;
+					}
+				}
+				m_FileListClipper.End();
+			}
+
+			if (m_InputPathActivated)
+			{
+				ImGuiIO gio = ImGui::GetIO();
+				if (ImGui::IsKeyReleased(gio.KeyMap[ImGuiKey_Enter]))
+				{
+					SetPath(std::string(InputPathBuffer));
+					m_InputPathActivated = false;
+				}
+				if (ImGui::IsKeyReleased(gio.KeyMap[ImGuiKey_Escape]))
+				{
+					m_InputPathActivated = false;
+				}
+			}
+#ifdef USE_EXPLORATION_BY_KEYS
+			else
+			{
+				LocateByInputKey();
+				ExploreWithkeys();
+			}
+#endif // USE_EXPLORATION_BY_KEYS
+			ImGui::EndTable();
+		}
+		// changement de repertoire
+		if (m_PathClicked)
+		{
+			SetPath(m_CurrentPath);
+		}
+
+		if (m_DrivesClicked)
+		{
+			GetDrives();
+		}
+
+		ImGui::EndChild();
+	}
+
+	bool IGFD::FileDialog::SelectableItem(int vidx, const FileInfoStruct& vInfos, bool vSelected, const char* vFmt, ...)
+	{
+		static ImGuiSelectableFlags selectableFlags = ImGuiSelectableFlags_AllowDoubleClick | 
+			ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_SpanAvailWidth;
+
+		va_list args;
+		va_start(args, vFmt);
+		vsnprintf(VariadicBuffer, MAX_FILE_DIALOG_NAME_BUFFER, vFmt, args);
+		va_end(args);
+
+#ifdef USE_EXPLORATION_BY_KEYS
+		bool flashed = BeginFlashItem(vidx);
+		bool res = FlashableSelectable(VariadicBuffer, vSelected, selectableFlags,
+			flashed);
+		if (flashed)
+			EndFlashItem();
+#else // USE_EXPLORATION_BY_KEYS
+		(void)vidx; // remove a warnings ofr unused var
+		bool res = ImGui::Selectable(VariadicBuffer, vSelected, selectableFlags);
+#endif // USE_EXPLORATION_BY_KEYS
+		if (res)
+		{
+			if (vInfos.type == 'd')
+			{
+				if (ImGui::IsMouseDoubleClicked(0)) // 0 -> left mouse button double click
+				{
+					m_PathClicked = SelectDirectory(vInfos); 
+					return true; // needToBreakTheloop
+				}
+				else if (dlg_filters.empty()) // directory chooser
+				{
+					SelectFileName(vInfos);
+				}
+			}
+			else
+			{
+				SelectFileName(vInfos);
+
+				if (ImGui::IsMouseDoubleClicked(0))
+				{
+					m_WantToQuit = true;
+					m_IsOk = true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	void IGFD::FileDialog::DrawSidePane(float vHeight)
+	{
+		ImGui::SameLine();
+
+		ImGui::BeginChild("##FileTypes", ImVec2(0, vHeight));
+
+		dlg_optionsPane(m_SelectedFilter.filter.c_str(), dlg_userDatas, &m_CanWeContinue);
+
+		ImGui::EndChild();
+	}
+
+	void IGFD::FileDialog::Close()
+	{
+		dlg_key.clear();
+		m_ShowDialog = false;
+	}
+
+	bool IGFD::FileDialog::WasOpenedThisFrame(const std::string& vKey)
+	{
+		bool res = m_ShowDialog && dlg_key == vKey;
+		if (res)
+		{
+			ImGuiContext& g = *GImGui;
+			res &= m_LastImGuiFrameCount == g.FrameCount; // return true if a dialog was displayed in this frame
+		}
+		return res;
+	}
+
+	bool IGFD::FileDialog::WasOpenedThisFrame()
+	{
+		bool res = m_ShowDialog;
+		if (res)
+		{
+			ImGuiContext& g = *GImGui;
+			res &= m_LastImGuiFrameCount == g.FrameCount; // return true if a dialog was displayed in this frame
+		}
+		return res;
+	}
+
+	bool IGFD::FileDialog::IsOpened(const std::string& vKey)
+	{
+		return (m_ShowDialog && dlg_key == vKey);
+	}
+
+	bool IGFD::FileDialog::IsOpened()
+	{
+		return m_ShowDialog;
+	}
+
+	std::string IGFD::FileDialog::GetOpenedKey()
+	{
+		if (m_ShowDialog)
+			return dlg_key;
+		return "";
+	}
+
+	std::string IGFD::FileDialog::GetFilePathName()
+	{
+		std::string result = GetCurrentPath();
+
+		std::string filename = GetCurrentFileName();
+		if (!filename.empty())
+		{
+#ifdef UNIX
+			if (s_fs_root != result)
+#endif // UNIX
+				result += PATH_SEP;
+
+			result += filename;
+		}
+
+		return result;
+	}
+
+	std::string IGFD::FileDialog::GetCurrentPath()
+	{
+		std::string path = m_CurrentPath;
+
+		if (dlg_filters.empty()) // if directory mode
+		{
+			std::string selectedDirectory = FileNameBuffer;
+			if (!selectedDirectory.empty() && selectedDirectory != ".")
+			{
+				if (path.empty())
+					path = selectedDirectory;
+				else
+					path += PATH_SEP + selectedDirectory;
+			}
+		}
+
+		return path;
+	}
+
+	std::string IGFD::FileDialog::GetCurrentFileName()
+	{
+		if (!dlg_filters.empty()) // if not directory mode
+		{
+			std::string result = FileNameBuffer;
+
+			// if not a collection we can replace the filter by the extention we want
+			if (m_SelectedFilter.collectionfilters.empty())
+			{
+				if (m_SelectedFilter.filter.find('*') == std::string::npos && result != m_SelectedFilter.filter)
+				{
+					size_t lastPoint = result.find_last_of('.');
+					if (lastPoint != std::string::npos)
+					{
+						result = result.substr(0, lastPoint);
+					}
+
+					result += m_SelectedFilter.filter;
+				}
+			}
+
+			return result;
+		}
+
+		return ""; // directory mode
+	}
+
+	std::string IGFD::FileDialog::GetCurrentFilter()
+	{
+		return m_SelectedFilter.filter;
+	}
+
+	UserDatas IGFD::FileDialog::GetUserDatas()
+	{
+		return dlg_userDatas;
+	}
+
+	bool IGFD::FileDialog::IsOk()
+	{
+		return m_IsOk;
+	}
+
+	std::map<std::string, std::string> IGFD::FileDialog::GetSelection()
+	{
+		std::map<std::string, std::string> res;
+
+		for (auto& it : m_SelectedFileNames)
+		{
+			std::string result = GetCurrentPath();
+
+#ifdef UNIX
+			if (s_fs_root != result)
+#endif // UNIX
+				result += PATH_SEP;
+
+			result += it;
+
+			res[it] = result;
+		}
+
+		return res;
+	}
+
+	void IGFD::FileDialog::SetExtentionInfos(const std::string& vFilter, const FileExtentionInfosStruct& vInfos)
+	{
+		m_FileExtentionInfos[vFilter] = vInfos;
+	}
+
+	void IGFD::FileDialog::SetExtentionInfos(const std::string& vFilter, const ImVec4& vColor, const std::string& vIcon)
+	{
+		m_FileExtentionInfos[vFilter] = FileExtentionInfosStruct(vColor, vIcon);
+	}
+
+	bool IGFD::FileDialog::GetExtentionInfos(const std::string& vFilter, ImVec4* vOutColor, std::string* vOutIcon)
+	{
+		if (vOutColor)
+		{
+			if (m_FileExtentionInfos.find(vFilter) != m_FileExtentionInfos.end()) // found
+			{
+				*vOutColor = m_FileExtentionInfos[vFilter].color;
+				if (vOutIcon)
+				{
+					*vOutIcon = m_FileExtentionInfos[vFilter].icon;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+
+	void IGFD::FileDialog::ClearExtentionInfos()
+	{
+		m_FileExtentionInfos.clear();
+	}
+
+	void IGFD::FileDialog::SetDefaultFileName(const std::string& vFileName)
+	{
+		dlg_defaultFileName = vFileName;
+		SetBuffer(FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER, vFileName);
+	}
+
+	bool IGFD::FileDialog::SelectDirectory(const FileInfoStruct& vInfos)
+	{
+		bool pathClick = false;
+
+		if (vInfos.fileName == "..")
+		{
+			if (m_CurrentPath_Decomposition.size() > 1)
+			{
+				m_CurrentPath = ComposeNewPath(m_CurrentPath_Decomposition.end() - 2);
+				pathClick = true;
+			}
+		}
+		else
+		{
+			std::string newPath;
+
+			if (m_ShowDrives)
+			{
+				newPath = vInfos.fileName + PATH_SEP;
+			}
+			else
+			{
+#ifdef __linux__
+				if (s_fs_root == m_CurrentPath)
+					newPath = m_CurrentPath + vInfos.fileName;
+				else
+#endif // __minux__
+					newPath = m_CurrentPath + PATH_SEP + vInfos.fileName;
+			}
+
+			if (IsDirectoryExist(newPath))
+			{
+				if (m_ShowDrives)
+				{
+					m_CurrentPath = vInfos.fileName;
+					s_fs_root = m_CurrentPath;
+				}
+				else
+				{
+					m_CurrentPath = newPath; //-V820
+				}
+				pathClick = true;
+			}
+		}
+
+		return pathClick;
+	}
+
+	void IGFD::FileDialog::SelectFileName(const FileInfoStruct& vInfos)
+	{
+		if (ImGui::GetIO().KeyCtrl)
+		{
+			if (dlg_countSelectionMax == 0) // infinite selection
+			{
+				if (m_SelectedFileNames.find(vInfos.fileName) == m_SelectedFileNames.end()) // not found +> add
+				{
+					AddFileNameInSelection(vInfos.fileName, true);
+				}
+				else // found +> remove
+				{
+					RemoveFileNameInSelection(vInfos.fileName);
+				}
+			}
+			else // selection limited by size
+			{
+				if (m_SelectedFileNames.size() < dlg_countSelectionMax)
+				{
+					if (m_SelectedFileNames.find(vInfos.fileName) == m_SelectedFileNames.end()) // not found +> add
+					{
+						AddFileNameInSelection(vInfos.fileName, true);
+					}
+					else // found +> remove
+					{
+						RemoveFileNameInSelection(vInfos.fileName);
+					}
+				}
+			}
+		}
+		else if (ImGui::GetIO().KeyShift)
+		{
+			if (dlg_countSelectionMax != 1)
+			{
+				m_SelectedFileNames.clear();
+				// we will iterate filelist and get the last selection after the start selection
+				bool startMultiSelection = false;
+				std::string fileNameToSelect = vInfos.fileName;
+				std::string savedLastSelectedFileName; // for invert selection mode
+				for (auto& it : m_FileList)
+				{
+					const FileInfoStruct& infos = it;
+
+					bool canTake = true;
+					if (!searchTag.empty() && infos.fileName.find(searchTag) == std::string::npos) canTake = false;
+					if (canTake) // if not filtered, we will take files who are filtered by the dialog
+					{
+						if (infos.fileName == m_LastSelectedFileName)
+						{
+							startMultiSelection = true;
+							AddFileNameInSelection(m_LastSelectedFileName, false);
+						}
+						else if (startMultiSelection)
+						{
+							if (dlg_countSelectionMax == 0) // infinite selection
+							{
+								AddFileNameInSelection(infos.fileName, false);
+							}
+							else // selection limited by size
+							{
+								if (m_SelectedFileNames.size() < dlg_countSelectionMax)
+								{
+									AddFileNameInSelection(infos.fileName, false);
+								}
+								else
+								{
+									startMultiSelection = false;
+									if (!savedLastSelectedFileName.empty())
+										m_LastSelectedFileName = savedLastSelectedFileName;
+									break;
+								}
+							}
+						}
+
+						if (infos.fileName == fileNameToSelect)
+						{
+							if (!startMultiSelection) // we are before the last Selected FileName, so we must inverse
+							{
+								savedLastSelectedFileName = m_LastSelectedFileName;
+								m_LastSelectedFileName = fileNameToSelect;
+								fileNameToSelect = savedLastSelectedFileName;
+								startMultiSelection = true;
+								AddFileNameInSelection(m_LastSelectedFileName, false);
+							}
+							else
+							{
+								startMultiSelection = false;
+								if (!savedLastSelectedFileName.empty())
+									m_LastSelectedFileName = savedLastSelectedFileName;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			m_SelectedFileNames.clear();
+			ResetBuffer(FileNameBuffer);
+			AddFileNameInSelection(vInfos.fileName, true);
+		}
+	}
+
+	void IGFD::FileDialog::RemoveFileNameInSelection(const std::string& vFileName)
+	{
+		m_SelectedFileNames.erase(vFileName);
+
+		if (m_SelectedFileNames.size() == 1)
+		{
+			snprintf(FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER, "%s", vFileName.c_str());
+		}
+		else
+		{
+			snprintf(FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER, "%zu files Selected", m_SelectedFileNames.size());
+		}
+	}
+
+	void IGFD::FileDialog::AddFileNameInSelection(const std::string& vFileName, bool vSetLastSelectionFileName)
+	{
+		m_SelectedFileNames.emplace(vFileName);
+
+		if (m_SelectedFileNames.size() == 1)
+		{
+			snprintf(FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER, "%s", vFileName.c_str());
+		}
+		else
+		{
+			snprintf(FileNameBuffer, MAX_FILE_DIALOG_NAME_BUFFER, "%zu files Selected", m_SelectedFileNames.size());
+		}
+
+		if (vSetLastSelectionFileName)
+			m_LastSelectedFileName = vFileName;
+	}
+
+	void IGFD::FileDialog::SetPath(const std::string& vPath)
+	{
+		m_ShowDrives = false;
+		m_CurrentPath = vPath;
+		m_FileList.clear();
+		m_CurrentPath_Decomposition.clear();
+		if (dlg_filters.empty()) // directory mode
+			SetDefaultFileName(".");
+		ScanDir(m_CurrentPath);
+	}
+
+	static std::string round_n(double vvalue, int n)
+	{
+		std::stringstream tmp;
+		tmp << std::setprecision(n) << std::fixed << vvalue;
+		return tmp.str();
+	}
+
+	static void FormatFileSize(size_t vByteSize, std::string* vFormat)
+	{
+		if (vFormat && vByteSize != 0)
+		{
+			static double lo = 1024.0;
+			static double ko = 1024.0 * 1024.0;
+			static double mo = 1024.0 * 1024.0 * 1024.0;
+
+			double v = (double)vByteSize;
+
+			if (v < lo)
+				*vFormat = round_n(v, 0) + " o"; // octet
+			else if (v < ko)
+				*vFormat = round_n(v / lo, 2) + " Ko"; // ko
+			else  if (v < mo)
+				*vFormat = round_n(v / ko, 2) + " Mo"; // Mo 
+			else
+				*vFormat = round_n(v / mo, 2) + " Go"; // Go 
+		}
+	}
+
+	void IGFD::FileDialog::CompleteFileInfos(FileInfoStruct* vFileInfoStruct)
+	{
+		if (vFileInfoStruct && 
+			vFileInfoStruct->fileName != "." && 
+			vFileInfoStruct->fileName != "..")
+		{
+			// _stat struct :
+			//dev_t     st_dev;     /* ID of device containing file */
+			//ino_t     st_ino;     /* inode number */
+			//mode_t    st_mode;    /* protection */
+			//nlink_t   st_nlink;   /* number of hard links */
+			//uid_t     st_uid;     /* user ID of owner */
+			//gid_t     st_gid;     /* group ID of owner */
+			//dev_t     st_rdev;    /* device ID (if special file) */
+			//off_t     st_size;    /* total size, in bytes */
+			//blksize_t st_blksize; /* blocksize for file system I/O */
+			//blkcnt_t  st_blocks;  /* number of 512B blocks allocated */
+			//time_t    st_atime;   /* time of last access - not sure out of ntfs */
+			//time_t    st_mtime;   /* time of last modification - not sure out of ntfs */
+			//time_t    st_ctime;   /* time of last status change - not sure out of ntfs */
+
+			std::string fpn;
+
+			if (vFileInfoStruct->type == 'f') // file
+				fpn = vFileInfoStruct->filePath + PATH_SEP + vFileInfoStruct->fileName;
+			else if (vFileInfoStruct->type == 'l') // link
+				fpn = vFileInfoStruct->filePath + PATH_SEP + vFileInfoStruct->fileName;
+			else if (vFileInfoStruct->type == 'd') // directory
+				fpn = vFileInfoStruct->filePath + PATH_SEP + vFileInfoStruct->fileName;
+
+			struct stat statInfos;
+			char timebuf[100];
+			int result = stat(fpn.c_str(), &statInfos);
+			if (!result)
+			{
+				if (vFileInfoStruct->type != 'd')
+				{
+					vFileInfoStruct->fileSize = (size_t)statInfos.st_size;
+					FormatFileSize(vFileInfoStruct->fileSize,
+						&vFileInfoStruct->formatedFileSize);
+				}
+
+				size_t len = 0;
+#ifdef MSVC
+				struct tm _tm;
+				errno_t err = localtime_s(&_tm, &statInfos.st_mtime);
+				if (!err) len = strftime(timebuf, 99, DateTimeFormat, &_tm);
+#else // MSVC
+				struct tm* _tm = localtime(&statInfos.st_mtime);
+				if (_tm) len = strftime(timebuf, 99, DateTimeFormat, _tm);
+#endif // MSVC
+				if (len)
+				{
+					vFileInfoStruct->fileModifDate = std::string(timebuf, len);
+				}
+			}
+		}
+	}
+
+	void IGFD::FileDialog::SortFields(SortingFieldEnum vSortingField, bool vCanChangeOrder)
+	{
+		if (vSortingField != SortingFieldEnum::FIELD_NONE)
+		{
+			m_HeaderFileName = tableHeaderFileNameString;
+			m_HeaderFileType = tableHeaderFileTypeString;
+			m_HeaderFileSize = tableHeaderFileSizeString;
+			m_HeaderFileDate = tableHeaderFileDateString;
+		}
+
+		if (vSortingField == SortingFieldEnum::FIELD_FILENAME)
+		{
+			if (vCanChangeOrder && m_SortingField == vSortingField)
+				m_SortingDirection[0] = !m_SortingDirection[0];
+
+			if (m_SortingDirection[0])
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileName = tableHeaderDescendingIcon + m_HeaderFileName;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+					  	if (a.fileName[0] == '.' && b.fileName[0] != '.') return true;
+					  	if (a.fileName[0] != '.' && b.fileName[0] == '.') return false;
+					  	if (a.fileName[0] == '.' && b.fileName[0] == '.')
+					  	{
+						  	if (a.fileName.length() == 1) return false;
+						  	if (b.fileName.length() == 1) return true;
+						  	return (stricmp(a.fileName.c_str() + 1, b.fileName.c_str() + 1) < 0);
+					  	}
+
+						if (a.type != b.type) return (a.type == 'd'); // directory in first
+						return (stricmp(a.fileName.c_str(), b.fileName.c_str()) < 0); // sort in insensitive case
+					});
+			}
+			else
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileName = tableHeaderAscendingIcon + m_HeaderFileName;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+					  	if (a.fileName[0] == '.' && b.fileName[0] != '.') return false;
+					  	if (a.fileName[0] != '.' && b.fileName[0] == '.') return true;
+					  	if (a.fileName[0] == '.' && b.fileName[0] == '.')
+					  	{
+						  	if (a.fileName.length() == 1) return true;
+						  	if (b.fileName.length() == 1) return false;
+						  	return (stricmp(a.fileName.c_str() + 1, b.fileName.c_str() + 1) > 0);
+					  	}
+
+						if (a.type != b.type) return (a.type != 'd'); // directory in last
+						return (stricmp(a.fileName.c_str(), b.fileName.c_str()) > 0); // sort in insensitive case
+					});
+			}
+		}
+		else if (vSortingField == SortingFieldEnum::FIELD_TYPE)
+		{
+			if (vCanChangeOrder && m_SortingField == vSortingField)
+				m_SortingDirection[1] = !m_SortingDirection[1];
+
+			if (m_SortingDirection[1])
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileType = tableHeaderDescendingIcon + m_HeaderFileType;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type == 'd'); // directory in first
+						return (a.ext < b.ext); // else
+					});
+			}
+			else
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileType = tableHeaderAscendingIcon + m_HeaderFileType;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type != 'd'); // directory in last
+						return (a.ext > b.ext); // else
+					});
+			}
+		}
+		else if (vSortingField == SortingFieldEnum::FIELD_SIZE)
+		{
+			if (vCanChangeOrder && m_SortingField == vSortingField)
+				m_SortingDirection[2] = !m_SortingDirection[2];
+
+			if (m_SortingDirection[2])
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileSize = tableHeaderDescendingIcon + m_HeaderFileSize;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type == 'd'); // directory in first
+						return (a.fileSize < b.fileSize); // else
+					});
+			}
+			else
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileSize = tableHeaderAscendingIcon + m_HeaderFileSize;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type != 'd'); // directory in last
+						return (a.fileSize > b.fileSize); // else
+					});
+			}
+		}
+		else if (vSortingField == SortingFieldEnum::FIELD_DATE)
+		{
+			if (vCanChangeOrder && m_SortingField == vSortingField)
+				m_SortingDirection[3] = !m_SortingDirection[3];
+
+			if (m_SortingDirection[3])
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileDate = tableHeaderDescendingIcon + m_HeaderFileDate;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type == 'd'); // directory in first
+						return (a.fileModifDate < b.fileModifDate); // else
+					});
+			}
+			else
+			{
+#ifdef USE_CUSTOM_SORTING_ICON
+				m_HeaderFileDate = tableHeaderAscendingIcon + m_HeaderFileDate;
+#endif // USE_CUSTOM_SORTING_ICON
+				std::sort(m_FileList.begin(), m_FileList.end(),
+					[](const FileInfoStruct& a, const FileInfoStruct& b) -> bool
+					{
+						if (a.type != b.type) return (a.type != 'd'); // directory in last
+						return (a.fileModifDate > b.fileModifDate); // else
+					});
+			}
+		}
+
+		if (vSortingField != SortingFieldEnum::FIELD_NONE)
+		{
+			m_SortingField = vSortingField;
+		}
+
+		ApplyFilteringOnFileList();
+	}
+
+	void IGFD::FileDialog::ScanDir(const std::string& vPath)
+	{
+		struct dirent** files = nullptr;
+		int          i = 0;
+		int          n = 0;
+		std::string		path = vPath;
+
+		if (m_CurrentPath_Decomposition.empty())
+		{
+			SetCurrentDir(path);
+		}
+
+		if (!m_CurrentPath_Decomposition.empty())
+		{
+#ifdef WIN32
+			if (path == s_fs_root)
+				path += PATH_SEP;
+#endif // WIN32
+			n = scandir(path.c_str(), &files, nullptr, alphaSort);
+
+			m_FileList.clear();
+
+			if (n > 0)
+			{
+				for (i = 0; i < n; i++)
+				{
+					struct dirent* ent = files[i];
+
+					FileInfoStruct infos;
+
+					infos.filePath = path;
+					infos.fileName = ent->d_name;
+					infos.fileName_optimized = OptimizeFilenameForSearchOperations(infos.fileName);
+
+					if (infos.fileName.empty() || (infos.fileName == "." && !dlg_filters.empty())) continue; // filename empty or filename is the current dir '.'
+					if (infos.fileName != ".." && (dlg_flags & ImGuiFileDialogFlags_DontShowHiddenFiles) && infos.fileName[0] == '.') // dont show hidden files
+						if (!dlg_filters.empty() || (dlg_filters.empty() && infos.fileName != ".")) // except "." if in directory mode
+							continue;
+					
+					switch (ent->d_type)
+					{
+					case DT_REG:
+						infos.type = 'f'; break;
+					case DT_DIR:
+						infos.type = 'd'; break;
+					case DT_LNK:
+						infos.type = 'l'; break;
+					}
+
+					if (infos.type == 'f' ||
+						infos.type == 'l') // link can have the same extention of a file
+					{
+						size_t lpt = infos.fileName.find_last_of('.');
+						if (lpt != std::string::npos)
+						{
+							infos.ext = infos.fileName.substr(lpt);
+						}
+
+						if (!dlg_filters.empty())
+						{
+							// check if current file extention is covered by current filter
+							// we do that here, for avoid doing that during filelist display
+							// for better fps
+							if (!m_SelectedFilter.empty() && // selected filter exist
+								(!m_SelectedFilter.filterExist(infos.ext) && // filter not found
+									m_SelectedFilter.filter != ".*"))
+							{
+								continue;
+							}
+						}
+					}
+
+					CompleteFileInfos(&infos);
+					m_FileList.push_back(infos);
+				}
+
+				for (i = 0; i < n; i++)
+				{
+					free(files[i]);
+				}
+
+				free(files);
+			}
+
+			SortFields(m_SortingField);
+		}
+	}
+
+	void IGFD::FileDialog::SetCurrentDir(const std::string& vPath)
+	{
+		std::string path = vPath;
+#ifdef WIN32
+		if (s_fs_root == path)
+			path += PATH_SEP;
+#endif // WIN32
+		char real_path[PATH_MAX];
+		DIR* dir = opendir(path.c_str());
+		if (dir == nullptr)
+		{
+			path = ".";
+			dir = opendir(path.c_str());
+		}
+
+		if (dir != nullptr)
+		{
+#ifdef WIN32
+			DWORD numchar = 0;
+			//			numchar = GetFullPathNameA(path.c_str(), PATH_MAX, real_path, nullptr);
+			std::wstring wpath = wGetString(path.c_str());
+			numchar = GetFullPathNameW(wpath.c_str(), 0, nullptr, nullptr);
+			std::wstring fpath(numchar, 0);
+			GetFullPathNameW(wpath.c_str(), numchar, (wchar_t*)fpath.data(), nullptr);
+			int error = dirent_wcstombs_s(nullptr, real_path, PATH_MAX, fpath.c_str(), PATH_MAX - 1);
+			if (error)numchar = 0;
+			if (!numchar)
+			{
+				std::cout << "fail to obtain FullPathName " << path << std::endl;
+			}
+#elif defined(UNIX) // UNIX is LINUX or APPLE
+			char* numchar = realpath(path.c_str(), real_path);
+#endif // defined(UNIX)
+			if (numchar != 0)
+			{
+				m_CurrentPath = real_path;
+				if (m_CurrentPath[m_CurrentPath.size() - 1] == PATH_SEP)
+				{
+					m_CurrentPath = m_CurrentPath.substr(0, m_CurrentPath.size() - 1);
+				}
+				SetBuffer(InputPathBuffer, MAX_PATH_BUFFER_SIZE, m_CurrentPath);
+				m_CurrentPath_Decomposition = splitStringToVector(m_CurrentPath, PATH_SEP, false);
+#if defined(UNIX) // UNIX is LINUX or APPLE
+				m_CurrentPath_Decomposition.insert(m_CurrentPath_Decomposition.begin(), std::string(1u, PATH_SEP));
+#endif // defined(UNIX)
+				if (!m_CurrentPath_Decomposition.empty())
+				{
+#ifdef WIN32
+					s_fs_root = m_CurrentPath_Decomposition[0];
+#endif // WIN32
+				}
+			}
+
+			closedir(dir);
+		}
+	}
+
+	bool IGFD::FileDialog::CreateDir(const std::string& vPath)
+	{
+		bool res = false;
+
+		if (!vPath.empty())
+		{
+			std::string path = m_CurrentPath + PATH_SEP + vPath;
+
+			res = CreateDirectoryIfNotExist(path);
+		}
+
+		return res;
+	}
+
+	std::string IGFD::FileDialog::ComposeNewPath(std::vector<std::string>::iterator vIter)
+	{
+		std::string res;
+
+		while (true)
+		{
+			if (!res.empty())
+			{
+#ifdef WIN32
+				res = *vIter + PATH_SEP + res;
+#elif defined(UNIX) // UNIX is LINUX or APPLE
+				if (*vIter == s_fs_root)
+				{
+					res = *vIter + res;
+				}
+				else
+				{
+					res = *vIter + PATH_SEP + res;
+				}
+#endif // defined(UNIX)
+			}
+			else
+			{
+				res = *vIter;
+			}
+
+			if (vIter == m_CurrentPath_Decomposition.begin())
+			{
+#if defined(UNIX) // UNIX is LINUX or APPLE
+				if (res[0] != PATH_SEP)
+					res = PATH_SEP + res;
+#endif // defined(UNIX)
+				break;
+			}
+
+			--vIter;
+		}
+
+		return res;
+	}
+
+	void IGFD::FileDialog::GetDrives()
+	{
+		auto drives = GetDrivesList();
+		if (!drives.empty())
+		{
+			m_CurrentPath.clear();
+			m_CurrentPath_Decomposition.clear();
+			m_FileList.clear();
+			for (auto& drive : drives)
+			{
+				FileInfoStruct infos;
+				infos.fileName = drive;
+				infos.fileName_optimized = OptimizeFilenameForSearchOperations(drive);
+				infos.type = 'd';
+
+				if (!infos.fileName.empty())
+				{
+					m_FileList.push_back(infos);
+				}
+			}
+			m_ShowDrives = true;
+			ApplyFilteringOnFileList();
+		}
+	}
+
+	void IGFD::FileDialog::ParseFilters(const char* vFilters)
+	{
+		m_Filters.clear();
+
+		if (vFilters)
+			dlg_filters = vFilters;				// file mode
+		else
+			dlg_filters.clear();				// directtory mode
+
+		if (!dlg_filters.empty())
+		{
+			// ".*,.cpp,.h,.hpp"
+			// "Source files{.cpp,.h,.hpp},Image files{.png,.gif,.jpg,.jpeg},.md"
+
+			bool currentFilterFound = false;
+
+			size_t nan = std::string::npos;
+			size_t p = 0, lp = 0;
+			while ((p = dlg_filters.find_first_of("{,", p)) != nan)
+			{
+				FilterInfosStruct infos;
+
+				if (dlg_filters[p] == '{') // {
+				{
+					infos.filter = dlg_filters.substr(lp, p - lp);
+					p++;
+					lp = dlg_filters.find('}', p);
+					if (lp != nan)
+					{
+						std::string fs = dlg_filters.substr(p, lp - p);
+						auto arr = splitStringToVector(fs, ',', false);
+						for (auto a : arr)
+						{
+							infos.collectionfilters.emplace(a);
+						}
+					}
+					p = lp + 1;
+				}
+				else // ,
+				{
+					infos.filter = dlg_filters.substr(lp, p - lp);
+					p++;
+				}
+
+				if (!currentFilterFound && m_SelectedFilter.filter == infos.filter)
+				{
+					currentFilterFound = true;
+					m_SelectedFilter = infos;
+				}
+
+				lp = p;
+				if (!infos.empty())
+					m_Filters.emplace_back(infos);
+			}
+
+			std::string token = dlg_filters.substr(lp);
+			if (!token.empty())
+			{
+				FilterInfosStruct infos;
+				infos.filter = token;
+				m_Filters.emplace_back(infos);
+			}
+
+			if (!currentFilterFound)
+				if (!m_Filters.empty())
+					m_SelectedFilter = *m_Filters.begin();
+		}
+	}
+
+	void IGFD::FileDialog::SetSelectedFilterWithExt(const std::string& vFilter)
+	{
+		if (!m_Filters.empty())
+		{
+			if (!vFilter.empty())
+			{
+				// std::map<std::string, FilterInfosStruct>
+				for (const auto& infos : m_Filters)
+				{
+					if (vFilter == infos.filter)
+					{
+						m_SelectedFilter = infos;
+					}
+					else
+					{
+						// maybe this ext is in an extention so we will 
+						// explore the collections is they are existing
+						for (const auto& filter : infos.collectionfilters)
+						{
+							if (vFilter == filter)
+							{
+								m_SelectedFilter = infos;
+							}
+						}
+					}
+				}
+			}
+
+			if (m_SelectedFilter.empty())
+				m_SelectedFilter = *m_Filters.begin();
+		}
+	}
+
+	std::string IGFD::FileDialog::OptimizeFilenameForSearchOperations(std::string vFileName)
+	{
+		// convert to lower case
+		for (char& c : vFileName)
+			c = (char)std::tolower(c);
+		return vFileName;
+	}
+
+	void IGFD::FileDialog::ApplyFilteringOnFileList()
+	{
+		m_FilteredFileList.clear();
+
+		for (auto& it : m_FileList)
+		{
+			const FileInfoStruct& infos = it;
+
+			bool show = true;
+
+			// if search tag
+			if (!searchTag.empty() &&
+				infos.fileName_optimized.find(searchTag) == std::string::npos && // first try wihtout case and accents
+				infos.fileName.find(searchTag) == std::string::npos) // second if searched with case and accents
+			{
+				show = false;
+			}
+
+			if (dlg_filters.empty() && infos.type != 'd') // directory mode
+			{
+				show = false;
+			}
+
+			if (show)
+			{
+				m_FilteredFileList.push_back(infos);
+			}
+		}
+	}
+
+#ifdef USE_EXPLORATION_BY_KEYS
+
+	//////////////////////////////////////////////////////////////////////////////
+	//// LOCATE / EXPLORE WITH KEYS //////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////
+
+	bool IGFD::FileDialog::LocateItem_Loop(ImWchar vC)
+	{
+		bool found = false;
+
+		for (size_t i =m_LocateFileByInputChar_lastFileIdx; i < m_FilteredFileList.size(); i++)
+		{
+			if (m_FilteredFileList[i].fileName_optimized[0] == vC || // lower case search
+				m_FilteredFileList[i].fileName[0] == vC) // maybe upper case search
+			{
+				//float p = ((float)i) * ImGui::GetTextLineHeightWithSpacing();
+				float p = (float)((double)i / (double)m_FilteredFileList.size()) * ImGui::GetScrollMaxY();
+				ImGui::SetScrollY(p);
+				m_LocateFileByInputChar_lastFound = true;
+				m_LocateFileByInputChar_lastFileIdx = i;
+				StartFlashItem(m_LocateFileByInputChar_lastFileIdx);
+
+				auto infos = &m_FilteredFileList[m_LocateFileByInputChar_lastFileIdx];
+
+				if (infos->type == 'd')
+				{
+					if (dlg_filters.empty()) // directory chooser
+					{
+						SelectFileName(*infos);
+					}
+				}
+				else
+				{
+					SelectFileName(*infos);
+				}
+
+				found = true;
+
+				break;
+			}
+		}
+
+		return found;
+	}
+
+	void IGFD::FileDialog::LocateByInputKey()
+	{
+		ImGuiContext& g = *GImGui;
+		if (!g.ActiveId && !m_FilteredFileList.empty())
+		{
+			auto& queueChar = ImGui::GetIO().InputQueueCharacters;
+
+			// point by char
+			if (!queueChar.empty())
+			{
+				ImWchar c = queueChar.back();
+				if (m_LocateFileByInputChar_InputQueueCharactersSize != queueChar.size())
+				{
+					if (c == m_LocateFileByInputChar_lastChar) // next file starting with same char until
+					{
+						if (m_LocateFileByInputChar_lastFileIdx < m_FilteredFileList.size() - 1)
+							m_LocateFileByInputChar_lastFileIdx++;
+						else
+							m_LocateFileByInputChar_lastFileIdx = 0;
+					}
+
+					if (!LocateItem_Loop(c))
+					{
+						// not found, loop again from 0 this time
+						m_LocateFileByInputChar_lastFileIdx = 0;
+						LocateItem_Loop(c);
+					}
+
+					m_LocateFileByInputChar_lastChar = c;
+				}
+			}
+
+			m_LocateFileByInputChar_InputQueueCharactersSize = queueChar.size();
+		}
+	}
+
+	void IGFD::FileDialog::ExploreWithkeys()
+	{
+		ImGuiContext& g = *GImGui;
+		if (!g.ActiveId && !m_FilteredFileList.empty())
+		{
+			// explore
+			bool exploreByKey = false;
+			bool enterInDirectory = false;
+			bool exitDirectory = false;
+			if (ImGui::IsKeyPressed(IGFD_KEY_UP))
+			{
+				exploreByKey = true;
+				if (m_LocateFileByInputChar_lastFileIdx > 0)
+					m_LocateFileByInputChar_lastFileIdx--;
+			}
+			else if (ImGui::IsKeyPressed(IGFD_KEY_DOWN))
+			{
+				exploreByKey = true;
+				if (m_LocateFileByInputChar_lastFileIdx < m_FilteredFileList.size() - 1)
+					m_LocateFileByInputChar_lastFileIdx++;
+			}
+			else if (ImGui::IsKeyReleased(IGFD_KEY_ENTER) && ImGui::IsWindowHovered())
+			{
+				exploreByKey = true;
+				enterInDirectory = true;
+			}
+			else if (ImGui::IsKeyReleased(IGFD_KEY_BACKSPACE) && ImGui::IsWindowHovered())
+			{
+				exploreByKey = true;
+				exitDirectory = true;
+			}
+
+			if (exploreByKey)
+			{
+				//float totalHeight = m_FilteredFileList.size() * ImGui::GetTextLineHeightWithSpacing();
+				float p = (float)((double)m_LocateFileByInputChar_lastFileIdx / (double)m_FilteredFileList.size()) * ImGui::GetScrollMaxY();// seems not udpated in tables version outside tables
+				//float p = ((float)locateFileByInputChar_lastFileIdx) * ImGui::GetTextLineHeightWithSpacing();
+				ImGui::SetScrollY(p);
+				StartFlashItem(m_LocateFileByInputChar_lastFileIdx);
+
+				auto infos = &m_FilteredFileList[m_LocateFileByInputChar_lastFileIdx];
+
+				if (infos->type == 'd')
+				{
+					if (!dlg_filters.empty() || enterInDirectory)
+					{
+						if (enterInDirectory)
+						{
+							if (SelectDirectory(*infos))
+							{
+								// changement de repertoire
+								SetPath(m_CurrentPath);
+								if (m_LocateFileByInputChar_lastFileIdx > m_FilteredFileList.size() - 1)
+								{
+									m_LocateFileByInputChar_lastFileIdx = 0;
+								}
+							}
+						}
+					}
+					else // directory chooser
+					{
+						SelectFileName(*infos);
+					}
+				}
+				else
+				{
+					SelectFileName(*infos);
+				}
+
+				if (exitDirectory)
+				{
+					FileInfoStruct nfo;
+					nfo.fileName = "..";
+
+					if (SelectDirectory(nfo))
+					{
+						// changement de repertoire
+						SetPath(m_CurrentPath);
+						if (m_LocateFileByInputChar_lastFileIdx > m_FilteredFileList.size() - 1)
+						{
+							m_LocateFileByInputChar_lastFileIdx = 0;
+						}
+					}
+#ifdef WIN32
+					else
+					{
+						if (m_CurrentPath_Decomposition.size() == 1)
+						{
+							GetDrives(); // display drives
+						}
+					}
+#endif // WIN32
+				}
+			}
+		}
+	}
+
+	void IGFD::FileDialog::StartFlashItem(size_t vIdx)
+	{
+		m_FlashAlpha = 1.0f;
+		m_FlashedItem = vIdx;
+	}
+
+	bool IGFD::FileDialog::BeginFlashItem(size_t vIdx)
+	{
+		bool res = false;
+
+		if (m_FlashedItem == vIdx &&
+			std::abs(m_FlashAlpha - 0.0f) > 0.00001f)
+		{
+			m_FlashAlpha -= m_FlashAlphaAttenInSecs * ImGui::GetIO().DeltaTime;
+			if (m_FlashAlpha < 0.0f) m_FlashAlpha = 0.0f;
+
+			ImVec4 hov = ImGui::GetStyleColorVec4(ImGuiCol_HeaderHovered);
+			hov.w = m_FlashAlpha;
+			ImGui::PushStyleColor(ImGuiCol_HeaderHovered, hov);
+			res = true;
+		}
+
+		return res;
+	}
+
+	void IGFD::FileDialog::EndFlashItem()
+	{
+		ImGui::PopStyleColor();
+	}
+
+	void IGFD::FileDialog::SetFlashingAttenuationInSeconds(float vAttenValue)
+	{
+		m_FlashAlphaAttenInSecs = 1.0f / ImMax(vAttenValue, 0.01f);
+	}
+#endif // USE_EXPLORATION_BY_KEYS
+
+#ifdef USE_BOOKMARK
+
+	//////////////////////////////////////////////////////////////////////////////
+	//// BOOKMARK FEATURE ////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////
+
+	void IGFD::FileDialog::DrawBookmarkPane(ImVec2 vSize)
+	{
+		ImGui::BeginChild("##bookmarkpane", vSize);
+
+		static int selectedBookmarkForEdition = -1;
+
+		if (IMGUI_BUTTON(addBookmarkButtonString "##ImGuiFileDialogAddBookmark"))
+		{
+			if (!m_CurrentPath_Decomposition.empty())
+			{
+				BookmarkStruct bookmark;
+				bookmark.name = m_CurrentPath_Decomposition.back();
+				bookmark.path = m_CurrentPath;
+				m_Bookmarks.push_back(bookmark);
+			}
+		}
+		if (selectedBookmarkForEdition >= 0 &&
+			selectedBookmarkForEdition < (int)m_Bookmarks.size())
+		{
+			ImGui::SameLine();
+			if (IMGUI_BUTTON(removeBookmarkButtonString "##ImGuiFileDialogAddBookmark"))
+			{
+				m_Bookmarks.erase(m_Bookmarks.begin() + selectedBookmarkForEdition);
+				if (selectedBookmarkForEdition == (int)m_Bookmarks.size())
+					selectedBookmarkForEdition--;
+			}
+
+			if (selectedBookmarkForEdition >= 0 &&
+				selectedBookmarkForEdition < (int)m_Bookmarks.size())
+			{
+				ImGui::SameLine();
+
+				ImGui::PushItemWidth(vSize.x - ImGui::GetCursorPosX());
+				if (ImGui::InputText("##ImGuiFileDialogBookmarkEdit", BookmarkEditBuffer, MAX_FILE_DIALOG_NAME_BUFFER))
+				{
+					m_Bookmarks[selectedBookmarkForEdition].name = std::string(BookmarkEditBuffer);
+				}
+				ImGui::PopItemWidth();
+			}
+		}
+
+		ImGui::Separator();
+
+		if (!m_Bookmarks.empty())
+		{
+			m_BookmarkClipper.Begin((int)m_Bookmarks.size(), ImGui::GetTextLineHeightWithSpacing());
+			while (m_BookmarkClipper.Step())
+			{
+				for (int i = m_BookmarkClipper.DisplayStart; i < m_BookmarkClipper.DisplayEnd; i++)
+				{
+					if (i < 0) continue;
+					const BookmarkStruct& bookmark = m_Bookmarks[i];
+					ImGui::PushID(i);
+					if (ImGui::Selectable(bookmark.name.c_str(), selectedBookmarkForEdition == i,
+						ImGuiSelectableFlags_AllowDoubleClick) |
+						(selectedBookmarkForEdition == -1 &&
+							bookmark.path == m_CurrentPath)) // select if path is current
+					{
+						selectedBookmarkForEdition = i;
+						ResetBuffer(BookmarkEditBuffer);
+						AppendToBuffer(BookmarkEditBuffer, MAX_FILE_DIALOG_NAME_BUFFER, bookmark.name);
+
+						if (ImGui::IsMouseDoubleClicked(0)) // apply path
+						{
+							SetPath(bookmark.path);
+						}
+					}
+					ImGui::PopID();
+					if (ImGui::IsItemHovered())
+						ImGui::SetTooltip("%s", bookmark.path.c_str());
+				}
+			}
+			m_BookmarkClipper.End();
+		}
+
+		ImGui::EndChild();
+	}
+
+	std::string IGFD::FileDialog::SerializeBookmarks()
+	{
+		std::string res;
+
+		size_t idx = 0;
+		for (auto& it : m_Bookmarks)
+		{
+			if (idx++ != 0)
+				res += "##"; // ## because reserved by imgui, so an input text cant have ##
+			res += it.name + "##" + it.path;
+		}
+
+		return res;
+	}
+
+	void IGFD::FileDialog::DeserializeBookmarks(const std::string& vBookmarks)
+	{
+		if (!vBookmarks.empty())
+		{
+			m_Bookmarks.clear();
+			auto arr = splitStringToVector(vBookmarks, '#', false);
+			for (size_t i = 0; i < arr.size(); i += 2)
+			{
+				BookmarkStruct bookmark;
+				bookmark.name = arr[i];
+				if (i + 1 < arr.size()) // for avoid crash if arr size is impair due to user mistake after edition
+				{
+					// if bad format we jump this bookmark
+					bookmark.path = arr[i + 1];
+					m_Bookmarks.push_back(bookmark);
+				}
+			}
+		}
+	}
+#endif // USE_BOOKMARK
+
+	//////////////////////////////////////////////////////////////////////////////
+	//// OVERWRITE DIALOG ////////////////////////////////////////////////////////
+	//////////////////////////////////////////////////////////////////////////////
+
+	bool IGFD::FileDialog::Confirm_Or_OpenOverWriteFileDialog_IfNeeded(bool vLastAction, ImGuiWindowFlags vFlags)
+	{
+		// if confirmation => return true for confirm the overwrite et quit the dialog
+		// if cancel => return false && set IsOk to false for keep inside the dialog
+
+		// if IsOk == false => return false for quit the dialog
+		if (!m_IsOk && vLastAction)
+		{
+			return true;
+		}
+
+		// if IsOk == true && no check of overwrite => return true for confirm the dialog
+		if (m_IsOk && vLastAction && !(dlg_flags & ImGuiFileDialogFlags_ConfirmOverwrite))
+		{
+			return true;
+		}
+
+		// if IsOk == true && check of overwrite => return false and show confirm to overwrite dialog
+		if ((m_OkResultToConfirm || (m_IsOk && vLastAction)) && (dlg_flags & ImGuiFileDialogFlags_ConfirmOverwrite))
+		{
+			if (m_IsOk) // catched only one time
+			{
+				if (!IsFileExist(GetFilePathName())) // not existing => quit dialog
+				{
+					return true;
+				}
+				else // existing => confirm dialog to open
+				{
+					m_IsOk = false;
+					m_OkResultToConfirm = true;
+				}
+			}
+
+			std::string name = OverWriteDialogTitleString "##" + dlg_title + dlg_key + "OverWriteDialog";
+
+			bool res = false;
+
+			ImGui::OpenPopup(name.c_str());
+			if (ImGui::BeginPopupModal(name.c_str(), (bool*)0,
+				vFlags | ImGuiWindowFlags_AlwaysAutoResize |
+				ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove))
+			{
+				ImGui::SetWindowPos(m_DialogCenterPos - ImGui::GetWindowSize() * 0.5f); // next frame needed for GetWindowSize to work
+
+				ImGui::Text("%s", OverWriteDialogMessageString);
+
+				if (IMGUI_BUTTON(OverWriteDialogConfirmButtonString))
+				{
+					m_OkResultToConfirm = false;
+					m_IsOk = true;
+					res = true;
+					ImGui::CloseCurrentPopup();
+				}
+
+				ImGui::SameLine();
+
+				if (IMGUI_BUTTON(OverWriteDialogCancelButtonString))
+				{
+					m_OkResultToConfirm = false;
+					m_IsOk = false;
+					res = false;
+					ImGui::CloseCurrentPopup();
+				}
+
+				ImGui::EndPopup();
+			}
+
+			return res;
+		}
+
+
+		return false;
+	}
+
+	bool IGFD::FileDialog::IsFileExist(const std::string& vFile)
+	{
+		std::ifstream docFile(vFile, std::ios::in);
+		if (docFile.is_open())
+		{
+			docFile.close();
+			return true;
+		}
+		return false;
+	}
+}
+
+#endif // __cplusplus
+
+/////////////////////////////////////////////////////////////////
+///// C Interface ///////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////
+
+// Return an initialized IGFD_Selection_Pair
+IMGUIFILEDIALOG_API IGFD_Selection_Pair IGFD_Selection_Pair_Get(void)
+{
+	IGFD_Selection_Pair res;
+	res.fileName = 0;
+	res.filePathName = 0;
+	return res;
+}
+
+// destroy only the content of vSelection_Pair
+IMGUIFILEDIALOG_API void IGFD_Selection_Pair_DestroyContent(IGFD_Selection_Pair* vSelection_Pair)
+{
+	if (vSelection_Pair)
+	{
+		if (vSelection_Pair->fileName)
+			delete[] vSelection_Pair->fileName;
+		if (vSelection_Pair->filePathName)
+			delete[] vSelection_Pair->filePathName;
+	}
+}
+
+// Return an initialized IGFD_Selection
+IMGUIFILEDIALOG_API IGFD_Selection IGFD_Selection_Get(void)
+{
+	return { 0, 0U };
+}
+
+// destroy only the content of vSelection
+IMGUIFILEDIALOG_API void IGFD_Selection_DestroyContent(IGFD_Selection* vSelection)
+{
+	if (vSelection)
+	{
+		if (vSelection->table)
+		{
+			for (size_t i = 0U; i < vSelection->count; i++)
+			{
+				IGFD_Selection_Pair_DestroyContent(&vSelection->table[i]);
+			}
+			delete[] vSelection->table;
+		}
+		vSelection->count = 0U;
+	}
+}
+
+// create an instance of ImGuiFileDialog
+IMGUIFILEDIALOG_API ImGuiFileDialog* IGFD_Create(void)
+{
+	return new ImGuiFileDialog();
+}
+
+// destroy the instance of ImGuiFileDialog
+IMGUIFILEDIALOG_API void IGFD_Destroy(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		delete vContext;
+		vContext = nullptr;
+	}
+}
+
+// standard dialog
+IMGUIFILEDIALOG_API void IGFD_OpenDialog(
+	ImGuiFileDialog* vContext,
+	const char* vKey, 
+	const char* vTitle, 
+	const char* vFilters, 
+	const char* vPath,
+	const char* vFileName, 
+	const int vCountSelectionMax, 
+	void* vUserDatas, 
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenDialog(
+			vKey, vTitle, vFilters, vPath, vFileName,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenDialog2(
+	ImGuiFileDialog* vContext,
+	const char* vKey, 
+	const char* vTitle, 
+	const char* vFilters, 
+	const char* vFilePathName,
+	const int vCountSelectionMax, 
+	void* vUserDatas, 
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenDialog(
+			vKey, vTitle, vFilters, vFilePathName,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenPaneDialog(
+	ImGuiFileDialog* vContext,
+	const char* vKey, 
+	const char* vTitle, 
+	const char* vFilters, 
+	const char* vPath,
+	const char* vFileName, 
+	IGFD_PaneFun vSidePane, 
+	const float vSidePaneWidth,
+	const int vCountSelectionMax, 
+	void* vUserDatas, 
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenDialog(
+			vKey, vTitle, vFilters, 
+			vPath, vFileName,
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenPaneDialog2(
+	ImGuiFileDialog* vContext,
+	const char* vKey, 
+	const char* vTitle, 
+	const char* vFilters, 
+	const char* vFilePathName, 
+	IGFD_PaneFun vSidePane, 
+	const float vSidePaneWidth,
+	const int vCountSelectionMax, 
+	void* vUserDatas, 
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenDialog(
+			vKey, vTitle, vFilters, 
+			vFilePathName,
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+// modal dialog
+IMGUIFILEDIALOG_API void IGFD_OpenModal(
+	ImGuiFileDialog* vContext,
+	const char* vKey,
+	const char* vTitle,
+	const char* vFilters,
+	const char* vPath,
+	const char* vFileName,
+	const int vCountSelectionMax,
+	void* vUserDatas,
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenModal(
+			vKey, vTitle, vFilters, vPath, vFileName,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenModal2(
+	ImGuiFileDialog* vContext,
+	const char* vKey,
+	const char* vTitle,
+	const char* vFilters,
+	const char* vFilePathName,
+	const int vCountSelectionMax,
+	void* vUserDatas,
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenModal(
+			vKey, vTitle, vFilters, vFilePathName,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenPaneModal(
+	ImGuiFileDialog* vContext,
+	const char* vKey,
+	const char* vTitle,
+	const char* vFilters,
+	const char* vPath,
+	const char* vFileName,
+	IGFD_PaneFun vSidePane,
+	const float vSidePaneWidth,
+	const int vCountSelectionMax,
+	void* vUserDatas,
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenModal(
+			vKey, vTitle, vFilters,
+			vPath, vFileName,
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_OpenPaneModal2(
+	ImGuiFileDialog* vContext,
+	const char* vKey,
+	const char* vTitle,
+	const char* vFilters,
+	const char* vFilePathName,
+	IGFD_PaneFun vSidePane,
+	const float vSidePaneWidth,
+	const int vCountSelectionMax,
+	void* vUserDatas,
+	ImGuiFileDialogFlags flags)
+{
+	if (vContext)
+	{
+		vContext->OpenDialog(
+			vKey, vTitle, vFilters,
+			vFilePathName,
+			vSidePane, vSidePaneWidth,
+			vCountSelectionMax, vUserDatas, flags);
+	}
+}
+
+IMGUIFILEDIALOG_API bool IGFD_DisplayDialog(ImGuiFileDialog* vContext, 
+	const char* vKey, ImGuiWindowFlags vFlags, ImVec2 vMinSize, ImVec2 vMaxSize)
+{
+	if (vContext)
+	{
+		return vContext->Display(vKey, vFlags, vMinSize, vMaxSize);
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API void IGFD_CloseDialog(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		vContext->Close();
+	}
+}
+
+IMGUIFILEDIALOG_API bool IGFD_IsOk(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		return vContext->IsOk();
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API bool IGFD_WasKeyOpenedThisFrame(ImGuiFileDialog* vContext, 
+	const char* vKey)
+{
+	if (vContext)
+	{
+		vContext->WasOpenedThisFrame(vKey);
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API bool IGFD_WasOpenedThisFrame(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		vContext->WasOpenedThisFrame();
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API bool IGFD_IsKeyOpened(ImGuiFileDialog* vContext, 
+	const char* vCurrentOpenedKey)
+{
+	if (vContext)
+	{
+		vContext->IsOpened(vCurrentOpenedKey);
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API bool IGFD_IsOpened(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		vContext->IsOpened();
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API IGFD_Selection IGFD_GetSelection(ImGuiFileDialog* vContext)
+{
+	IGFD_Selection res = IGFD_Selection_Get();
+
+	if (vContext)
+	{
+		auto sel = vContext->GetSelection();
+		if (!sel.empty())
+		{
+			res.count = sel.size();
+			res.table = new IGFD_Selection_Pair[res.count];
+
+			size_t idx = 0U;
+			for (auto s : sel)
+			{
+				IGFD_Selection_Pair* pair = res.table + idx++;
+
+				// fileName
+				if (!s.first.empty())
+				{
+					size_t siz = s.first.size() + 1U;
+					pair->fileName = new char[siz];
+#ifndef MSVC
+					strncpy(pair->fileName, s.first.c_str(), siz);
+#else
+					strncpy_s(pair->fileName, siz, s.first.c_str(), siz);
+#endif
+					pair->fileName[siz - 1U] = '\0';
+				}
+
+				// filePathName
+				if (!s.second.empty())
+				{
+					size_t siz = s.first.size() + 1U;
+					pair->filePathName = new char[siz];
+#ifndef MSVC
+					strncpy(pair->filePathName, s.first.c_str(), siz);
+#else
+					strncpy_s(pair->filePathName, siz, s.first.c_str(), siz);
+#endif
+					pair->filePathName[siz - 1U] = '\0';
+				}
+			}
+
+			return res;
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API char* IGFD_GetFilePathName(ImGuiFileDialog* vContext)
+{
+	char* res = 0;
+
+	if (vContext)
+	{
+		auto s = vContext->GetFilePathName();
+		if (!s.empty())
+		{
+			size_t siz = s.size() + 1U;
+			res = new char[siz];
+#ifndef MSVC
+			strncpy(res, s.c_str(), siz);
+#else
+			strncpy_s(res, siz, s.c_str(), siz);
+#endif
+			res[siz - 1U] = '\0';
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API char* IGFD_GetCurrentFileName(ImGuiFileDialog* vContext)
+{
+	char* res = 0;
+
+	if (vContext)
+	{
+		auto s = vContext->GetCurrentFileName();
+		if (!s.empty())
+		{
+			size_t siz = s.size() + 1U;
+			res = new char[siz];
+#ifndef MSVC
+			strncpy(res, s.c_str(), siz);
+#else
+			strncpy_s(res, siz, s.c_str(), siz);
+#endif
+			res[siz - 1U] = '\0';
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API char* IGFD_GetCurrentPath(ImGuiFileDialog* vContext)
+{
+	char* res = 0;
+
+	if (vContext)
+	{
+		auto s = vContext->GetCurrentPath();
+		if (!s.empty())
+		{
+			size_t siz = s.size() + 1U;
+			res = new char[siz];
+#ifndef MSVC
+			strncpy(res, s.c_str(), siz);
+#else
+			strncpy_s(res, siz, s.c_str(), siz);
+#endif
+			res[siz - 1U] = '\0';
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API char* IGFD_GetCurrentFilter(ImGuiFileDialog* vContext)
+{
+	char* res = 0;
+
+	if (vContext)
+	{
+		auto s = vContext->GetCurrentFilter();
+		if (!s.empty())
+		{
+			size_t siz = s.size() + 1U;
+			res = new char[siz];
+#ifndef MSVC
+			strncpy(res, s.c_str(), siz);
+#else
+			strncpy_s(res, siz, s.c_str(), siz);
+#endif
+			res[siz - 1U] = '\0';
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API void* IGFD_GetUserDatas(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		return vContext->GetUserDatas();
+	}
+
+	return nullptr;
+}
+
+IMGUIFILEDIALOG_API void IGFD_SetExtentionInfos(ImGuiFileDialog* vContext,
+	const char* vFilter, ImVec4 vColor, const char* vIcon)
+{
+	if (vContext)
+	{
+		vContext->SetExtentionInfos(vFilter, vColor, vIcon);
+	}
+}
+
+IMGUIFILEDIALOG_API void IGFD_SetExtentionInfos2(ImGuiFileDialog* vContext,
+	const char* vFilter, float vR, float vG, float vB, float vA, const char* vIcon)
+{
+	if (vContext)
+	{
+		vContext->SetExtentionInfos(vFilter, ImVec4(vR, vG, vB, vA), vIcon);
+	}
+}
+
+IMGUIFILEDIALOG_API bool IGFD_GetExtentionInfos(ImGuiFileDialog* vContext,
+	const char* vFilter, ImVec4* vOutColor, char** vOutIcon)
+{
+	if (vContext)
+	{
+		std::string icon;
+		bool res = vContext->GetExtentionInfos(vFilter, vOutColor, &icon);
+		if (!icon.empty() && vOutIcon)
+		{
+			size_t siz = icon.size() + 1U;
+			*vOutIcon = new char[siz];
+#ifndef MSVC
+			strncpy(*vOutIcon, icon.c_str(), siz);
+#else
+			strncpy_s(*vOutIcon, siz, icon.c_str(), siz);
+#endif
+			*vOutIcon[siz - 1U] = '\0';
+		}
+		return res;
+	}
+
+	return false;
+}
+
+IMGUIFILEDIALOG_API void IGFD_ClearExtentionInfos(ImGuiFileDialog* vContext)
+{
+	if (vContext)
+	{
+		vContext->ClearExtentionInfos();
+	}
+}
+
+#ifdef USE_EXPLORATION_BY_KEYS
+IMGUIFILEDIALOG_API void IGFD_SetFlashingAttenuationInSeconds(ImGuiFileDialog* vContext, float vAttenValue)
+{
+	if (vContext)
+	{
+		vContext->SetFlashingAttenuationInSeconds(vAttenValue);
+	}
+}
+#endif
+
+#ifdef USE_BOOKMARK
+IMGUIFILEDIALOG_API char* IGFD_SerializeBookmarks(ImGuiFileDialog* vContext)
+{
+	char *res = 0;
+	
+	if (vContext)
+	{
+		auto s = vContext->SerializeBookmarks();
+		if (!s.empty())
+		{
+			size_t siz = s.size() + 1U;
+			res = new char[siz];
+#ifndef MSVC
+			strncpy(res, s.c_str(), siz);
+#else
+			strncpy_s(res, siz, s.c_str(), siz);
+#endif
+			res[siz - 1U] = '\0';
+		}
+	}
+
+	return res;
+}
+
+IMGUIFILEDIALOG_API void IGFD_DeserializeBookmarks(ImGuiFileDialog* vContext, const char* vBookmarks)
+{
+	if (vContext)
+	{
+		vContext->DeserializeBookmarks(vBookmarks);
+	}
+}
+#endif
\ No newline at end of file