Hane/ImGuiFilePicker
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
ImGuiFilePicker/main.cpp

584 lines
23 KiB
C++
Raw Blame History

// Dear ImGui: standalone example application for GLFW + OpenGL 3, using programmable pipeline
// (GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan/Metal graphics context creation, etc.)
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#define IMGUI_IMPLEMENTATION
#define GL_SILENCE_DEPRECATION
#define log_debugc(str, ...) do { if (debug) fprintf(stdout, "[DEBUG] (%s:%d): " (str) "\n", __FILE__, __LINE__, ##__VA_ARGS__); } while (0)
#define log_debugcpp(str) do { \
if (debug) std::cout << "[DEBUG]" << "(" << __FILE__ << ":" << __LINE__ << "): " << (str) << std::endl; \
} while (0)
#define log_directory(str) if(debugVerbosity & DEBUG_DIRECTORY) log_debugcpp((str))
#define log_volume(str) if(debugVerbosity & DEBUG_VOLUME) log_debugcpp((str))
#define log_extension(str) if(debugVerbosity & DEBUG_EXTENSION) log_debugcpp((str))
#define MAX_LISTDIR_PATH_LENGTH (MAX_PATH - 3)
#include "imgui/misc/single_file/imgui_single_file.h"
#include <iostream>
#include <vector>
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
// [Win32] Our example includes a copy of glfw3.lib pre-compiled with VS2010 to maximize ease of testing and compatibility with old VS compilers.
// To link with VS2010-era libraries, VS2015+ requires linking with legacy_stdio_definitions.lib, which we do using this pragma.
// Your own project should not be affected, as you are likely to link with a newer binary of GLFW that is adequate for your version of Visual Studio.
#if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS)
#pragma comment(lib, "legacy_stdio_definitions")
#endif
static void glfw_error_callback(int error, const char* description)
{
fprintf(stderr, "Glfw Error %d: %s\n", error, description);
}
bool debug = true;
// int debugVerbosity = 0;
// enum enumDebugVerbosity {
// DEBUG_DIRECTORY = (1<<0),
// DEBUG_VOLUME = (1<<1),
// DEBUG_EXTENSION = (1<<2)
// };
// debugVerbosity = DEBUG_DIRECTORY | DEBUG_EXTENSION;
// debugVerbosity &= ~DEBUG_DIRECTORY;
// if (debugVerbosity & (DEBUG_DIRECTORY | DEBUG_EXTENSION));
typedef struct {
long long size;
//TODO yel spacsio NELLA MEMoria
TCHAR name[MAX_LISTDIR_PATH_LENGTH];
SYSTEMTIME createTime;
SYSTEMTIME lastAccessTime;
SYSTEMTIME lastWriteTime;
bool isFile;
bool isHidden;
} directoriesInfo;
//TODO UNICORDEO
/* FILE PICKER MOMENTO */
/* PROPOSITO GENERAL */
bool compareLastChar(std::vector<std::string> *lastCharCandidates, char* string){
bool matchingExtension = false;
for (int i = 0; i < lastCharCandidates->size(); i++){
log_debugcpp(lastCharCandidates->at(i) + " <- FILTERING EXTENSION");
if(strlen(string) < lastCharCandidates->at(i).length()) continue;
char* potentialExtension = &string[strlen(string) - lastCharCandidates->at(i).length()];
log_debugcpp(potentialExtension);
log_debugcpp(" LEN " + std::to_string(strlen(potentialExtension)) + " <- VS -> " + lastCharCandidates->at(i) + " LEN " + std::to_string(lastCharCandidates->at(i).length()));
//+ strlen(potentialExtension) + std::to_string(lastCharCandidates->at(i).length())
if(!strcmp(potentialExtension, lastCharCandidates->at(i).c_str())) {
log_debugcpp("VALID EXTENSION");
matchingExtension = true;
}
}
return matchingExtension;
}
/* DIRECTORIES */
bool retrieveCurrentDirectory(char** currentPath){
if(GetCurrentDirectory(MAX_PATH, *currentPath)) return true;
return false;
}
bool moveDirectory(char** currentPath){
log_debugcpp(*currentPath);
if(SetCurrentDirectory(*currentPath)) return true;
return false;
}
int listDirectory(std::string path, std::vector<directoriesInfo*> *directoryContents){
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATA ffd;
LARGE_INTEGER filesize;
int numFiles = 0;
if (path.length() > (MAX_LISTDIR_PATH_LENGTH)) return -1;
path = path + "\\*";
hFind = FindFirstFile(path.c_str(), &ffd);
if (INVALID_HANDLE_VALUE == hFind) return -2;
do {
if(!strcmp(ffd.cFileName, ".") || !strcmp(ffd.cFileName, "..")) continue;
log_debugcpp("BUCLE listDirectory iteracion " + std::to_string(numFiles));
directoriesInfo* itemInfo;
if (directoryContents->size() <= numFiles){
itemInfo = new directoriesInfo();
directoryContents->push_back(itemInfo);
} else {
itemInfo = directoryContents->at(numFiles);
}
log_debugcpp("MEMORY ASSIGNES iteration " + std::to_string(numFiles));
//A registrar info, fiera
itemInfo->isFile = (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? true : false;
itemInfo->isHidden = (ffd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? true : false;
//Tamaño
filesize.QuadPart = ((ffd.nFileSizeHigh * (MAXDWORD+1)) + ffd.nFileSizeLow);
itemInfo->size = filesize.QuadPart;
//Fechitssss
FileTimeToSystemTime(&ffd.ftCreationTime, &itemInfo->createTime);
FileTimeToSystemTime(&ffd.ftLastAccessTime, &itemInfo->lastAccessTime);
FileTimeToSystemTime(&ffd.ftLastWriteTime, &itemInfo->lastWriteTime);
//Nombre de la cosita
uint64_t idx = 0;
do {
itemInfo->name[idx] = ffd.cFileName[idx];
idx++;
} while (ffd.cFileName[idx]);
itemInfo->name[idx] = '\0';
log_debugcpp("INFORMACION ALMACENADA iteracion " + std::to_string(numFiles));
numFiles++;
} while (FindNextFile(hFind, &ffd) != 0);
FindClose(hFind);
return numFiles;
}
/* VOLUMES */
//new char*[CharCount * sizeof(WCHAR)
/*idea, si quisiera que empezase en punto X del string
coger el param opcional y crear un puntero a la posicion X del array para empezar desde ahi
int explodePaths(TCHAR* volumePaths, int volumePathLength, int volumePathBufferSize,
char separator, std::vector<char*> *dest, , int startingFrom = 0);
if (nextOcurrence == NULL) return 0;
*/
int explodePaths(TCHAR* volumePaths, int volumePathsBufferSize, char separator, std::vector<char*> *dest, int depth = 1){
//Por alguna razon esta puta mierda que dice acabar con 2 NULL acaba con 3; de locos.
//https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getvolumepathnamesforvolumenamew
char* nextOcurrence = strchr(volumePaths, separator);
char* itemPath;
itemPath = (char*)calloc(1, volumePathsBufferSize);
int pathLengthIdx = 0;
for (; volumePaths[pathLengthIdx] != nextOcurrence[0]; pathLengthIdx++) {
if (debug) { std::cout << volumePaths[0]; std::cout << " ENTERS " + std::to_string(pathLengthIdx) << std::endl; }
itemPath[pathLengthIdx] = volumePaths[pathLengthIdx];
}
itemPath[pathLengthIdx + 1] = '\0';
dest->push_back(itemPath);
//TODO concat de puto C
log_debugcpp(dest->at(dest->size() - 1));
log_debugcpp( " EXPLODEPATH");
if (nextOcurrence[0] == nextOcurrence[1]) return depth;
depth++;
return explodePaths(nextOcurrence + sizeof(TCHAR), (volumePathsBufferSize - pathLengthIdx), separator, dest, depth);
}
int listVolumes(std::vector<char*> *onPresentPaths){
HANDLE hFind = INVALID_HANDLE_VALUE;
const char separator = '\0';
int numVolumes = 0;
//Volume name
TCHAR volumeName[MAX_PATH];
int volumeNameSize = sizeof volumeName / sizeof volumeName[0];
//Paths
int volumePathsBufferSize = (MAX_PATH + 1) * sizeof(TCHAR);
unsigned long volumePathLength;
TCHAR volumePaths[volumePathsBufferSize];
std::fill(volumePaths, volumePaths + volumePathsBufferSize, '\0');
hFind = FindFirstVolume(volumeName, volumeNameSize); //if (debug) std::cout << volumeNameSize << std::endl;
if (INVALID_HANDLE_VALUE == hFind) return -2;
do {
//if (debug) std::cout << volumeName << std::endl;
if(GetVolumePathNamesForVolumeName(volumeName, volumePaths, volumePathsBufferSize, &volumePathLength)){
if (volumePathLength == 1) { if (debug) std::cout << "Skill Issue" << std::endl; continue; }
log_debugcpp(volumeName);
//pathSchecker
// if (debug && volumePaths[0] == 'E') {
// std::cout << volumePathLength << std::endl;
// /*exit(1);*/
// for (int i = 0; i < volumePathsBufferSize; i++){
// std::cout << std::to_string(i) + ": ";
// std::cout << volumePaths[i];
// std::cout << " | ";
// }
// std::cout << std::endl << "I IA" << std::endl;
// exit(1);
// }
if(numVolumes += explodePaths(volumePaths, volumePathsBufferSize, separator, onPresentPaths)){
for (int i = 0; i < onPresentPaths->size(); i++){
std::cout << onPresentPaths->at(i) << std::endl;
}
}
//std::cout << volumePaths << std::endl;
log_debugcpp(std::to_string(volumePathLength) + "<- VOLUME PATH LENGTH");
log_debugcpp("THE END");
}else{
log_debugcpp("no volumes found wtf");
}
std::fill(volumePaths, volumePaths + volumePathsBufferSize, '\0');
} while (FindNextVolume(hFind, volumeName, volumeNameSize) != 0);
log_debugcpp(std::to_string(onPresentPaths->size()) + " JUST BEFORE MAIN");
FindVolumeClose(hFind);
return numVolumes;
}
/* FIN FILE PICKER MOMENTO */
int main(int, char**)
{
// Setup window
glfwSetErrorCallback(glfw_error_callback);
if (!glfwInit())
return 1;
// Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
// GL ES 2.0 + GLSL 100
const char* glsl_version = "#version 100";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#elif defined(__APPLE__)
// GL 3.2 + GLSL 150
const char* glsl_version = "#version 150";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac
#else
// GL 3.0 + GLSL 130
const char* glsl_version = "#version 130";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only
#endif
// Create window with graphics context
GLFWwindow* window = glfwCreateWindow(1280, 720, "Dear ImGui GLFW+OpenGL3 example", NULL, NULL);
if (window == NULL)
return 1;
glfwMakeContextCurrent(window);
glfwSwapInterval(1); // Enable vsync
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init(glsl_version);
// Load Fonts
// - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
// - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
// - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
// - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
// - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
// - Read 'docs/FONTS.md' for more instructions and details.
// - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
//io.Fonts->AddFontDefault();
//io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
//io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
//io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
//io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
//ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
//IM_ASSERT(font != NULL);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
// Main loop
while (!glfwWindowShouldClose(window)) {
// Poll and handle events (inputs, window resize, etc.)
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
glfwPollEvents();
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
{
static float f = 0.0f;
static int counter = 0;
ImGui::Begin("Hello, world!"); // Create a window called "Hello, world!" and append into it.
ImGui::Text("This is some useful text."); // Display some text (you can use a format strings too)
ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our window open/close state
ImGui::Checkbox("Another Window", &show_another_window);
ImGui::SliderFloat("float", &f, 0.0f, 1.0f); // Edit 1 float using a slider from 0.0f to 1.0f
ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::SameLine();
ImGui::Text("counter = %d", counter);
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::End();
}
{
ImGui::Begin("File Picker in 4K");
static bool isInvalidPath = false;
static bool isListVolumesAdequate = true;
static bool isListDirectoriesAdequate = true;
//Listar UNA VEZ volumenes
static int numVolumes;
static std::vector<char*> onPresentPaths;
if (isListVolumesAdequate) {
isListVolumesAdequate = false;
//std::cout << isListVolumesAdequate << std::endl;
numVolumes = listVolumes(&onPresentPaths);
log_debugcpp(std::to_string(numVolumes) + "<- depth MAIN size() ->" + std::to_string(onPresentPaths.size()));
}
//Listar UNA VEZ directorios
//cursed C momento: necesario ptr en otra var para mandar a char** de firma
static char currentPath[MAX_PATH];
static char* currentPathPtr = &currentPath[0];
//static int currentItemIdx = -1;
//static std::vector<char*> directoryContents;
static std::vector<directoriesInfo*> directoryContents;
static int numFiles = 0;
ImGui::Text("%s PRE DIRECTORY TREATMENTO", currentPath);
if(isListDirectoriesAdequate) {
log_debugcpp("ADECUADO LISTAR DIRECTORIOS");
isListDirectoriesAdequate = false;
if(!retrieveCurrentDirectory(&currentPathPtr)) {
log_debugcpp("NO HABIA DIRECTORIO GetCurrentPath()");
goto filepickerFailure;
}
//
//TODO ELIMINAR RESTRICCION EXE; PRUEBITA DEL SIGNIORE
numFiles = listDirectory(std::string(currentPath), &directoryContents);
//std::cout << numFiles;
if (numFiles < 0) {
log_debugcpp("FALLO LA FUNCION, VALOR NEGATIVO " + std::to_string(numFiles));
isInvalidPath = true;
}
}
//It's renderin' time
static bool showHidden = false;
static bool filterByExtension = false;
static std::vector<std::string> extensions;
ImGui::Text("Select a file:");
//Permanentes e increiblemente utilitarios botones en Cuatro K: MOVE UP
//c pervirtio con unicode std::wstring s(L"←→↑↓");
static char moveUp[] = "..";
static char* moveUpPtr = &moveUp[0];
if(ImGui::Button("Move Up")) {
moveDirectory(&moveUpPtr);
isInvalidPath = false;
isListDirectoriesAdequate = true;
}
ImGui::SameLine();
//BARRA DE DIRECCIONES
ImGui::Text("%s TEMPADDRBAR", currentPath);
//LA GRAN TABLACIÓN: ACTOR EN LAS SOMBRAS
static ImGuiTableFlags splitterTableFlags = ImGuiTableFlags_Resizable | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_BordersV;
if (ImGui::BeginTable("##splitterTable", 2, splitterTableFlags, ImVec2(-FLT_MIN, 0.8f * ImGui::GetTextLineHeightWithSpacing()))){
ImGui::TableNextRow();
ImGui::TableNextColumn();
//VOLUMENES
static ImGuiTableFlags volumesFlags = ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY ;
if (ImGui::BeginTable("##volumesTable", 1, volumesFlags, ImVec2(-FLT_MIN, 20 * ImGui::GetTextLineHeightWithSpacing()))){
ImGui::TableSetupColumn("Volumes", ImGuiTableColumnFlags_NoHide);
//ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, TEXT_BASE_WIDTH * 12.0f);
//ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthFixed, TEXT_BASE_WIDTH * 18.0f);
ImGui::TableHeadersRow();
ImGui::TableNextRow();
if (numVolumes > 0) {
for (int i = 0; i < onPresentPaths.size(); i++) {
ImGui::TableNextColumn();
// ImGui::PushID(i);
ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor::HSV(i / 7.0f, 0.6f, 0.6f));
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, (ImVec4)ImColor::HSV(i / 7.0f, 0.7f, 0.7f));
ImGui::PushStyleColor(ImGuiCol_ButtonActive, (ImVec4)ImColor::HSV(i / 7.0f, 0.8f, 0.8f));
if(ImGui::Button(onPresentPaths.at(i))){
moveDirectory(&onPresentPaths.at(i));
isListDirectoriesAdequate = true;
}
ImGui::PopStyleColor(3);
if (i != onPresentPaths.size() - 1) ImGui::TableNextRow();
// ImGui::PopID();
}
}
ImGui::EndTable();
}
ImGui::TableNextColumn();
//DIRECTORIOS ENCONTRADOS bien pinta2
static ImGuiTableFlags directoriesFlags = ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable |ImGuiTableFlags_ScrollY ;
if (ImGui::BeginTable("##directoriesTable", 3, directoriesFlags, ImVec2(-FLT_MIN, 20 * ImGui::GetTextLineHeightWithSpacing()))){
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoHide);
ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_NoHide);
ImGui::TableSetupColumn("Size", ImGuiTableColumnFlags_NoHide);
//ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, TEXT_BASE_WIDTH * 12.0f);
//ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_WidthFixed, TEXT_BASE_WIDTH * 18.0f);
ImGui::TableHeadersRow();
int idx = 0;
for (; idx < numFiles; idx++) {
if(directoryContents.at(idx)->isHidden && !showHidden) continue;
if(filterByExtension && !directoryContents.at(idx)->isFile) {
//TODO XAPUSITA
extensions.clear();
extensions.push_back("exe");
if (!compareLastChar(&extensions, directoryContents.at(idx)->name)) continue;
}
ImGui::TableNextRow();
ImGui::TableNextColumn();
//NAME
bool isSelected = false;
if (ImGui::Selectable(directoryContents.at(idx)->name, &isSelected)){
//currentItemIdx = i;
strcat(currentPath, "\\");
strcat(currentPath, directoryContents.at(idx)->name);
moveDirectory(&currentPathPtr);
//currentItemIdx = -1;
isListDirectoriesAdequate = true;
}
ImGui::TableNextColumn();
//TYPE
if (directoryContents.at(idx)->isFile) ImGui::Text("Folder"); else ImGui::Text("File");
ImGui::TableNextColumn();
//SIZE
if (!directoryContents.at(idx)->isFile) ImGui::Text("%lld bytes", directoryContents.at(idx)->size);
else ImGui::Text("");
//ImGui::SetItemDefaultFocus();
}
//DISPLAYING ALTERNATIVE INFO
if (!idx) {
ImGui::TableNextRow(); ImGui::TableNextColumn();
if (isInvalidPath) ImGui::Text("Failed to access: Path not valid");
else ImGui::Text("Folder is empty");
}
ImGui::EndTable();
}
ImGui::EndTable();
}
//ImGui::TreePop();
ImGui::Checkbox("Show hidden", &showHidden);
ImGui::SameLine();
ImGui::Checkbox("Filter by .exe", &filterByExtension);
ImGui::SameLine();
ImGui::Button("Select");
filepickerFailure:
ImGui::End();
}
// 3. Show another simple window.
if (show_another_window)
{
ImGui::Begin("Another Window", &show_another_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
if (ImGui::Button("Close Me"))
show_another_window = false;
ImGui::End();
}
// Rendering
ImGui::Render();
int display_w, display_h;
glfwGetFramebufferSize(window, &display_w, &display_h);
glViewport(0, 0, display_w, display_h);
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
glfwSwapBuffers(window);
}
// Cleanup
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
Reference in a new issue View git blame Copy permalink