#include <DirectoryWindow.h>

Collaboration diagram for DirectoryWindow:

Classes
struct	ImageData

Public Member Functions
	DirectoryWindow (std::string directoryPath, std::string directoryName, DirectoryKind kind_)

std::string	TruncateString (const std::string &str, size_t maxLength)

void	generateTextureIDs ()

void	renderDirectory ()

ImageData	getSelectedImage () const

void	clearSelectedImage ()

void	startMonitoring ()

void	stopMonitoring ()

	~DirectoryWindow ()

ImageData	getImageByPath (const std::string &file_name)

float	getGlobalSizeSlider ()

void	applyPendingAssetChanges ()

Public Attributes
std::string	directoryPath

std::string	directoryName

Private Member Functions
std::vector< ImageData >::iterator	findImageByFilename (std::vector< ImageData > &images, const std::string &filename)

void	monitorDirectory (const std::string &path)

ImageData	LoadTextureFromFile (const char *path)

Private Attributes
ImageData	selected_image = {0, glm::vec2(), ""}

std::vector< ImageData >	images

std::thread	monitorThread

std::atomic< bool >	running {true}

std::atomic< bool >	first_scan_done {true}

std::shared_mutex	imagesMutex

DirectoryKind	kind_

float	global_size_slider = 1.0f

float	imageSize = 128.0f

std::mutex	pendingMtx

std::vector< std::string >	pendingRemovals

std::vector< std::pair< std::string, std::string > >	pendingAddPaths

Detailed Description

Definition at line 21 of file DirectoryWindow.h.

Constructor & Destructor Documentation

◆ DirectoryWindow()

DirectoryWindow::DirectoryWindow	(	std::string	directoryPath,
		std::string	directoryName,
		DirectoryKind	kind_ )

inline

Definition at line 24 of file DirectoryWindow.h.

    {
        this->directoryPath = directoryPath;
        this->directoryName = directoryName;
        this->kind_ = kind_;
    }

◆ ~DirectoryWindow()

DirectoryWindow::~DirectoryWindow ( )

inline

Definition at line 224 of file DirectoryWindow.h.

    {
        stopMonitoring();
    }

Here is the call graph for this function:

Member Function Documentation

◆ applyPendingAssetChanges()

void DirectoryWindow::applyPendingAssetChanges ( )

inline

Definition at line 257 of file DirectoryWindow.h.

    {
        // 1) Steal queues quickly (minimize lock time)
        std::vector<std::string> removals;
        std::vector<std::pair<std::string, std::string>> adds;
        {
            std::lock_guard<std::mutex> qlk(pendingMtx);
            removals.swap(pendingRemovals);
            adds.swap(pendingAddPaths);
        }
 
        // 2) Process removals (GL-safe thread)
        if (!removals.empty())
        {
            std::unique_lock<std::shared_mutex> lk(imagesMutex);
            for (const auto& fname : removals)
            {
                auto it = std::find_if(images.begin(), images.end(),
                                       [&](const ImageData& im)
                                       { return im.filename == fname; });
                if (it != images.end())
                {
                    if (it->textureID != 0)
                        glDeleteTextures(1, &it->textureID);
                    images.erase(it);
                }
                // else: already gone — ignore
            }
        }
 
        // 3) Process additions (load textures here; GL-safe thread)
        if (!adds.empty())
        {
            std::vector<ImageData> toInsert;
            toInsert.reserve(adds.size());
 
            for (auto& [fname, fullpath] : adds)
            {
                // Optional: wait briefly if file is still being copied
                bool ready = false;
                for (int i = 0; i < 10; ++i)
                {
                    std::ifstream f(fullpath, std::ios::binary);
                    if (f.good())
                    {
                        ready = true;
                        break;
                    }
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                }
                if (!ready)
                    continue;
 
                // Use your existing loader (returns ImageData with texture + size)
                ImageData img = LoadTextureFromFile(fullpath.c_str());
                if (img.textureID != 0)
                {
                    img.filename = fname; // store filename (not full path) for matching
                    toInsert.emplace_back(std::move(img));
                }
            }
 
            if (!toInsert.empty())
            {
                std::unique_lock<std::shared_mutex> lk(imagesMutex);
                for (auto& im : toInsert)
                {
                    // Avoid duplicates
                    auto it = std::find_if(images.begin(), images.end(),
                                           [&](const ImageData& x)
                                           { return x.filename == im.filename; });
                    if (it == images.end())
                        images.emplace_back(std::move(im));
                }
            }
        }
    }

◆ clearSelectedImage()

void DirectoryWindow::clearSelectedImage ( )

inline

