# Quick Menu — Unreal Engine Plugin
# Complete Reference (llms-full.txt)
# Version: 1.0 | Engine: UE 4.27 – 5.7 | Site: quickmenuplugin.com

## What is Quick Menu?

Quick Menu is a radial pie menu plugin for Unreal Engine that gives you instant access to editor actions with a single keypress. Press **V** to open a context-aware pie menu at your cursor. Select an action by hovering and releasing. The menu adapts to what you're doing — different tools when editing a Blueprint vs. sculpting Landscape vs. working in Sequencer.

Everything is configured through a **visual node graph** — no config files, no code required. Connect nodes to build menus that react to your editor context, organize actions into nested sub-menus, and customize every wedge with icons and colors.

**Key facts:**
- Hotkey: **V** (configurable)
- 44 built-in action types covering viewport, transforms, spawning, blueprints, materials, sequencer, and more
- 5 context switch types for dynamic menus
- Visual graph editor — drag, drop, connect
- Supports nested sub-menus (up to 4 levels deep)
- Python scripting support for custom actions
- Works across Level Editor, Blueprint Editor, Material Editor, Sequencer, Niagara, PCG, and 49 editor contexts total
- Compatible with UE 4.27 through 5.7

---

## How It Works

### The Graph System

Quick Menu uses **graph assets** (like Blueprint graphs, but simpler) to define your menus. You create a Quick Menu Graph in the Content Browser, then set it as active in Project Settings.

**The flow:**

```
Root → Switch (optional) → WheelOutput → Pie Menu
```

