import java.util.Scanner; /** * AnsiShopTUI * ------------------------------------------------------------------ * A VERY simple demonstration of how ANSI terminal escape codes can be * used to build a text user interface (TUI), without any external * libraries (no Lanterna, no ncurses, no JLine -- just plain old * escape sequences printed to System.out). * * The idea: your terminal understands special sequences of characters * that start with the "ESC" character (ASCII 27) followed by "[". * These sequences tell the terminal to do things like clear the * screen, move the cursor to a specific row/column, or change text * color. We define those sequences as simple String constants below, * then wrap them in tiny helper methods (clearScreen, gotoXY, * printAt, etc.) so the rest of the program never has to deal with * raw escape codes directly. * * This is a "product lookup" toy app for a fake store that sells * keyboards, mice, monitors, and power strips. It has several * screens (Welcome -> Main Menu -> Category List -> Product Detail) * so you can see how a TUI moves the user between different "pages" * just by clearing the screen and redrawing. * * To run: * javac AnsiShopTUI.java * java AnsiShopTUI * * NOTE: This works in a real terminal (Terminal.app, iTerm, gnome * terminal, Windows Terminal, etc). It will NOT render correctly * inside some IDE "Run" consoles that don't support ANSI codes. * ------------------------------------------------------------------ */ public class AnsiShopTUI { // ================================================================ // 1. RAW ANSI ESCAPE CODES (as constants) // ================================================================ // Every ANSI escape sequence starts with this "Control Sequence // Introducer" (CSI): ESC + "[".  is the escape character. static final String ESC = "["; // --- Screen / cursor control --- static final String CLEAR_SCREEN = ESC + "2J"; // erase entire screen static final String CURSOR_HOME = ESC + "H"; // move cursor to row 1, col 1 static final String HIDE_CURSOR = ESC + "?25l"; // hide the blinking cursor static final String SHOW_CURSOR = ESC + "?25h"; // show the blinking cursor static final String CLEAR_LINE = ESC + "2K"; // erase the current line // --- Text style / color --- static final String RESET = ESC + "0m"; // reset all colors/styles to default static final String BOLD = ESC + "1m"; static final String REVERSE = ESC + "7m"; // swap foreground/background (highlight) static final String FG_RED = ESC + "31m"; static final String FG_GREEN = ESC + "32m"; static final String FG_YELLOW = ESC + "33m"; static final String FG_BLUE = ESC + "34m"; static final String FG_MAGENTA = ESC + "35m"; static final String FG_CYAN = ESC + "36m"; static final String FG_WHITE = ESC + "37m"; static final String BG_BLUE = ESC + "44m"; // ================================================================ // 2. SIMPLE WRAPPER METHODS // ================================================================ // These are the "building blocks" a beginner TUI is made of. // Everything below just prints raw text -- the escape codes are // what make the terminal treat that text specially. /** Clears the whole screen and puts the cursor back at (1,1). */ static void clearScreen() { System.out.print(CLEAR_SCREEN); System.out.print(CURSOR_HOME); System.out.flush(); } /** * Moves the cursor to a given row/column. Terminals are 1-indexed, * with (1,1) being the top-left corner of the screen. */ static void gotoXY(int row, int col) { System.out.print(ESC + row + ";" + col + "H"); } /** Prints plain text starting at a specific row/column. */ static void printAt(int row, int col, String text) { gotoXY(row, col); System.out.print(text); } /** Prints colored text starting at a specific row/column. */ static void printAt(int row, int col, String color, String text) { gotoXY(row, col); System.out.print(color + text + RESET); } /** Draws a simple rectangular box made of +, -, and | characters. */ static void drawBox(int row, int col, int width, int height) { printAt(row, col, "+" + "-".repeat(width - 2) + "+"); for (int r = 1; r < height - 1; r++) { printAt(row + r, col, "|"); printAt(row + r, col + width - 1, "|"); } printAt(row + height - 1, col, "+" + "-".repeat(width - 2) + "+"); } /** Waits for the user to press Enter before continuing. */ static void pause(Scanner scanner, int row, int col) { printAt(row, col, FG_WHITE, "Press ENTER to continue..."); scanner.nextLine(); } // ================================================================ // 3. FAKE PRODUCT DATA // ================================================================ // A tiny "database" of products, grouped into 4 categories. static class Product { String name; double price; int stockCount; Product(String name, double price, int stockCount) { this.name = name; this.price = price; this.stockCount = stockCount; } } static final String[] CATEGORY_NAMES = { "Keyboards", "Mice", "Monitors", "Power Strips" }; static final Product[][] CATALOG = { { // Keyboards new Product("ClickyClack Mechanical 87-key", 59.99, 14), new Product("QuietType Membrane Standard", 19.99, 42), new Product("WirelessGlide Compact", 34.50, 8), }, { // Mice new Product("PixelPoint Wired Optical", 9.99, 61), new Product("SmoothGlide Wireless", 24.99, 27), new Product("ErgoGrip Vertical Mouse", 32.00, 5), }, { // Monitors new Product("ViewMax 24in 1080p", 129.00, 11), new Product("UltraWide 34in Curved", 379.99, 3), new Product("BudgetView 21in", 89.50, 19), }, { // Power Strips new Product("SurgeGuard 6-Outlet", 14.99, 33), new Product("TravelStrip 3-Outlet + USB", 12.50, 20), new Product("HeavyDuty 8-Outlet Metal", 27.75, 9), }, }; // ================================================================ // 4. SCREENS ("pages" of the app) // ================================================================ /** Screen 1: Welcome / splash screen. */ static void showWelcomeScreen(Scanner scanner) { clearScreen(); drawBox(2, 5, 60, 7); printAt(4, 10, BOLD + FG_CYAN, "WELCOME TO THE ANSI TERMINAL SHOP"); printAt(6, 10, FG_WHITE, "A tiny demo of ANSI escape codes in Java."); printAt(7, 10, FG_WHITE, "No libraries. Just escape sequences + println."); pause(scanner, 11, 5); } /** Screen 2: Main menu -- pick a product category. */ static int showMainMenu(Scanner scanner) { clearScreen(); drawBox(1, 3, 50, CATEGORY_NAMES.length + 6); printAt(2, 6, BOLD + FG_YELLOW, "MAIN MENU - Product Categories"); printAt(3, 6, FG_WHITE, "------------------------------"); for (int i = 0; i < CATEGORY_NAMES.length; i++) { printAt(4 + i, 6, FG_GREEN, "[" + (i + 1) + "] " + CATEGORY_NAMES[i]); } int quitLine = 4 + CATEGORY_NAMES.length; printAt(quitLine, 6, FG_RED, "[0] Quit"); printAt(quitLine + 2, 6, FG_WHITE, "Choose an option: "); String input = scanner.nextLine().trim(); try { int choice = Integer.parseInt(input); if (choice >= 0 && choice <= CATEGORY_NAMES.length) { return choice; } } catch (NumberFormatException ignored) { // fall through to invalid choice handling below } printAt(quitLine + 3, 6, FG_RED, "Invalid choice: " + input); pause(scanner, quitLine + 5, 6); return -1; // signal "redraw menu" } /** Screen 3: Product list for a chosen category. */ static void showCategoryScreen(Scanner scanner, int categoryIndex) { boolean stayOnScreen = true; while (stayOnScreen) { Product[] products = CATALOG[categoryIndex]; clearScreen(); drawBox(1, 3, 66, products.length + 7); printAt(2, 6, BOLD + FG_CYAN, "CATEGORY: " + CATEGORY_NAMES[categoryIndex]); printAt(3, 6, FG_WHITE, "----------------------------------------"); printAt(4, 6, REVERSE, " # Product Price Stock "); for (int i = 0; i < products.length; i++) { Product p = products[i]; String line = String.format("[%d] %-30s $%-7.2f %3d", i + 1, p.name, p.price, p.stockCount); printAt(5 + i, 6, FG_WHITE, line); } int backLine = 5 + products.length; printAt(backLine, 6, FG_YELLOW, "[0] Back to Main Menu"); printAt(backLine + 2, 6, FG_WHITE, "View which product? "); String input = scanner.nextLine().trim(); if (input.equals("0")) { stayOnScreen = false; continue; } try { int choice = Integer.parseInt(input); if (choice >= 1 && choice <= products.length) { showProductDetailScreen(scanner, products[choice - 1]); } else { printAt(backLine + 3, 6, FG_RED, "No such product number."); pause(scanner, backLine + 5, 6); } } catch (NumberFormatException e) { printAt(backLine + 3, 6, FG_RED, "Please enter a number."); pause(scanner, backLine + 5, 6); } } } /** Screen 4: Detail view for a single product. */ static void showProductDetailScreen(Scanner scanner, Product p) { clearScreen(); drawBox(3, 8, 50, 9); printAt(5, 12, BOLD + FG_MAGENTA, "PRODUCT DETAIL"); printAt(6, 12, FG_WHITE, "Name: " + p.name); printAt(7, 12, FG_WHITE, "Price: $" + String.format("%.2f", p.price)); printAt(8, 12, FG_WHITE, "Stock: " + p.stockCount + " units available"); String status = p.stockCount == 0 ? "OUT OF STOCK" : p.stockCount < 10 ? "LOW STOCK" : "IN STOCK"; String statusColor = p.stockCount == 0 ? FG_RED : p.stockCount < 10 ? FG_YELLOW : FG_GREEN; printAt(9, 12, statusColor, "Status: " + status); pause(scanner, 11, 8); } // ================================================================ // 5. MAIN PROGRAM LOOP // ================================================================ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // Hide the blinking cursor while the app runs, restore it on exit. System.out.print(HIDE_CURSOR); showWelcomeScreen(scanner); boolean running = true; while (running) { int choice = showMainMenu(scanner); if (choice == 0) { running = false; } else if (choice >= 1 && choice <= CATEGORY_NAMES.length) { showCategoryScreen(scanner, choice - 1); } // choice == -1 means "invalid input" -- just loop and redraw menu } clearScreen(); printAt(1, 1, FG_CYAN, "Thanks for visiting the ANSI Terminal Shop. Goodbye!"); System.out.print(RESET); System.out.print(SHOW_CURSOR); System.out.println(); scanner.close(); } }

# Understanding AnsiShopTUI: A Beginner's Guide to Terminal UIs This is a companion guide to `AnsiShopTUI.java`, a small Java program that builds a menu-driven "shop" app entirely inside a plain terminal window. No graphics library, no windows, no mouse. If you're new to Java and have never thought about how terminal programs draw text on screen, this document explains the ideas behind the code before you dive into it. ## What is a TUI? TUI stands for Text User Interface. It's the older, text-only cousin of the GUI (Graphical User Interface) you're used to on a phone or desktop. Instead of buttons, windows, and icons made of pixels, a TUI uses only text characters arranged on a grid, but that text can still be colored, positioned precisely, and updated dynamically to feel like a real app with menus and screens. Old-school examples include DOS-era program installers, the `vim` and `nano` text editors, `top` (the process viewer on Mac/Linux), and old BBS (bulletin board) systems from the 1980s and 90s. They all do the same basic trick this program does: they place characters at exact positions on the screen instead of just printing line after line. ## A Little History: Why Terminals Understand "Escape Codes" Long before computers had screens with pixels, people used physical machines called terminals (think: a keyboard attached to a printer or a simple screen) to talk to a faraway computer. One very influential terminal, made by a company called DEC in the 1970s, was called the VT100. It defined a set of special commands you could send to the terminal so it would do things like move its cursor, clear the screen, or print in a different color, instead of only printing new lines forever. Those commands became a de facto standard, and today they're documented as the ANSI escape codes (ANSI is the American National Standards Institute, which formalized this set of terminal control sequences). Even though physical terminals are long gone, virtually every terminal program you use today, Terminal.app on a Mac, the Windows Terminal, iTerm, a Linux console, still understands these same codes, because emulating an old VT100-style terminal became the universal baseline everyone agreed to support. That's why a language like Java, running on a modern computer, can use decades-old escape codes and still control the terminal window in real time. ## What Is an "Escape Code," Concretely? An escape code is just a short sequence of ordinary text characters that the terminal treats as an instruction instead of something to display. It always starts with one invisible character called ESC (short for "Escape," and it's ASCII character number 27), immediately followed by a left bracket `[`. Everything after that up to a letter is the instruction. For example, the text sequence `ESC[2J` means "clear the entire screen," and `ESC[10;5H` means "move the cursor to row 10, column 5." When your Java program prints these exact characters to the screen, nothing visible appears for the escape code itself, but the terminal reacts by clearing itself or jumping the cursor, and then whatever text you print next appears in the new spot. This ESC + `[` combination is called the CSI, the Control Sequence Introducer. Nearly every code in `AnsiShopTUI.java` is built the same way: CSI, followed by some numbers, followed by a single letter that says what to do (`H` for cursor position, `J` for clearing, `m` for color/style). ## How the Class Organizes This Idea The file is deliberately split into layers, from lowest-level to highest-level, so you can see how a handful of raw text codes eventually become a working menu app. **Layer 1: Raw constants.** Near the top, you'll see constants like `CLEAR_SCREEN`, `FG_GREEN`, and `BOLD`. Each one is just a literal string containing the escape sequence for that effect. This layer has zero logic, it is only naming the magic strings so the rest of the code never has to remember what `ESC[32m` means. **Layer 2: Simple wrapper methods.** Methods like `clearScreen()`, `gotoXY(row, col)`, and `printAt(row, col, text)` take those raw constants and turn them into small, reusable actions. `gotoXY` is worth understanding closely: it builds a fresh escape code every time using whatever row and column you pass in, because cursor position is the one code that needs actual numbers plugged in rather than being a fixed constant. Everything above this layer never touches a raw escape code directly again. **Layer 3: Fake data.** The `Product` class and the `CATALOG` array are ordinary Java data, no terminal concepts here at all. This is just the inventory the app displays. **Layer 4: Screens.** Methods like `showWelcomeScreen`, `showMainMenu`, `showCategoryScreen`, and `showProductDetailScreen` are where it all comes together. Each one clears the screen, then uses the Layer 2 wrappers to draw a box, print some labeled text at specific coordinates, and ask the user for input with a `Scanner`. A "screen" in this program is really just: clear everything, redraw a specific layout, then wait for a choice. **Layer 5: The main loop.** `main()` ties the screens together. It shows the welcome screen once, then loops through the main menu, opening a category screen when you pick one, until you choose to quit. ## Why "Clear, Then Redraw" Instead of Just Printing More Text? A beginner's first instinct is usually to keep `System.out.println`-ing new lines forever, the way a typical console program does. A TUI behaves differently: every time you move to a new "page," the program clears the whole screen and repaints it from scratch at fixed coordinates. That's why the screen feels like a page changing, similar to clicking a link in a GUI, rather than a long scrolling log of everything that has ever happened. This is the central trick that separates a TUI from a plain command-line program: precise, repeatable positioning instead of endless scrolling. ## Rows, Columns, and the "1-Indexed" Surprise One detail that trips people up: terminal coordinates start counting at 1, not 0. The very top-left character cell on the screen is row 1, column 1, not row 0, column 0 like a Java array. That's why you'll see `gotoXY(1, 1)` in this code rather than `gotoXY(0, 0)`. This convention comes straight from the original hardware terminals and has simply never changed. ## Why No External Libraries? There are polished Java libraries (like Lanterna or JLine) that handle terminal UIs for you with much more power: mouse support, resizing, cross-platform quirks, and so on. This project intentionally avoids all of that. The goal here is to see the actual mechanism, plain strings sent to `System.out`, so that when you eventually do use a real TUI library, you'll understand what it's doing underneath for you. ## Things to Try Once You Understand the Basics A few small changes are good exercises for building confidence with this code: add a fifth product category, change the color scheme by swapping which `FG_*` constant a screen uses, add a "search by name" option to the main menu, or add a background color constant and use it behind the title text. Each of these only requires working within the layers already described, no new terminal concepts required. ## Quick Reference: Codes Used in This Program | Constant | Escape Sequence | Effect | |---|---|---| | `CLEAR_SCREEN` | `ESC[2J` | Erases everything on screen | | `CURSOR_HOME` | `ESC[H` | Moves cursor to row 1, col 1 | | `HIDE_CURSOR` / `SHOW_CURSOR` | `ESC[?25l` / `ESC[?25h` | Toggles the blinking cursor | | `gotoXY(row, col)` | `ESC[row;colH` | Moves cursor to a specific position | | `RESET` | `ESC[0m` | Turns off all color/style | | `BOLD` | `ESC[1m` | Makes following text bold | | `REVERSE` | `ESC[7m` | Swaps foreground/background color | | `FG_RED`, `FG_GREEN`, etc. | `ESC[3Xm` | Sets text color | If you keep this table nearby while reading `AnsiShopTUI.java`, every constant in the source file should map directly back to something explained above.