Definition at line 205 of file DirectoryWindow.h.

    {
        selected_image = {0, glm::vec2(), ""}; // Limpa a seleção
    }

◆ findImageByFilename()

std::vector< ImageData >::iterator DirectoryWindow::findImageByFilename	(	std::vector< ImageData > &	images,
		const std::string &	filename )

inlineprivate

Definition at line 350 of file DirectoryWindow.h.

    {
        return std::find_if(images.begin(), images.end(), [&filename](const ImageData& image)
                            { return image.filename == filename; });
    }

◆ generateTextureIDs()

void DirectoryWindow::generateTextureIDs ( )

inline

Definition at line 49 of file DirectoryWindow.h.

    {
        // Wait for the monitoring thread to finish one full loop
        //{
        //    std::shared_lock<std::shared_mutex> lock(imagesMutex);  // Shared lock: waits if the thread is still writing
        //    if (!first_scan_done) {
        //        lock.unlock();
        //        std::this_thread::sleep_for(std::chrono::milliseconds(100));  // Wait and retry
        //        generateTextureIDs();  // Retry generating textures
        //        return;
        //    }
        //}
 
        while (true)
        {
            {
                std::shared_lock<std::shared_mutex> lock(imagesMutex);
                if (first_scan_done)
                    break;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
 
        // Now generate textures
        std::unique_lock<std::shared_mutex> lock(imagesMutex); // Unique lock to write (generate textures)
        for (auto& image : images)
        {
            if (image.textureID == 0)
            {
                std::string path_file = directoryPath + "\\" + image.filename;
                image = LoadTextureFromFile(path_file.c_str());
            }
        }
    }

Here is the call graph for this function:

◆ getGlobalSizeSlider()

float DirectoryWindow::getGlobalSizeSlider ( )

inline

Definition at line 249 of file DirectoryWindow.h.

    {
        return global_size_slider;
    }

◆ getImageByPath()

ImageData DirectoryWindow::getImageByPath ( const std::string & file_name )

inline

Definition at line 229 of file DirectoryWindow.h.

    {
        auto it = std::find_if(images.begin(), images.end(), [&](const ImageData& image)
                               {
            // Check if image.filename is a substring at the end of file_name
            if (file_name.size() >= image.filename.size()) {
                return file_name.compare(file_name.size() - image.filename.size(), image.filename.size(), image.filename) == 0;
            }
            return false; });
 
        if (it != images.end())
        {
            return *it;
        }
        else
        {
            throw std::runtime_error("Image not found: " + file_name);
        }
    }

◆ getSelectedImage()

ImageData DirectoryWindow::getSelectedImage ( ) const

inline

Definition at line 199 of file DirectoryWindow.h.

    {
        return selected_image;
    }

◆ LoadTextureFromFile()

ImageData DirectoryWindow::LoadTextureFromFile ( const char * path )

inlineprivate

Definition at line 411 of file DirectoryWindow.h.

    {
 
        // Record the start time using std::chrono::high_resolution_clock
        //std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
 
        int width, height, nrChannels;
        unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 4);
        stbi_set_flip_vertically_on_load(0); // Flip images vertically if needed
        if (!data)
        {
            std::cerr << "Failed to load texture: " << path << std::endl;
            return ImageData(0, glm::vec2(), "");
        }
 
        GLuint textureID[1];
        glGenTextures(1, textureID);
        glBindTexture(GL_TEXTURE_2D, textureID[0]);
 
        // Set the texture data
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
 
        GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
        stbi_image_free(data);
 
        // Record the end time using std::chrono::high_resolution_clock
        //std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
 
        // Calculate the duration in milliseconds
        //std::chrono::seconds duration = std::chrono::duration_cast<std::chrono::seconds>(end - start);
 
        // Output the duration in milliseconds
        //std::cout << "Operation for file "<< path <<"took " << duration.count() << " seconds" << std::endl;
 
        return ImageData(textureID[0], glm::vec2(width, height), path);
    }

Here is the caller graph for this function:

◆ monitorDirectory()

void DirectoryWindow::monitorDirectory ( const std::string & path )

inlineprivate

Definition at line 356 of file DirectoryWindow.h.

    {
        using namespace std::chrono_literals;
 
        // Keep only a simple "known file list" of filenames (no GL/state here)
        std::vector<std::string> knownFiles;
 
        while (running.load(std::memory_order_relaxed))
        {
            std::vector<std::string> currentFiles;
            try
            {
                for (const auto& entry : std::filesystem::directory_iterator(path))
                {
                    if (entry.is_regular_file())
                    {
                        currentFiles.push_back(entry.path().filename().string());
                    }
                }
            }
            catch (const std::filesystem::filesystem_error& e)
            {
                std::cerr << "[DirectoryWindow] Filesystem error: " << e.what() << std::endl;
            }
 
            // Diff: removed = known - current
            for (const auto& name : knownFiles)
            {
                if (std::find(currentFiles.begin(), currentFiles.end(), name) == currentFiles.end())
                {
                    std::lock_guard<std::mutex> qlk(pendingMtx);
                    pendingRemovals.emplace_back(name);
                }
            }
 
            // Diff: added = current - known
            for (const auto& name : currentFiles)
            {
                if (std::find(knownFiles.begin(), knownFiles.end(), name) == knownFiles.end())
                {
                    const std::string full = (std::filesystem::path(path) / name).string();
                    std::lock_guard<std::mutex> qlk(pendingMtx);
                    pendingAddPaths.emplace_back(name, full);
                }
            }
 
            knownFiles = std::move(currentFiles);
 
            // First pass complete → allow generateTextureIDs() to proceed
            first_scan_done = true;
 
            std::this_thread::sleep_for(2s);
        }
    }

Here is the caller graph for this function:

◆ renderDirectory()

void DirectoryWindow::renderDirectory ( )

inline

Definition at line 84 of file DirectoryWindow.h.

    {
        ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoCollapse;
        if (kind_ == DirectoryKind::MAP)
        {
            window_flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize;
        }
 
        ImGui::SetNextWindowSizeConstraints(ImVec2(ImGui::GetIO().DisplaySize.x * 0.1, ImGui::GetIO().DisplaySize.y * 0.1), ImVec2(ImGui::GetIO().DisplaySize.x - 200, ImGui::GetIO().DisplaySize.y));
        ImGui::Begin(directoryName.c_str(), NULL, window_flags);
        ImGui::Text("Path: %s", directoryPath.c_str());
 
        // --- Fixed header (no scrolling) ---
        if (kind_ == DirectoryKind::MARKER)
        {
            float minScale = 0.10f, maxScale = 10.0f;
            ImGui::Separator();
            ImGui::TextUnformatted("Default Marker Size Scale");
            ImGui::SameLine();
            ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
            if (ImGui::SliderFloat("##marker_size_slider", &global_size_slider, minScale, maxScale, "x%.2f"))
            {
                // Clamp just in case
                if (global_size_slider < minScale)
                    global_size_slider = minScale;
                if (global_size_slider > maxScale)
                    global_size_slider = maxScale;
            }
        }
 
        ImGui::Separator();
 
        float minScale = 25.0f, maxScale = 550.0f;
        ImGui::Separator();
        ImGui::TextUnformatted("Directory Thumb Pixel Size");
        ImGui::SameLine();
        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
        if (ImGui::SliderFloat("##image_size_slider", &imageSize, minScale, maxScale, "x%.2f"))
        {
            // Clamp just in case
            if (imageSize < minScale)
                imageSize = minScale;
            if (imageSize > maxScale)
                imageSize = maxScale;
        }
 
        ImGui::Separator();
 
        ImGui::BeginChild("DirectoryScrollRegion", ImVec2(0, 0), true, ImGuiWindowFlags_HorizontalScrollbar);
        float window_width = ImGui::GetWindowWidth();
        ImVec2 content_region = ImGui::GetContentRegionAvail();
        int columns = (int)(content_region.x / imageSize);
        if (columns <= 0)
            columns = 1;
        int count = 0;
        {
 
            std::shared_lock<std::shared_mutex> lock(imagesMutex);
            for (auto& image : images)
            {
                if (count % columns != 0)
                    ImGui::SameLine();
                std::string path_file = directoryPath + "\\" + image.filename.c_str();
                if (image.textureID == 0)
                {
                    image = LoadTextureFromFile(path_file.c_str());
                }
 
                ImGui::BeginGroup();
                ImGui::PushID(count);
 
                if (kind_ == DirectoryKind::MARKER)
                {
                    // Add drag-and-drop functionality for marker images
                    if (ImGui::ImageButton((void*)(intptr_t)image.textureID, ImVec2(imageSize, imageSize)))
                    {
                        selected_image = image;
                        std::cout << "Selected Image: " << image.filename << " | " << image.textureID << std::endl;
                        ImGui::OpenPopup("Image Popup");
                    }
 
                    // Begin the drag source for the markers
                    if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceAllowNullID))
                    {
                        ImGui::SetDragDropPayload("MARKER_IMAGE", &image, sizeof(image)); // Attach the marker image payload
                        ImGui::Text("Drag Marker: %s", image.filename.c_str());           // Tooltip while dragging
                        ImGui::EndDragDropSource();
                    }
                }
                else
                {
                    if (ImGui::ImageButton((void*)(intptr_t)image.textureID, ImVec2(imageSize, imageSize)))
                    {
                        selected_image = image;
                        std::cout << "Selected Image: " << image.filename << " | " << image.textureID << std::endl;
                        ImGui::OpenPopup("Image Popup");
                    }
 
                    if (ImGui::BeginPopup("Image Popup"))
                    {
                        ImGui::Text("File: %s", image.filename.c_str());
                        ImGui::EndPopup();
                    }
                }
                ImGui::TextWrapped("%s", TruncateString(image.filename.c_str(), 16).c_str());
                ImGui::PopID();
                ImGui::EndGroup();
                count++;
            }
        }
        ImGui::EndChild();
        ImGui::End();
    }

