Practical Examples

This page demonstrates common use cases and patterns for using EasyMenu in your applications.

Simple Menu Application

A basic menu with a few options demonstrating the fundamental usage pattern:

#include <iostream>
#include <EasyMenu.h>

int main() {
    EasyMenu menu("Main Menu");

    menu.AddItem("Start Application");
    menu.AddItem("View Help");
    menu.AddItem("About");
    menu.AddItem("Exit");

    unsigned int choice = menu.RunMenu();

    switch (choice) {
        case 1:
            std::cout << "Starting application..." << std::endl;
            break;
        case 2:
            std::cout << "Displaying help..." << std::endl;
            break;
        case 3:
            std::cout << "About: EasyMenu Demo v1.0" << std::endl;
            break;
        case 4:
            std::cout << "Goodbye!" << std::endl;
            break;
        default:
            std::cout << "No selection made." << std::endl;
    }

    return 0;
}

Menu Loop Pattern

An application that repeatedly displays a menu until the user chooses to exit:

#include <iostream>
#include <EasyMenu.h>

void performAction1() {
    std::cout << "\nPerforming Action 1..." << std::endl;
    std::cout << "Press Enter to continue...";
    
    std::cin.get();
}

void performAction2() {
    std::cout << "\nPerforming Action 2..." << std::endl;
    std::cout << "Press Enter to continue...";
    
    std::cin.get();
}

void showData() {
    std::cout << "\nDisplaying data..." << std::endl;
    std::cout << "Data: [Sample Information]" << std::endl;
    std::cout << "Press Enter to continue...";
    
    std::cin.get();
}

int main() {
    EasyMenu menu("Application Menu");

    menu.AddItem("Action 1");
    menu.AddItem("Action 2");
    menu.AddItem("View Data");
    menu.AddItem("Exit");

    bool running = true;

    while (running) {
        unsigned int choice = menu.RunMenu();

        switch (choice) {
            case 1:
                performAction1();
                break;
            case 2:
                performAction2();
                break;
            case 3:
                showData();
                break;
            case 4:
                std::cout << "Exiting application..." << std::endl;
                running = false;
                break;
            default:
                running = false;
        }
    }

    return 0;
}

Dynamic Menu Updates

Modifying menu items based on application state:

#include <iostream>
#include <EasyMenu.h>

int main() {
    EasyMenu menu("Dynamic Menu");

    bool featureEnabled = false;

    menu.AddItem("Enable Feature");
    menu.AddItem("Use Feature", false, true); // Initially inactive
    menu.AddItem("Exit");

    bool running = true;

    while (running) {
        unsigned int choice = menu.RunMenu();

        switch (choice) {
            case 1:
                featureEnabled = !featureEnabled;
                if (featureEnabled)
                {
                    menu.UpdateItem(1, "Disable Feature");
                    menu.SetActivity(2, true); // Enable "Use Feature"
                    std::cout << "Feature enabled!" << std::endl;
                    
                    std::cin.get();
                }
                else{
                    menu.UpdateItem(1, "Enable Feature");
                    menu.SetActivity(2, false); // disable "Use Feature"
                    std::cout << "Feature Disabled!" << std::endl;
                    
                    std::cin.get();
                }
                break;
            case 2:
                if (featureEnabled) {
                    std::cout << "Using feature..." << std::endl;
                    
                    std::cin.get();
                }
                break;
            case 3:
                running = false;
                break;
            default:
                running = false;
        }
    }

    return 0;
}

Custom Header and Footer

Creating a menu with custom header and footer components:

#include <iostream>
#include <EasyMenu.h>
#include <EasyMenuComponents.h>