1. **Root node** — entry point, always one per graph
2. **Switch nodes** — route to different outputs based on context (what's selected, which editor is active, etc.)
3. **WheelOutput nodes** — terminal nodes that define a wheel (pie menu). Each input pin on a WheelOutput is one wedge in the pie menu
4. **Action nodes** — connect to WheelOutput pins to define what each wedge does
5. **SubMenu nodes** — group actions into expandable sub-menus within a wheel

### Pin Types

- **Exec pins** (white) — execution flow from Root through Switches to WheelOutputs
- **Menu pins** (blue) — connect actions and sub-menus to WheelOutput input pins

### Context Detection

Switch nodes evaluate the current editor state at runtime:
- Which editor tab is active? (Level Editor, Blueprint, Material, Sequencer...)
- What editing mode? (Select, Landscape, Foliage, Modeling...)
- How many actors are selected? (0, 1, multiple)
- What class is the selected actor?
- What Blueprint context? (Components, Event Graph, Construction Script...)

This means you can have one graph that shows transform tools in the Level Editor, component tools in the Blueprint Editor, and playback controls in Sequencer — all from the same V key.

---

## Node Reference

### Structural Nodes

#### Root
- One per graph, cannot be deleted
- Single exec output pin
- Starting point for menu evaluation

#### WheelOutput
- Terminal node with exec input + N menu input pins
- Each menu pin = one wedge in the pie menu
- Properties: **WheelName** (displayed in editor), **Category** (for organization)
- Maximum 10 wedges per wheel

#### SubMenu
- Menu output + N menu input pins (children)
- When connected to a WheelOutput pin, that wedge becomes expandable
- Children appear as a nested ring when hovering the parent wedge
- Properties: **SubMenuName**, **WedgeColor** (custom color), **IconBrushName** (icon)
- Can be nested (sub-menu within sub-menu, up to 4 levels)

#### Sequence
- Menu output + N menu input pins (children, 1–16)
- Executes multiple actions sequentially when the wedge is clicked
- Children fire in order (pin 0 first, then pin 1, etc.)
- Properties: **SequenceName**, **DelayMs** (delay in milliseconds between actions, 0–10000), **IconBrushName**, **IconTexture**

#### Subgraph
- Encapsulates a self-contained sub-graph inside a single node
- Each Subgraph node owns its own UEdGraph containing a TunnelEntry and a WheelOutput
- Exec input pin. Double-click to open the contained sub-graph
- Properties: **SubgraphName**
- Cannot be duplicated

#### TunnelEntry
- Entry point inside a Subgraph's sub-graph
- Automatically created when a Subgraph is created
- Single exec output pin
- Cannot be deleted or duplicated. One per sub-graph.

#### Comment
- Standard comment block for organizing the graph visually
- Supports custom colors via a color picker
- No effect on menu evaluation — purely organizational
- Press **C** with nodes selected to create one

### Switch Nodes (Context Routing)

#### Switch: Editor Context
Routes based on the active editor tab. Supports 49 contexts including:
- **General:** Level Editor, Content Browser
- **Blueprint:** Blueprint Editor, Widget Blueprint, Animation Blueprint
- **Visual:** Material Editor, Niagara, Texture, Font
- **Sequencing:** Sequencer, Control Rig
- **World:** PCG, Landscape (via editor mode)
- **Audio:** MetaSound, Sound Cue, Sound Class
- **Data:** DataTable, Curve, Struct, Enum
- **AI:** Behavior Tree, State Tree, Environment Query
- **Advanced:** IK Rig, IK Retarget, ML Deformer, Chooser, Dataflow
- **Custom:** User-defined tab ID (for third-party editor plugins)

Each context gets its own exec output pin. Unmatched contexts go to the Default pin.

#### Switch: Editor Mode
Routes based on the current editing mode:
- Default (Select), Landscape, Foliage, Mesh Paint, Placement, Fracture, Modeling Tools, Custom

#### Switch: Selection Count
Routes based on how many actors are selected in the viewport.
- User defines which counts (0, 1, 2, 5...) get dedicated outputs
- Unmatched counts go to Default

#### Switch: Actor Class
Routes based on the class of the selected actor.
- User adds actor class entries; each gets an output pin
- Supports subclass matching
- Unmatched classes go to Default

#### Switch: Blueprint Context
Routes based on the active panel in the Blueprint Editor:
- Components, Event Graph, Construction Script, Defaults, Custom

**Note:** All switch nodes support **Custom** cases with raw ID strings, allowing you to extend beyond the predefined options (e.g., custom tab IDs for third-party editor plugins, custom mode IDs, etc.).

### Shared Action Node Properties

All action nodes inherit from `UQMGraphNode_ActionBase` and share:
- **Label** (String) — display text on the wedge (auto-generated by default)
- **bAutoLabel** (bool, default true) — when true, label auto-updates from node properties
- **WedgeColor** (LinearColor, default Transparent) — custom wedge color in the pie menu
- **IconBrushName** (Name) — Slate brush icon (editor icons or `QuickMenu.*` custom brushes like `QuickMenu.GoToWheel`)
- **IconTexture** (Texture2D) — custom texture icon (overrides IconBrushName)

Icons prefixed with `QuickMenu.` are resolved from the QuickMenu style set rather than FAppStyle. The plugin ships with **~200 built-in SVG icons** in `Resources/Icones/`, all registered under the `QuickMenu.*` prefix (e.g., `QuickMenu.Play`, `QuickMenu.Compile`, `QuickMenu.TransformMove`). These are available in the icon picker dropdown on every action and SubMenu node, alongside standard Unreal Editor icons.

### Action Nodes — By Category

#### Spawn (2 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Spawn Actor** | Spawns an actor in front of the camera | Pick any actor class |
| **Spawn Shape** | Spawns a basic mesh primitive | Cube, Sphere, Cylinder, Cone, Plane |

#### Viewport (6 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Set View Mode** | Changes viewport rendering | Lit, Unlit, Wireframe, Detail Lighting, Lighting Only, Shader Complexity, Light Complexity, Path Tracing, Reflection Override, Collision (Pawn), Collision (Visibility), LOD Coloration |
| **Show Flag** | Toggles viewport overlays | Collision, Navigation, Fog, Bounds, Volumes, BSP, Billboard Sprites, Landscape, Post Process, Decals, Particles, Instanced Foliage, Grid, Mesh Edges, HLODs, Motion Blur, Temporal AA, Ambient Occlusion, Bloom, Deferred Lighting |
| **Toggle Snap** | Toggles grid snapping | Location, Rotation, Scale |
| **Grid Size** | Changes grid snap increment | Increase, Decrease |
| **Viewport View** | Sets camera orientation | Perspective, Top, Bottom, Front, Back, Left, Right |
| **Viewport Layout** | Changes viewport pane arrangement | 1 Pane, 2 Panes (Horizontal/Vertical), 3 Panes (Left/Right/Top/Bottom), 4 Panes (2x2) |

#### Transform (4 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Transform Mode** | Sets the transform gizmo | Translate, Rotate, Scale |
| **Coord Space** | Sets coordinate system | World, Local, Parent |
| **Select Op** | Selection operations | All, None, Invert, All of Same Class, All Lights, All Static Meshes, All Skeletal Meshes, Same Material, Immediate Children, All Descendants |
| **Reset Transform** | Resets actor transform | Reset All, Location, Rotation, Scale, Snap to Grid |

#### Actor Operations (4 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Actor Op** | Common actor operations | Focus Selected, Pilot Actor, Stop Piloting, Group, Ungroup, Lock, Unlock, Hide Selected, Unhide All, Snap to Floor, Isolate Selected, Mirror X/Y/Z, Snap Camera to Actor, Snap Actor to Camera, Attach to Last, Detach from Parent, Merge Actors, Convert to Blueprint |
| **Property Toggle** | Toggles actor properties | Cycle Mobility, Cycle Collision, Toggle Hidden In Game, Toggle Cast Shadows, Toggle Simulate Physics |
| **Align Op** | Alignment and snapping | Snap Origin to Grid, Align to Floor, Snap Pivot to Floor, Snap Bounds to Floor, Align to Actor, Snap to Actor |
| **Pivot Op** | Pivot point operations | Pivot to Center, Reset Pivot, Save Pivot, Reset Pre-Pivot, Pivot Here (Cursor), Pivot Here (Snapped) |

#### Editor (7 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Console Command** | Executes an arbitrary console command | User-defined command string |
| **Editor Command** | Viewport toggles | Toggle Grid, Toggle Realtime, Toggle Stats, Toggle Fullscreen, Toggle Game View, High-Res Screenshot, Toggle Viewport UI, Reset Show Flags, Toggle Cinematic |
| **Open Panel** | Opens an editor tab | Viewport, Details, World Outliner, Content Browser, Output Log, World Settings, Layers, Levels, Place Actors, Statistics, Message Log, Env Light Mixer, HLOD Outliner, Sequencer, Data Layers, Session Frontend, Device Manager |
| **Panel Instance** | Multi-instance panel ops | Add New or Close Last for: Viewport, Details, Scene Outliner, Content Browser |
| **Edit Op** | Basic edit operations | Undo, Redo, Duplicate, Delete, Copy, Paste, Project Settings, Editor Preferences, Plugins |
| **Editor Mode** | Switch editing mode | Select, Landscape, Foliage, Mesh Paint, Modeling, Fracture, Placement |
| **Bookmark Op** | Viewport bookmarks | Set, Jump To, or Clear bookmarks 0-9 |

#### Build & Level (2 actions)

| Action | What it does | Options |
|--------|-------------|---------|
| **Build** | Run build operations | Build All, Build Lighting, Build Navigation, Build Geometry, Build HLODs, Build Texture Streaming, Live Coding, Reflection Captures, Virtual Texture, Minimap, Landscape Splines, All Landscape, Recompile Shaders |
| **Level Op** | Level management | New Level, Open Level, Save Current Level, Save All, Import Asset, Export Selected, Fix Up Redirectors |

#### Play (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Play Op** | PIE session controls | Play, Simulate, Stop, Pause / Resume, Eject, Possess, Play (New Window), Standalone Game |

#### Scalability (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Scalability** | Engine quality settings | Quality: Low/Medium/High/Epic/Cinematic + Material Quality: Low/Medium/High |

#### Blueprint Actions (8 actions)

| Action | What it does | Notes |
|--------|-------------|-------|
| **BP: Add Component** | Adds a component to the active Blueprint | Pick any component class from dropdown |
| **BP: Component Op** | Operations on selected component | Delete, Duplicate, Rename, Make Root, Detach. Requires UE 5.0+ |
| **BP: Component Property** | Set component properties | Mobility, Visibility, Collision, Physics. Requires UE 5.0+ |
| **BP: Add Graph** | Adds a new graph | Function, Macro, Event Dispatcher |
| **BP: Add Variable** | Adds a typed variable | Bool, Byte, Int, Int64, Float, Double, Name, String, Text, Vector, Rotator, Transform |
| **BP: My Blueprint Op** | Panel item operations | Delete, Rename, Delete Unused Variables |
| **BP: Interface** | Interface management | Implement or Remove interface |
| **BP: Compile Op** | Compile and debug | Compile, Compile All, Save & Compile, Toggle Breakpoint, Clear All Breakpoints, Find References, Go to Parent Class, Open Class Settings |

#### Material Editor (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Material Op** | Material editor operations | Apply Changes, Refresh Previews, Delete Selected, Clean Unused, Toggle Live Preview, Toggle Stats, Preview: Plane/Cylinder/Sphere/Cube |

#### Sequencer (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Sequencer Op** | Sequencer controls | Play / Pause, Stop, Go to Start, Go to End, Step Forward, Step Backward, Toggle Loop, Speed: 0.25x/0.5x/1x/2x, Toggle Auto-Key, Refresh Tree, Force Evaluate, Save Sequence |

#### Static Mesh Editor (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Static Mesh Op** | Mesh editor operations | Add Box/Sphere/Capsule Collision, Auto Convex Collision, Remove All Collision, Generate LODs, Remove All LODs, Add Socket, Enable Nanite, Disable Nanite, Refresh, Save |

#### Niagara (1 action, conditional)

| Action | What it does | Options |
|--------|-------------|---------|
| **Niagara Op** | Niagara system controls | Compile, Reset Simulation, Toggle Looping, Speed: 0.25x/0.5x/1x/2x, Save |

Only visible when the Niagara plugin is loaded.

#### PCG (1 action, conditional)

| Action | What it does | Options |
|--------|-------------|---------|
| **PCG Op** | PCG graph operations | Execute, Clean, Flush Cache, Refresh, Toggle Debug |

Only visible when the PCG plugin is loaded.

#### Navigation & Utility (2 actions)

| Action | What it does | Notes |
|--------|-------------|-------|
| **Go To Wheel** | Navigates to another wheel in the current graph | Pick target wheel from dropdown. Creates a "breadcrumb" navigation — back arrow returns to previous wheel. Default icon: `QuickMenu.GoToWheel` |
| **Repeat Last** | Re-executes the last action used via Quick Menu | Label dynamically shows what the last action was |

#### Graph Editor (1 action)

| Action | What it does | Options |
|--------|-------------|---------|
| **Graph Op** | Quick Menu editor self-operations | Add Wheel Output, Add SubMenu, Add Switch, Auto-Layout Graph, Align Horizontal, Align Vertical, Collapse to SubMenu, Preview Wheel, Validate Graph, Set as Active Graph, Auto Name & Color Comments, Create Comment, Auto-Layout++, Remove Unused Pins |

#### Custom Code / Python (1 action, conditional)

| Action | What it does |
|--------|-------------|
| **Custom Code** | Run inline Python code when the wedge is clicked |

**Properties:**
- **Execute Code** — Python code to run on click
- **Display Name Code** — Python expression returning a string (dynamic label)
- **Is Visible Code** — Python expression returning bool (conditional visibility)

Only available when the Python Editor Script Plugin is enabled.

**Example — Toggle wireframe overlay on selected actor:**
```python
# Execute Code
actor = unreal.EditorLevelLibrary.get_selected_level_actors()[0]
current = actor.get_editor_property('bWireframe')
actor.set_editor_property('bWireframe', not current)
```

---

## The Graph Editor

### Opening the Editor
- Double-click a Quick Menu Graph asset in the Content Browser
- Or: right-click a graph asset → "Edit"

### Editor Layout

The editor has 4 panels:

1. **Graph Canvas** (center) — the main node graph. Drag, zoom, connect nodes. Right-click for context menu to add nodes.
2. **Wheel List** (left sidebar) — lists all WheelOutput nodes grouped by category. Click to focus, drag to reorder, right-click for options.
3. **Preview** (right sidebar) — live pie menu preview of the selected wheel. Interactive — you can click wedges to test.
4. **Find Results** (bottom, toggled with Ctrl+F) — search across all nodes in the graph.

### Creating a Graph

1. Content Browser → Add → Quick Menu → Quick Menu Graph
2. Double-click to open
3. The Root node is already placed
4. Right-click canvas → add a WheelOutput node
5. Connect Root exec out → WheelOutput exec in
6. Right-click canvas → add action nodes
7. Connect action nodes to WheelOutput menu pins (blue)
8. Go to Project Settings → Plugins → Quick Menu → set your graph as Active Graph

### Working with Nodes

- **Add node:** Right-click canvas → browse or search categories
- **Delete node:** Select → Delete key (Root cannot be deleted)
- **Connect pins:** Drag from output pin to input pin
- **Disconnect:** Right-click pin → Break Link, or drag pin away
- **Node shortcuts:** Hold a key + click canvas to spawn a preconfigured node (set up in Project Settings)
- **Compact mode:** Right-click node → Toggle Compact (smaller visual footprint)
- **Auto-label:** Most nodes auto-generate their label from their properties (e.g., a TransformMode node set to Translate will display "Translate" automatically). Toggle `bAutoLabel` off to set a custom label instead.

### Customizing Wedge Appearance

Every action node has properties that control how its wedge looks in the pie menu:

- **Label** — the text displayed on the wedge. Auto-generated by default (see Auto-label above), or set manually.
- **Wedge Color** — the fill color of the wedge. Each node can have its own color, making categories visually distinct.
- **Icon** — two options:
  - **IconBrushName** — pick any built-in Slate icon (e.g., editor icons, tool icons)
  - **IconTexture** — assign a custom UTexture2D for a fully custom icon
- **Compact mode** — toggles between a full-size and compact node display in the graph editor (H key or right-click → Toggle Compact)

These properties are editable in the Details panel when a node is selected in the graph editor.

### Wheel List Panel (Left Sidebar)

The Wheel List displays all WheelOutput nodes in your graph, organized by category. It's the primary way to navigate a large graph with many wheels.

**Features:**
- **Click a wheel** to select it in the graph canvas and show it in the preview
- **Double-click** to enter Focus Mode (see below)
- **Drag a wheel** up/down to reorder within its category
- **Drag a wheel onto a category header** to move it to that category
- **Multi-select** with Shift (range) or Ctrl (toggle) — useful for bulk operations
- **Search/filter box** at the top — type to filter wheels by name
- **Right-click a wheel** → Rename, Delete, Move to Category
- **Right-click a category header** → Rename, Change Color, Change Icon, Delete Category, New Category

**Category system:**
- Categories are collapsible groups with a colored header
- Each category can have a custom color and icon
- Wheels without a category appear in "Uncategorized"
- New categories auto-create when you drag a wheel to the "Drop here for new category" zone
- Category state (collapsed/expanded) persists between sessions

**Pin auto-naming:** When you connect an action node to a WheelOutput menu pin, the pin's friendly name updates to match the action label. This means the Wheel List shows meaningful names like "Translate", "Rotate" rather than "Pin 0", "Pin 1".

### Preview Panel (Right Sidebar)

The Preview panel shows a live, interactive rendering of the selected wheel as a pie menu.

**Features:**
- **Live updates** — any change in the graph (add node, connect pin, change property) is reflected in the preview after a short debounce
- **Interactive** — click wedges to test actions (they execute for real), hover to see highlights
- **"+" button** — add actions to the wheel directly from the preview (opens action picker)
- **"X" buttons** — remove wedges inline
- **Scale slider** — at the bottom, drag to preview the pie menu at different sizes (1.0x to 2.0x)
- **Sub-menu expansion** — hover a sub-menu wedge to see its children expand as nested rings
- **Toggleable** — show/hide with the toolbar button or Ctrl+E

**What it shows:**
- When a WheelOutput is selected: that wheel's wedges with labels, icons, and colors
- When a single action node is selected: a temporary preview with just that action
- When nothing relevant is selected: the last previewed wheel

### Find Results Panel (Bottom)

Opened with **Ctrl+F**. Search across all nodes in the current graph.

- Type a query and press Enter — results list all matching nodes with their type and name
- **Double-click a result** to zoom the graph canvas to that node and select it
- Search matches node names, labels, and property values (e.g., searching "Translate" finds TransformMode nodes set to Translate)
- Results show a badge indicating which subgraph/asset the node belongs to (useful in graphs with SubMenu references)
- The panel stays open until you close it or press Ctrl+F again

### Focus Mode

- Double-click a WheelOutput in the Wheel List to enter **Focus Mode**
- Only that wheel's connected nodes are highlighted; everything else fades
- The preview panel shows that wheel
- Click the breadcrumb bar or press Escape to exit

### Comment Nodes

- Press **C** with nodes selected to create a group comment around them
- Double-click to rename
- Click the color swatch in the title bar to change the comment color
- Resizable — drag edges to fit your node group
- Standard UE comment node behavior (visual grouping, no effect on execution)

---

## Keyboard Shortcuts & UX

### Pie Menu

| Key | Action |
|-----|--------|
| **V** (configurable) | Open pie menu at cursor |
| **Left Click** | Execute hovered wedge |
| **Right Click** | Go back to parent menu / dismiss |
| **Escape** | Close menu |
| **Mouse Wheel** | Zoom pie menu |
| **Ctrl+Z** | Undo last action (refreshes menu) |
| **Ctrl+Y** | Redo (refreshes menu) |
| **E** (configurable) | Jump to graph editor for current wheel |

### Graph Editor — Navigation

| Key | Action |
|-----|--------|
| **Escape** | Exit focus mode or subgraph |
| **Backspace** | Navigate back to parent graph |
| **Shift+Space** | Jump directly to root graph |
| **Ctrl+F** | Find in graph (search nodes by name) |
| **Ctrl+E** | Toggle preview panel |

### Graph Editor — Node Spawn (Hold + Click)

Hold the key, then click on the canvas to spawn a node at that position:

| Key | Spawns |
|-----|--------|
| **W + Click** | WheelOutput node |
| **S + Click** | SubMenu node |
| **C + Click** | Switch: Editor Context node |

These are the defaults — fully customizable in Project Settings → Quick Menu → Node Spawn Shortcuts. You can add your own key → node class mappings.

### Graph Editor — Node Operations

| Key | Action |
|-----|--------|
| **C** | Create group comment around selected nodes |
| **H** | Toggle compact/expanded display on selected node |
| **F2** | Rename selected wheel |
| **Ctrl+C** | Connect selected action nodes to selected WheelOutput/SubMenu (auto-wires them) |
| **=** | Add a menu pin to selected WheelOutput/SubMenu |
| **-** | Remove last menu pin from selected WheelOutput/SubMenu |
| **Shift+Ctrl+N** | Create new wheel category |
| **Shift+Ctrl+A** | Select all wheels in wheel list |

### Graph Editor — Standard Editing

| Key | Action |
|-----|--------|
| **Ctrl+Z / Ctrl+Y** | Undo / Redo |
| **Delete** | Delete selected nodes |
| **Ctrl+A** | Select all |
| **Ctrl+C / Ctrl+X / Ctrl+V** | Copy / Cut / Paste |
| **Ctrl+D** | Duplicate |

### Smart Auto-Wiring

When you spawn a WheelOutput or SubMenu with nodes already selected:
1. Quick Menu detects your selected action/submenu nodes
2. Automatically grows the new node's menu pins to match
3. Wires them in visual order (top-to-bottom, left-to-right)

This means: select 5 action nodes → press W + click → instant wheel with all 5 connected.

**Ctrl+C** does the same for existing nodes: select actions + a WheelOutput → Ctrl+C → all wired up.

---

## Quick Menu Panel

The Quick Menu Panel is a dockable editor tab (Window → Quick Menu Panel) that serves as a central hub for configuration and support.

### Panel Sections

**Header:**
- **Active Graph dropdown** — quickly switch which graph is active without going to Project Settings
- **Activation Mode selector** — Click & Release / Click Only / Release Only, changeable directly from the panel
- Support links: Discord, GitHub, Wiki (clickable icons)

**Tab 1 — Shortcuts:**
- Lists all keyboard shortcuts organized by section (Pie Menu, Node Spawn, Graph Editor)
- Each shortcut has an editable key binding badge — click it, press a new key to rebind
- Reset button appears when a binding has been changed from default
- Node Spawn shortcuts show the hold+click shortcuts (W, S, C by default)

**Tab 2 — Docs:**
- Built-in documentation of all node types and action types
- Organized by category, browsable in-editor

**Tab 3 — Console Commands:**
- Lists custom console commands defined in Project Settings
- Toggle commands on/off with one click
- Edit command values inline (commands with parameters show editable value fields, not just Run buttons)
- Tracks last-applied values and can reset to initial CVar values
- Add/remove custom commands

### Support Links

| Link | URL |
|------|-----|
| Discord | https://discord.gg/YYc2v8k5BA |
| GitHub | https://github.com/Bassounet/QuickMenu-Plugin |
| Wiki | https://github.com/Bassounet/QuickMenu-Plugin/wiki |

Report bugs via GitHub Issues. Join Discord for community support and feature requests.

---

## The Pie Menu

### Opening
Press **V** (or your configured hotkey) anywhere in the editor. The pie menu appears centered at your cursor.

### Navigation
- **Hover** over a wedge to highlight it
- **Click** (or release V, depending on activation mode) to execute the action
- **Sub-menus** expand as nested rings when you hover their parent wedge
- **Back arrow** appears at the center when inside a sub-menu — click to go back
- **Go To Wheel** wedges navigate to another wheel (with breadcrumb history)
- **Submenu indicator** — wedges that are sub-menus or GoToWheel actions show a thin bright arc just outside their outer edge, visually distinguishing them from leaf action wedges
- **Remove confirmation** — the X button on wedges requires two clicks (first click shows confirmation state, second click removes)
- **Warning toast** — when an action can't execute, a shake animation overlay appears on the hovered wedge
- **Mouse wheel** can scroll through options in some contexts
- **Move cursor to center** (dead zone) to deselect all

### Activation Modes (Project Settings)
- **Click and Release** (default) — hover over wedge, release mouse/key to execute
- **Click Only** — click on wedge to execute
- **Release Only** — release the V key to execute whatever is hovered

### Dismissing
- Click outside the menu
- Press Escape
- Press V again (in some modes)
- Click the dead zone center
- Switch focus to another window

### Editing Directly from the Pie Menu

The pie menu is not just a launcher — it's also a live editor. When previewing a wheel in the graph editor or using it in the editor:

- **"+" button** — appears on the wheel when there's room for more wedges. Click to open the action picker overlay and add a new action directly to the current wheel, without going back to the graph.
- **"X" button** — appears on removable wedges. Click to remove an action from the wheel inline.
- **E key** (configurable) — press while the pie menu is open to jump straight to the graph editor, focused on the current wheel.

This means you have two workflows for building menus:
1. **Graph-first:** Open the graph editor, add nodes, connect pins, see the result in preview
2. **Wheel-first:** Press V, see what's there, add/remove actions inline, press E to fine-tune in the graph

Both workflows edit the same underlying graph — changes made inline are reflected in the graph, and vice versa.

### Context-Aware Behavior
When you press V, Quick Menu evaluates your graph:
1. Starts at Root
2. Follows Switch nodes based on current context
3. Reaches a WheelOutput
4. Displays that wheel's actions

If no wheel matches the current context, Quick Menu can:
- Fall back to a Default wheel (if one exists)
- Show a **"Create Wheel" panel** — a guided flow that offers to create a new wheel for the detected context

### The "Create Wheel" Flow

When you press V in a context that has no matching wheel (e.g., you open the Material Editor for the first time):

1. Instead of showing an empty menu, Quick Menu shows a panel saying "No wheel found for: Material Editor"
2. A "Create Wheel" button lets you instantly create a WheelOutput node wired to the correct Switch case
3. The new wheel opens in the graph editor, ready to be populated with actions
4. Next time you press V in that context, your new wheel appears

This is configurable: **Project Settings → Offer Create Wheel** (on by default). When off, unmatched contexts fall back to the Default output silently.

### Multiple Graphs and "Set as Active"

You can create multiple Quick Menu Graph assets — each with its own logic, wheels, and switch routing. Only one graph is active at a time.

**Where to set the active graph:**
- **Project Settings** → Plugins → Quick Menu → Active Graph
- **Quick Menu Panel** → Active Graph dropdown in the header
- **Content Browser** → right-click a graph asset → "Set as Active Menu" (UE 5.0+)
- **Graph Editor** → Graph Op action → "Set as Active Graph"

**Why multiple graphs?**
- Different graphs for different workflows (modeling vs. level design vs. cinematics)
- A "simple" graph with just the basics and an "advanced" graph with everything
- Team members can have personal graphs while sharing the same project
- Quick switching via the Panel dropdown — no need to dig into settings

---

## Project Settings

Found at: **Edit → Project Settings → Plugins → Quick Menu**

| Setting | Default | Description |
|---------|---------|-------------|
| **Active Graph** | None | The Quick Menu Graph asset to use. Must be set for the menu to work. |
| **Open Menu Key** | V | Hotkey to open the pie menu |
| **Edit Wheel Key** | E | Hotkey to jump from pie menu to graph editor for the current wheel |
| **Activation Mode** | Click and Release | When the hovered wedge executes (see Activation Modes above) |
| **Node Spawn Shortcuts** | Empty | List of key + node class pairs for quick node creation in the graph editor |
| **Offer Create Wheel** | true | Show "Create Wheel" panel when no wheel matches the current context |
| **Custom Console Commands** | Empty | User-defined console commands available in the Quick Menu panel |

---

## Python Custom Code Examples

These examples work with the **Custom Code** action node. Requires the Python Editor Script Plugin to be enabled.

### 1. Toggle Wireframe on Selected Actor
```python
# Execute Code
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
if actors:
    a = actors[0]
    comp = a.get_component_by_class(unreal.StaticMeshComponent)
    if comp:
        comp.set_editor_property('bWireframe', not comp.get_editor_property('bWireframe'))
```

### 2. Randomize Rotation of All Selected Actors
```python
import random
for actor in unreal.EditorLevelLibrary.get_selected_level_actors():
    rot = unreal.Rotator(0, random.uniform(0, 360), 0)
    actor.set_actor_rotation(rot, False)
```

### 3. Scatter Selected Actors Randomly in a Radius
```python
import random
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
for a in actors:
    loc = a.get_actor_location()
    loc.x += random.uniform(-500, 500)
    loc.y += random.uniform(-500, 500)
    a.set_actor_location(loc, False, False)
```

### 4. Select All Actors of the Same Class as Current Selection
```python
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
if actors:
    cls = actors[0].get_class()
    all_actors = unreal.EditorLevelLibrary.get_all_level_actors()
    same = [a for a in all_actors if a.get_class() == cls]
    unreal.EditorLevelLibrary.set_selected_level_actors(same)
```

### 5. Log Selected Actor Properties (Quick Debug)
```python
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
if actors:
    a = actors[0]
    unreal.log(f"Name: {a.get_name()}")
    unreal.log(f"Class: {a.get_class().get_name()}")
    unreal.log(f"Location: {a.get_actor_location()}")
    unreal.log(f"Scale: {a.get_actor_scale3d()}")
```

### 6. Align All Selected Actors to the Same Z Height
```python
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
if len(actors) > 1:
    target_z = actors[0].get_actor_location().z
    for a in actors[1:]:
        loc = a.get_actor_location()
        loc.z = target_z
        a.set_actor_location(loc, False, False)
```

### 7. Rename Selected Actors Sequentially
```python
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
for i, a in enumerate(actors):
    a.set_actor_label(f"Prop_{i:03d}")
```

### 8. Create a Ring of Actors Around Selection
```python
import math
actors = unreal.EditorLevelLibrary.get_selected_level_actors()
if actors:
    center = actors[0].get_actor_location()
    radius = 500
    count = 8
    for i in range(count):
        angle = (2 * math.pi / count) * i
        loc = unreal.Vector(center.x + radius * math.cos(angle), center.y + radius * math.sin(angle), center.z)
        unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.StaticMeshActor, loc)
```

### 9. Toggle Collision on All Selected Actors
```python
for actor in unreal.EditorLevelLibrary.get_selected_level_actors():
    comp = actor.get_component_by_class(unreal.PrimitiveComponent)
    if comp:
        enabled = comp.get_editor_property('bGenerateOverlapEvents')
        comp.set_editor_property('bGenerateOverlapEvents', not enabled)
```

### 10. Dynamic Label — Show Selection Count
Use this in the **Display Name Code** field (not Execute Code):
```python
# Display Name Code (returns string)
count = len(unreal.EditorLevelLibrary.get_selected_level_actors())
result = f"Selected: {count} actor{'s' if count != 1 else ''}"
```

### 11. Conditional Visibility — Only Show When in Landscape Mode
Use this in the **Is Visible Code** field:
```python
# Is Visible Code (returns bool)
result = unreal.EditorLevelLibrary.get_editor_world() is not None
# For landscape mode specifically, check the active mode:
import unreal
result = "Landscape" in str(unreal.get_editor_subsystem(unreal.EditorActorSubsystem))
```

---

## Troubleshooting

### "Nothing happens when I press V"
1. Check Project Settings → Quick Menu → Active Graph is set
2. Verify the graph has a Root node connected to at least one WheelOutput
3. If using Switch nodes, make sure the current context has a matching output (or a Default connection)

### "Menu shows wrong actions for this editor"
1. Open your graph and check your Switch node connections
2. Verify the Switch type matches what you're trying to detect (Editor Context vs. Editor Mode vs. Selection Count)
3. Add the missing context as a case on the Switch node

### "Python action doesn't work"
1. Ensure the **Python Editor Script Plugin** is enabled in Plugin settings
2. Check the Output Log for Python errors
3. Test your code in the Python console first (Window → Developer Tools → Python Console)

### "Some actions are grayed out"
- Blueprint actions (Component Op, Component Property) require a Blueprint Editor to be open with a component selected
- Niagara/PCG actions only appear when those plugins are enabled
- Some actions require a specific selection state (e.g., Actor Op → Group requires multiple actors selected)

### "How do I create a context-aware menu?"
1. Add a Switch node (e.g., Switch: Editor Context)
2. Add the contexts you want as cases
3. Connect each case output to a different WheelOutput
4. Each WheelOutput can have different actions
5. Connect a Default output for unmatched contexts

### "How do I create nested sub-menus?"
1. Add a SubMenu node
2. Connect action nodes to the SubMenu's menu input pins
3. Connect the SubMenu's menu output to a WheelOutput menu pin
4. When hovering that wedge, children expand as a nested ring

### "Wedge limit reached"
Each wheel supports a maximum of 10 wedges. Use SubMenu nodes to group related actions and reduce top-level wedge count.

---

## Version Compatibility

| Feature | UE 4.27 | UE 5.0-5.1 | UE 5.2-5.4 | UE 5.5-5.7 |
|---------|---------|-------------|-------------|-------------|
| Core pie menu | Yes | Yes | Yes | Yes |
| Graph editor | Yes | Yes | Yes | Yes |
| All Switch nodes | Yes | Yes | Yes | Yes |
| Most action nodes | Yes | Yes | Yes | Yes |
| BP: Component Op | No | Yes | Yes | Yes |
| BP: Component Property | No | Yes | Yes | Yes |
| Custom Code (Python) | Requires Python plugin | Requires Python plugin | Requires Python plugin | Requires Python plugin |
| Content Browser context menu | No | Yes | Yes | Yes |
| Asset Definition (thumbnails) | No | No (5.1+ only) | Yes | Yes |

---

## Video Index

| # | Title | Duration | Topic | Link |
|---|-------|----------|-------|------|
| 1 | Quick Menu in 2 Minutes | 2 min | Install, press V, first impression | TBD |
| 2 | Creating Your First Wheel | 5 min | Graph editor, Root, WheelOutput, adding actions | TBD |
| 3 | Context-Aware Menus | 5 min | Switch nodes, dynamic menus based on selection | TBD |
| 4 | SubMenus & Nested Wheels | 4 min | SubMenu node, composition, organization | TBD |
| 5 | Python Actions | 4 min | CustomCode node, practical examples | TBD |
| 6 | Blueprint Actions | 5 min | ComponentOp, ComponentProperty | TBD |
| 7 | Advanced Graph Patterns | 7 min | Combining everything, advanced patterns | TBD |

---

## For Developers — C++ Class Reference

This section maps user-facing features to C++ classes for developers who want to extend Quick Menu.

### Core Architecture

| Class | Role |
|-------|------|
| `FQuickMenuModule` | Module startup, V hotkey registration, opens pie overlay |
| `UQuickMenuSettings` | UDeveloperSettings — project settings |
| `UQuickMenuGraphAsset` | UObject owning the UEdGraph |
| `FQuickMenuGraphSchema` | Pin types, connection rules, context menus |
| `FQuickMenuGraphEvaluator` | Walks graph → TArray<FQuickMenuItem> |
| `SQuickMenuWidget` | SLeafWidget — pie menu rendering and interaction |
| `FQuickMenuGraphAssetEditor` | FAssetEditorToolkit — graph editor |

### Node Classes

| Class | User-Facing Name |
|-------|-----------------|
| `UQMGraphNode_Root` | Root |
| `UQMGraphNode_WheelOutput` | WheelOutput |
| `UQMGraphNode_SubMenu` | SubMenu |
| `UQMGraphNode_SwitchEditorContext` | Switch: Editor Context |
| `UQMGraphNode_SwitchEditorMode` | Switch: Editor Mode |
| `UQMGraphNode_SwitchSelectionCount` | Switch: Selection Count |
| `UQMGraphNode_SwitchActorClass` | Switch: Actor Class |
| `UQMGraphNode_SwitchBlueprintContext` | Switch: Blueprint Context |

### Action Base Class

All action nodes inherit from `UQMGraphNode_ActionBase`, which provides:
- `Label` (FString) — display name
- `IconBrushName` (FName) — Slate icon
- `IconTexture` (UTexture2D*) — custom icon texture
- `WedgeColor` (FLinearColor) — wedge color
- `bCompact` (bool) — compact display mode
- `bAutoLabel` (bool) — auto-generate label from properties

### Creating a Custom Action Node

1. Create a class inheriting from `UQMGraphNode_ActionBase`
2. Override `Resolve()` — called when the wedge is clicked
3. Override `GetDisplayLabel()` — returns the wedge label text
4. Override `GetNodeTitle()` — returns the node title in the graph editor
5. Optionally override `IsActionVisible()` — controls whether the wedge appears
6. Register in `QMActionRegistry.cpp` → `RegisterActions()`

### Action Node → Class Mapping

| Action | C++ Class |
|--------|-----------|
| Spawn Actor | `UQMGraphNode_Action_SpawnActor` |
| Spawn Shape | `UQMGraphNode_Action_SpawnShape` |
| Set View Mode | `UQMGraphNode_Action_SetViewMode` |
| Console Command | `UQMGraphNode_Action_ConsoleCommand` |
| Toggle Snap | `UQMGraphNode_Action_ToggleSnap` |
| Grid Size | `UQMGraphNode_Action_GridSize` |
| Transform Mode | `UQMGraphNode_Action_TransformMode` |
| Coord Space | `UQMGraphNode_Action_CoordSpace` |
| Select Op | `UQMGraphNode_Action_SelectOp` |
| Play Op | `UQMGraphNode_Action_PlayOp` |
| Editor Command | `UQMGraphNode_Action_EditorCommand` |
| Open Panel | `UQMGraphNode_Action_OpenPanel` |
| Panel Instance | `UQMGraphNode_Action_PanelInstance` |
| Editor Mode | `UQMGraphNode_Action_EditorMode` |
| Build | `UQMGraphNode_Action_Build` |
| Level Op | `UQMGraphNode_Action_LevelOp` |
| Actor Op | `UQMGraphNode_Action_ActorOp` |
| Edit Op | `UQMGraphNode_Action_EditOp` |
| Reset Transform | `UQMGraphNode_Action_ResetTransform` |
| Property Toggle | `UQMGraphNode_Action_PropertyToggle` |
| Show Flag | `UQMGraphNode_Action_ShowFlag` |
| Viewport View | `UQMGraphNode_Action_ViewportView` |
| Viewport Layout | `UQMGraphNode_Action_ViewportLayout` |
| Scalability | `UQMGraphNode_Action_ScalabilityOp` |
| Align Op | `UQMGraphNode_Action_AlignOp` |
| Pivot Op | `UQMGraphNode_Action_PivotOp` |
| Bookmark Op | `UQMGraphNode_Action_BookmarkOp` |
| Material Op | `UQMGraphNode_Action_MaterialOp` |
| Sequencer Op | `UQMGraphNode_Action_SequencerOp` |
| Static Mesh Op | `UQMGraphNode_Action_StaticMeshOp` |
| Niagara Op | `UQMGraphNode_Action_NiagaraOp` |
| PCG Op | `UQMGraphNode_Action_PCGOp` |
| BP: Add Component | `UQMGraphNode_Action_BP_AddComponent` |
| BP: Component Op | `UQMGraphNode_Action_BP_ComponentOp` |
| BP: Component Property | `UQMGraphNode_Action_BP_ComponentProperty` |
| BP: Add Graph | `UQMGraphNode_Action_BP_AddGraph` |
| BP: Add Variable | `UQMGraphNode_Action_BP_AddVariable` |
| BP: My Blueprint Op | `UQMGraphNode_Action_BP_MyBlueprintOp` |
| BP: Interface | `UQMGraphNode_Action_BP_Interface` |
| BP: Compile Op | `UQMGraphNode_Action_BP_CompileOp` |
| Go To Wheel | `UQMGraphNode_Action_GoToWheel` |
| Repeat Last | `UQMGraphNode_Action_RepeatLast` |
| Graph Op | `UQMGraphNode_Action_GraphOp` |
| Custom Code | `UQMGraphNode_Action_CustomCode` |

---

## Links

- Website: https://quickmenuplugin.com
- Documentation: https://docs.quickmenuplugin.com
- Discord: https://discord.gg/YYc2v8k5BA
- GitHub: https://github.com/Bassounet/QuickMenu-Plugin
- Wiki: https://github.com/Bassounet/QuickMenu-Plugin/wiki
- YouTube: TBD
- UE Marketplace: TBD