Here is the call graph for this function:

◆ startMonitoring()

void DirectoryWindow::startMonitoring ( )

inline

Definition at line 210 of file DirectoryWindow.h.

    {
        monitorThread = std::thread(&DirectoryWindow::monitorDirectory, this, directoryPath);
    }

Here is the call graph for this function:

◆ stopMonitoring()

void DirectoryWindow::stopMonitoring ( )

inline

Definition at line 215 of file DirectoryWindow.h.

    {
        running.exchange(false, std::memory_order_relaxed);
        if (monitorThread.joinable())
        {
            monitorThread.join();
        }
    }

Here is the caller graph for this function:

◆ TruncateString()

std::string DirectoryWindow::TruncateString	(	const std::string &	str,
		size_t	maxLength )

inline

Definition at line 39 of file DirectoryWindow.h.

    {
        if (str.length() > maxLength)
        {
            return str.substr(0, maxLength) + "...";
        }
        return str;
    }

Here is the caller graph for this function:

Member Data Documentation

◆ directoryName

std::string DirectoryWindow::directoryName

Definition at line 255 of file DirectoryWindow.h.

◆ directoryPath

std::string DirectoryWindow::directoryPath

Definition at line 254 of file DirectoryWindow.h.

◆ first_scan_done

std::atomic<bool> DirectoryWindow::first_scan_done {true}