int main() {
    EasyMenu menu;

    // Create custom header
    EasyMenuComponents::clsEasyMenuHeader header;
    header.AddLine("================================");
    header.AddLine("    File Management System");
    header.AddLine("         Version 2.0");
    header.AddLine("================================");
    menu.SetHeader(header);

    // Create custom footer
    EasyMenuComponents::clsEasyMenuFooter footer;
    footer.AddLine("================================");
    footer.AddLine("Use Arrow Keys to Navigate");
    footer.AddLine("Press Enter to Select");
    footer.AddLine("================================");
    menu.SetFooter(footer);

    // Add menu items
    menu.AddItem("Create New File");
    menu.AddItem("Open File");
    menu.AddItem("Save File");
    menu.AddItem("Delete File");
    menu.AddItem("Exit");

    unsigned int choice = menu.RunMenu();

    if (choice > 0) {
        std::cout << "You selected option: " << choice << std::endl;
    }

    return 0;
}

Conditional Item Visibility

Showing or hiding menu items based on application state:

#include <iostream>
#include <EasyMenu.h>

int main() {
    EasyMenu menu("User Menu");

    bool isAdmin = false; // Simulate user permissions

    menu.AddItem("View Profile");
    menu.AddItem("Edit Settings");
    menu.AddItem("Admin Panel", true, isAdmin); // Hidden for non-admins
    menu.AddItem("Logout");

    bool running = true;

    while (running) {
        unsigned int choice = menu.RunMenu();

        switch (choice) {
            case 1:
                std::cout << "Viewing profile..." << std::endl;
                
                std::cin.get();
                break;
            case 2:
                std::cout << "Editing settings..." << std::endl;
                
                std::cin.get();
                break;
            case 3:
                if (isAdmin) {
                    std::cout << "Opening admin panel..." << std::endl;
                    
                    std::cin.get();
                }
                break;
            case 4:
                std::cout << "Logging out..." << std::endl;
                running = false;
                break;
            default:
                running = false;
        }
    }

    return 0;
}

Multi-Level Menu System

Creating a hierarchical menu system with submenus:

#include <iostream>
#include <EasyMenu.h>

void settingsMenu() {
    EasyMenu menu("Settings");

    menu.AddItem("Display Settings");
    menu.AddItem("Audio Settings");
    menu.AddItem("Network Settings");
    menu.AddItem("Back to Main Menu");

    unsigned int choice = menu.RunMenu();

    switch (choice) {
        case 1:
            std::cout << "Display settings..." << std::endl;
            
            std::cin.get();
            break;
        case 2:
            std::cout << "Audio settings..." << std::endl;
            
            std::cin.get();
            break;
        case 3:
            std::cout << "Network settings..." << std::endl;
            
            std::cin.get();
            break;
    }
}

void helpMenu() {
    EasyMenu menu("Help");

    menu.AddItem("Getting Started");
    menu.AddItem("FAQ");
    menu.AddItem("Contact Support");
    menu.AddItem("Back to Main Menu");

    unsigned int choice = menu.RunMenu();

    switch (choice) {
        case 1:
            std::cout << "Getting started guide..." << std::endl;
            
            std::cin.get();
            break;
        case 2:
            std::cout << "Frequently asked questions..." << std::endl;
            
            std::cin.get();
            break;
        case 3:
            std::cout << "Contact: support@example.com" << std::endl;
            
            std::cin.get();
            break;
    }
}

int main() {
    EasyMenu mainMenu("Main Menu");

    mainMenu.AddItem("Start");
    mainMenu.AddItem("Settings");
    mainMenu.AddItem("Help");
    mainMenu.AddItem("Exit");

    bool running = true;

    while (running) {
        unsigned int choice = mainMenu.RunMenu();

        switch (choice) {
            case 1:
                std::cout << "Starting application..." << std::endl;
                
                std::cin.get();
                break;
            case 2:
                settingsMenu();
                break;
            case 3:
                helpMenu();
                break;
            case 4:
                std::cout << "Goodbye!" << std::endl;
                running = false;
                break;
            default:
                running = false;
        }
    }

    return 0;
}

Error Handling Pattern

Proper error handling when modifying menu items:

#include <iostream>
#include <EasyMenu.h>

