Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

tenho seguinte código c++ #include #include #include #include #include #include #include…

  1. User

    tenho seguinte código c++

    #include #include #include #include #include #include #include <cryptopp/keccak.h> #include <cryptopp/hex.h> #include <cryptopp/files.h> #include <conio.h> #include <windows.h>

    namespace fs = std::filesystem;

    // Function to calculate Keccak-512 hash of a file std::string calculateKeccak512(const std::string& filePath) { CryptoPP::Keccak_512 hash; std::string digest;

    CryptoPP::FileSource(filePath.c_str(), true, new CryptoPP::HashFilter(hash, new CryptoPP::HexEncoder( new CryptoPP::StringSink(digest), true)));

    return digest; }

    // Function to set console text color void setConsoleColor(int color) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color); }

    // Function to reset console text color void resetConsoleColor() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7); // Default color }

    // Function to clear console screen void clearScreen() { system("cls"); }

    // Function to display the progress bar void displayProgressBar(float progress) { int barWidth = 50; std::cout << "\r["; int pos = static_cast(barWidth * progress); for (int i = 0; i < barWidth; ++i) { if (i < pos) std::cout << "="; else if (i == pos) std::cout << ">"; else std::cout << " "; } std::cout << "] " << int(progress * 100.0) << "%"; std::cout.flush(); }

    int main() { // Step 1: Ask for the directory path std::string directoryPath; std::cout << "Digite o caminho da pasta que deve ser verificada: "; std::getline(std::cin, directoryPath);

    // Check if the directory exists if (!fs::exists(directoryPath) || !fs::is_directory(directoryPath)) { std::cerr << "Diretório inválido!" << std::endl; return 1; }

    // Step 2: Collect files with specified extensions std::vectorstd::string extensions = { ".exe", ".dll", ".asi" }; std::vector<std::pair<std::string, bool>> files; // Pair of filename and selection status

    for (const auto& entry : fs::directory_iterator(directoryPath)) { if (entry.is_regular_file()) { std::string extension = entry.path().extension().string(); if (std::find(extensions.begin(), extensions.end(), extension) != extensions.end()) { files.push_back({ entry.path().filename().string(), true }); // Default to selected (true) } } }

    // Step 3: Display files and allow selection/deselection int currentIndex = 0; int key;

    while (true) { clearScreen(); std::cout << "Use as setas para cima/baixo para navegar e ESPAÇO para selecionar/deselecionar arquivos." << std::endl; std::cout << "Arquivos:" << std::endl << std::endl;

    // Display all files, and highlight the current selection
    for (size_t i = 0; i < files.size(); ++i) {
        if (i == currentIndex) {
            setConsoleColor(112); // Highlight current selection
            std::cout << "> ";
        }
        else {
            std::cout << "  ";
        }
    
        if (files[i].second) {
            setConsoleColor(10); // Green text for selected files
        }
        else {
            setConsoleColor(12); // Red text for deselected files
        }
    
        std::cout << files[i].first;
        resetConsoleColor();
        std::cout << std::endl;
    }
    
    std::cout << std::endl;
    std::cout << "Pressione ENTER para gerar o arquivo." << std::endl;
    
    key = _getch();
    if (key == '\r') { // ENTER key
        break;
    }
    else if (key == 0 || key == 224) { // Arrow keys on Windows
        key = _getch();
        if (key == 72) { // Up arrow
            if (currentIndex > 0) currentIndex--;
        }
        else if (key == 80) { // Down arrow
            if (currentIndex < files.size() - 1) currentIndex++;
        }
    }
    else if (key == ' ') {
        // Toggle selection
        files[currentIndex].second = !files[currentIndex].second;
    }
    

    }

    // Step 4: Compute hashes and display progress bar std::cout << "\nCalculando hashes..." << std::endl; size_t totalFiles = std::count_if(files.begin(), files.end(), [](auto& f) { return f.second; }); size_t processedFiles = 0;

    std::ofstream outputFile("rTales.ini"); if (!outputFile.is_open()) { std::cerr << "Erro ao abrir o arquivo de saída!" << std::endl; return 1; }

    for (auto& file : files) { if (file.second) { // If the file is selected std::string filePath = (fs::path(directoryPath) / file.first).string(); std::string hash = calculateKeccak512(filePath); outputFile << """ << file.first << "" : " << hash << std::endl;

        processedFiles++;
        float progress = (float)processedFiles / totalFiles;
        displayProgressBar(progress);
    }
    

    } std::cout << std::endl;

    outputFile.close(); std::cout << "Hashes calculados e salvos em rTales.ini" << std::endl; return 0; }

    Quando os arquivos são listados, o foco não está acompanhando o seleção de arquivos, está apenas ficando no fim da lista

  2. Assistant

    O problema que você está enfrentando ocorre porque as configurações de cor do console estão sendo sobrescritas quando você imprime cada linha. Na forma atual do seu código, ao exibir cada arquivo, você está alterando a cor do console várias vezes, e as alterações de cor posteriores estão sobrepondo as anteriores. Por isso, o destaque na seleção atual não está aparecendo conforme esperado.

    Especificamente, quando i == currentIndex, você primeiro define a cor para 112 (que supostamente destaca a seleção atual), mas em seguida, você redefine a cor para 10 ou 12 (para arquivos selecionados ou desmarcados). Isso faz com que a cor de destaque seja perdida.

    Para corrigir isso, você precisa definir a cor do console apenas uma vez por linha, combinando tanto as cores de primeiro plano quanto as de fundo em um único atributo.

    Aqui está como você pode ajustar o seu código:

    1. Use constantes de cores definidas, em vez de números mágicos, para tornar o código mais legível e menos propenso a erros.

    2. Combine os atributos de cor de primeiro plano e de fundo para que o console aplique todas as configurações desejadas de uma só vez.

    Altere a parte do seu código que exibe os arquivos para o seguinte:

    #include <windows.h> // Certifique-se de incluir esta biblioteca
    
    // Defina as constantes de cor para facilitar a leitura
    const WORD DEFAULT_COLOR = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
    const WORD SELECTED_COLOR = FOREGROUND_GREEN | FOREGROUND_INTENSITY;
    const WORD DESELECTED_COLOR = FOREGROUND_RED | FOREGROUND_INTENSITY;
    const WORD HIGHLIGHT_BACKGROUND = BACKGROUND_BLUE | BACKGROUND_INTENSITY;
    
    ...
    
    // Dentro do seu loop de exibição de arquivos:
    for (size_t i = 0; i < files.size(); ++i) {
        WORD attributes = 0;
    
        // Defina a cor do texto com base na seleção
        if (files[i].second) {
            attributes |= SELECTED_COLOR; // Texto verde para arquivos selecionados
        } else {
            attributes |= DESELECTED_COLOR; // Texto vermelho para arquivos desmarcados
        }
    
        // Adicione o destaque de fundo se for o índice atual
        if (i == currentIndex) {
            attributes |= HIGHLIGHT_BACKGROUND;
        }
    
        // Defina a cor do console com os atributos combinados
        setConsoleColor(attributes);
    
        // Exiba o indicador de seleção ">" se for o índice atual
        if (i == currentIndex) {
            std::cout << "> ";
        } else {
            std::cout << "  ";
        }
    
        // Exiba o nome do arquivo
        std::cout << files[i].first;
    
        // Resete a cor do console para o padrão após cada linha
        resetConsoleColor();
        std::cout << std::endl;
    }
    

    Explicação do que mudou:

    • Combinação de atributos: Agora, ao invés de chamar setConsoleColor múltiplas vezes (o que resultava na sobreposição de cores), combinamos os atributos de cor em uma única variável attributes e aplicamos todos de uma vez.

    • Uso de constantes claras: Definimos constantes para as cores, o que torna o código mais legível e fácil de manter.

    • Aplicação correta do destaque: Ao adicionar HIGHLIGHT_BACKGROUND aos atributos quando i == currentIndex, asseguramos que toda a linha (incluindo o texto do arquivo) seja destacada corretamente.

    • Redefinição da cor após cada linha: Chamamos resetConsoleColor() após exibir cada linha para garantir que as configurações de cor não afetem as próximas linhas.

    Com essas alterações, o foco na seleção de arquivos deverá funcionar corretamente, destacando a linha atual e mantendo as cores de texto apropriadas para arquivos selecionados e desmarcados. Agora, ao navegar com as setas, você verá o destaque acompanhando sua seleção, assim como a cor do texto indicando o estado de cada arquivo.


    Nota adicional: É importante sempre garantir que as configurações do console sejam aplicadas de forma consistente. Alterar as cores várias vezes em uma sequência sem resetar ou combinar os atributos pode levar a comportamentos inesperados, como o que você observou.