private

Definition at line 340 of file DirectoryWindow.h.

340{true};

◆ global_size_slider

float DirectoryWindow::global_size_slider = 1.0f

private

Definition at line 343 of file DirectoryWindow.h.

◆ images

std::vector<ImageData> DirectoryWindow::images

private

Definition at line 337 of file DirectoryWindow.h.

◆ imageSize

float DirectoryWindow::imageSize = 128.0f

private

Definition at line 344 of file DirectoryWindow.h.

◆ imagesMutex

std::shared_mutex DirectoryWindow::imagesMutex

private

Definition at line 341 of file DirectoryWindow.h.

◆ kind_

DirectoryKind DirectoryWindow::kind_

private

Definition at line 342 of file DirectoryWindow.h.

◆ monitorThread

std::thread DirectoryWindow::monitorThread

private

Definition at line 338 of file DirectoryWindow.h.

◆ pendingAddPaths

std::vector<std::pair<std::string, std::string> > DirectoryWindow::pendingAddPaths

private

Definition at line 347 of file DirectoryWindow.h.

◆ pendingMtx

std::mutex DirectoryWindow::pendingMtx

private

Definition at line 345 of file DirectoryWindow.h.

◆ pendingRemovals

std::vector<std::string> DirectoryWindow::pendingRemovals

private

Definition at line 346 of file DirectoryWindow.h.

◆ running

std::atomic<bool> DirectoryWindow::running {true}

private

Definition at line 339 of file DirectoryWindow.h.

339{true};

◆ selected_image

ImageData DirectoryWindow::selected_image = {0, glm::vec2(), ""}

private

Definition at line 336 of file DirectoryWindow.h.

336{0, glm::vec2(), ""}; // Armazena a imagem selecionada

The documentation for this class was generated from the following file:

include/DirectoryWindow.h

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DirectoryWindow()

◆ ~DirectoryWindow()

Member Function Documentation

◆ applyPendingAssetChanges()

◆ clearSelectedImage()

◆ findImageByFilename()

◆ generateTextureIDs()

◆ getGlobalSizeSlider()

◆ getImageByPath()

◆ getSelectedImage()

◆ LoadTextureFromFile()

◆ monitorDirectory()

◆ renderDirectory()

◆ startMonitoring()

◆ stopMonitoring()

◆ TruncateString()

Member Data Documentation

◆ directoryName

◆ directoryPath

◆ first_scan_done

◆ global_size_slider

◆ images

◆ imageSize

◆ imagesMutex

◆ kind_

◆ monitorThread

◆ pendingAddPaths

◆ pendingMtx

◆ pendingRemovals

◆ running

◆ selected_image