int main() {
    EasyMenu menu("Item Management Demo");

    menu.AddItem("Item 1");
    menu.AddItem("Item 2");
    menu.AddItem("Item 3");

    // Safe item update
    if (menu.UpdateItem(2, "Modified Item 2")) {
        std::cout << "Item 2 updated successfully" << std::endl;
    } else {
        std::cout << "Failed to update item 2" << std::endl;
    }

    // Attempting to update non-existent item
    if (!menu.UpdateItem(10, "Non-existent")) {
        std::cout << "Item 10 does not exist" << std::endl;
    }

    // Safe item removal
    if (menu.RemoveItem(3)) {
        std::cout << "Item 3 removed successfully" << std::endl;
    }

    // Check menu state before running
    if (menu.IsEmpty()) {
        std::cout << "Menu is empty!" << std::endl;
    } else {
        std::cout << "Menu has " << menu.GetNumberOfItems()
                  << " items" << std::endl;

        unsigned int choice = menu.RunMenu();

        if (choice == 0) {
            std::cout << "No selection (menu empty or not navigable)"
                      << std::endl;
        } else {
            std::cout << "Selected: " << choice << std::endl;
        }
    }

    return 0;
}

Complete Application Example

A fully functional task management application using EasyMenu:

#include <iostream>
#include <vector>
#include <string>
#include <EasyMenu.h>

struct Task {
    std::string description;
    bool completed;
};

std::vector<Task> tasks;

void addTask() {
    std::cout << "\nEnter task description: ";
    std::string desc;
    
    std::getline(std::cin, desc);

    tasks.push_back({desc, false});
    std::cout << "Task added successfully!" << std::endl;
    std::cout << "Press Enter to continue...";
    std::cin.get();
}

void viewTasks() {
    std::cout << "\n=== Task List ===" << std::endl;

    if (tasks.empty()) {
        std::cout << "No tasks available." << std::endl;
    } else {
        for (size_t i = 0; i < tasks.size(); ++i) {
            std::cout << (i + 1) << ". ";
            std::cout << (tasks[i].completed ? "[X] " : "[ ] ");
            std::cout << tasks[i].description << std::endl;
        }
    }

    std::cout << "\nPress Enter to continue...";
    
    std::cin.get();
}

void markComplete() {
    if (tasks.empty()) {
        std::cout << "\nNo tasks to mark as complete." << std::endl;
        std::cout << "Press Enter to continue...";
        
        std::cin.get();
        return;
    }

    std::cout << "\nEnter task number to mark complete: ";
    int taskNum;
    std::cin >> taskNum;

    if (taskNum > 0 && taskNum <= (int)tasks.size()) {
        tasks[taskNum - 1].completed = true;
        std::cout << "Task marked as complete!" << std::endl;
    } else {
        std::cout << "Invalid task number." << std::endl;
    }

    std::cout << "Press Enter to continue...";
    
    std::cin.get();
}

int main() {
    EasyMenu menu("Task Manager");

    menu.AddItem("Add New Task");
    menu.AddItem("View All Tasks");
    menu.AddItem("Mark Task Complete");
    menu.AddItem("Exit");

    bool running = true;

    while (running) {
        unsigned int choice = menu.RunMenu();

        switch (choice) {
            case 1:
                addTask();
                break;
            case 2:
                viewTasks();
                break;
            case 3:
                markComplete();
                break;
            case 4:
                std::cout << "Exiting Task Manager..." << std::endl;
                running = false;
                break;
            default:
                running = false;
        }
    }

    return 0;
}

Compiling the Examples

To compile and run any of these examples:

Using g++

g++ example.cpp -o example -I path/to/EasyMenu/Include
./example

Using Visual Studio

  1. Create a new Console Application project
  2. Copy the example code into your main.cpp file
  3. Configure the include path as described in the Installation guide
  4. Build and run the project (F5 or Ctrl+F5)

Next Steps