<!--
    The dropdown kit — our own implementation of the 1.12 dropdown widget set. The reference
    (FrameXML UIDropDownMenuTemplates.xml + UIDropDownMenu.lua) is the SPECIFICATION it answers to,
    not the source of this text: the global names, the `info` table's field names, every geometry
    constant and every observable behaviour below are the reference's and are load-bearing (addons
    call, replace and read them by name); the code that expresses them is ours, and is written the
    way we would write it — shared helpers, field lists and lookup tables where the reference
    repeats itself. Decision 0203 phase 2's closing sub-slice, widened for decision 0434 phase 5:
    the unit popups are the first MENU-mode + submenu customer; the world map's continent/zone
    pickers and the trainer/tradeskill filters stay on the level-1 capsule path.

    IN: UIDropDownMenuTemplate (the capsule: LabelFrame art trio, $parentText, the scroll-down
    toggle button), UIDropDownMenuButtonTemplate (row: highlight, check, right-side icon, expand
    arrow, the disabled-row InvisibleButton), UIDropDownListTemplate (Backdrop + MenuBackdrop
    swap, 32 rows) instanced as DropDownList1/2, and the reference API: Initialize (displayMode +
    level), AddButton(info, level) with isTitle/disabled/notClickable/notCheckable/hasArrow/
    icon+texcoords/textR-G-B/justifyH/keepShownOnClick, Refresh, SetWidth/SetText/GetText,
    SetSelectedID/Name/Value + getters, ClearAll, ToggleDropDownMenu(level, value, frame,
    anchorName ["cursor" included], x, y) with the off-screen flip, HideDropDownMenu,
    CloseDropDownMenus(level), Disable/EnableButton, SetButtonText, SetAnchor, JustifyText,
    GetCurrentDropDown, the 2-second hover-away auto-close counting through the level chain.

    THE COLOR SWATCH ROW came in with the colour picker (ColorPickerFrame.xml): the full
    `hasColorSwatch` / `r` / `g` / `b` / `swatchFunc` / `hasOpacity` / `opacity` / `opacityFunc` /
    `cancelFunc` field set, the `$parentColorSwatch` button on the row template, and
    `UIDropDownMenuButton_OpenColorPicker` (spec: UIDropDownMenu.lua l.801-815). It is the second
    half of one feature, not a separate one: `hasColorSwatch` draws the square, clicking the square
    is the ONLY way the reference's colour picker ever opens, and `hasColorSwatch` is **145 files /
    82 corpus addons**.

    OUT (each waits for its first customer): menu level 3 (UIDROPDOWNMENU_MAXLEVELS is 2 — the
    unit popups' deepest law; the XML gains DropDownList3 the day a customer needs it),
    info.textHeight's per-row SetFont, the newbie
    tooltips on rows (the ref gates them behind a default-off cvar), message() on the row/level
    overflow guards (no dev-error dialog surface; the guard returns silently). The uiScale
    correction came IN with its first scaled customer (0992, the options window's dropdown
    rows): Toggle wears the owner's effective scale on the list.

    Deviations, deliberate:
    - THE WIDTH SETTLE. The ref sizes each row at AddButton time from normalText:GetWidth() and
      applies the list max in OnShow — but our text measures land at extract, AFTER the script
      tick that set the text (ui_script/extract's measure round-trip), so an AddButton-time
      read is stale. The ref's width FORMULA (text + 60, arrow +10, icon +10, notCheckable -30,
      list = max + 15) runs in the list's OnUpdate instead and applies on the first update
      whose measures are real — one frame after open, imperceptible. A capsule that declared a
      width (UIDropDownMenu_SetWidth → dropWidth/noResize: the world map pickers) keeps the
      declared width applied synchronously at Toggle, the proven pre-0434 path (rows dropWidth,
      list dropWidth + 32).
    - THE FLIP SETTLES TOO: the off-screen check needs the list's resolved rect, which also
      lands a frame late — it runs from the same OnUpdate chain, after the width applies.
    - The default (no anchorName) seat anchors the list to the dropdown FRAME at (8, 7) —
      pixel-identical to the reference's "$parentLeft BOTTOMLEFT (8, 22)" through the Left
      texture's own (0, 17) seat.
    - MENU displayMode hides the capsule art trio when present but skips the ref's toggle-button
      texture blanking + re-anchor (every MENU customer here is a born-hidden 10x10 frame whose
      capsule never draws).
    - (Was: "the disabled-row InvisibleButton spans to the row's RIGHT — the ref stops it at the
      color swatch, which is OUT". The swatch is IN now, so the ref's own anchor is restored:
      `RIGHT relativeTo="$parentColorSwatch" relativePoint="LEFT"`.)
    - The list OnShow resets showTimer AND isCounting (the ref writes `showTime`, a field
      nothing reads — we implement the intent, not the typo).
-->
<Ui xmlns="http://www.blizzard.com/wow/ui/">
    <Script><![CDATA[
        UIDROPDOWNMENU_MAXBUTTONS = 32;
        UIDROPDOWNMENU_MAXLEVELS = 2;
        UIDROPDOWNMENU_BUTTON_HEIGHT = 16;
        UIDROPDOWNMENU_BORDER_HEIGHT = 15;
        UIDROPDOWNMENU_OPEN_MENU = nil;
        UIDROPDOWNMENU_INIT_MENU = nil;
        UIDROPDOWNMENU_MENU_LEVEL = 1;
        UIDROPDOWNMENU_MENU_VALUE = nil;
        UIDROPDOWNMENU_SHOW_TIME = 2;
        -- Which menus are open, keyed by level. UnitPopup writes it and its OnUpdate enable/disable
        -- pass walks it; each list's own OnHide clears its entry.
        OPEN_DROPDOWNMENUS = {};

        -- ── The kit's vocabulary ──────────────────────────────────────────────────────────────
        -- Four things this file says over and over, said once here.

        -- Every named child in the kit is `<owner's name><suffix>`: a row's Check/NormalText/Icon/
        -- ExpandArrow/ColorSwatch/InvisibleButton, a capsule's Left/Middle/Right/Text/Button, the
        -- swatch's NormalTexture. (The reference spells this two different ways for the same
        -- object — off the list name plus the row index, and off the row itself.)
        local function menuChild(frame, suffix)
            return getglobal(frame:GetName()..suffix);
        end

        -- A row addressed the way the by-address API addresses it: level + index.
        local function listRow(level, index)
            return getglobal("DropDownList"..level.."Button"..index);
        end

        -- The `info` fields a row simply carries. AddButton copies them onto the row so the row's
        -- own handlers — its click, the width settle, the colour square — can read them back later.
        -- These names are the published API: the list is the documentation.
        local ROW_FIELDS = {
            "func", "owner", "arg1", "arg2", "keepShownOnClick", "tooltipTitle", "tooltipText",
            "hasArrow", "notCheckable", "icon",
            "hasColorSwatch", "hasOpacity", "opacity", "opacityFunc", "swatchFunc", "cancelFunc",
        };

        -- A capsule remembers its selection under exactly one of these; adopting one drops the
        -- other two, which is why they can never disagree.
        local SELECTION_KEYS = { "selectedName", "selectedID", "selectedValue" };

        -- The capsule's three-piece LabelFrame art.
        local CAPSULE_ART = { "Left", "Middle", "Right" };

        -- Reset the levels this dropdown is about to rebuild, remember + run its init function,
        -- then apply displayMode. A DIFFERENT dropdown taking the menu over resets the whole stack
        -- from level 1; the same one keeps whatever sits above the level it is rebuilding.
        function UIDropDownMenu_Initialize(frame, initFunction, displayMode, level)
            frame = frame or this;
            local name = frame:GetName();
            local takeover = (name ~= UIDROPDOWNMENU_OPEN_MENU);
            if ( takeover ) then
                UIDROPDOWNMENU_MENU_LEVEL = 1;
            end
            UIDROPDOWNMENU_INIT_MENU = name;
            for i = 1, UIDROPDOWNMENU_MAXLEVELS, 1 do
                if ( takeover or i >= UIDROPDOWNMENU_MENU_LEVEL ) then
                    local list = getglobal("DropDownList"..i);
                    list.numButtons = 0;
                    for j = 1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                        listRow(i, j):Hide();
                    end
                end
            end
            frame:SetHeight(UIDROPDOWNMENU_BUTTON_HEIGHT * 2);
            if ( initFunction ) then
                frame.initialize = initFunction;
                initFunction(level);
            end
            if ( displayMode == "MENU" ) then
                -- Drop the capsule art, when the frame has any (see the header deviation).
                if ( getglobal(name.."Left") ) then
                    for _, part in ipairs(CAPSULE_ART) do
                        getglobal(name..part):Hide();
                    end
                end
                frame.displayMode = "MENU";
            end
        end

        -- The reference's width law, run from the list's OnUpdate (the header's WIDTH SETTLE): rows
        -- measure text + 60, +10 for an arrow OR a colour swatch, +10 for an icon, -30 when
        -- notCheckable; the list takes max + 15. Waits until every text row has a real (nonzero)
        -- measure. (The ref's `if ( info.hasArrow or info.hasColorSwatch )` is ONE +10, not two —
        -- the two ride the same right-hand slot, and a row never has both.)
        function UIDropDownMenu_SettleWidth(listFrame)
            local listFrameName = listFrame:GetName();
            if ( listFrame.fixedWidth ) then
                listFrame.pendingWidth = nil;
                return;
            end
            local maxWidth = 0;
            local want, seen = 0, 0;
            for i=1, listFrame.numButtons, 1 do
                local button = getglobal(listFrameName.."Button"..i);
                local text = button:GetText();
                if ( text and text ~= "" ) then
                    want = want + 1;
                    local width = menuChild(button, "NormalText"):GetWidth();
                    if ( width > 0 ) then
                        seen = seen + 1;
                        width = width + 60;
                        if ( button.hasArrow or button.hasColorSwatch ) then
                            width = width + 10;
                        end
                        if ( button.notCheckable ) then
                            width = width - 30;
                        end
                        if ( button.icon ) then
                            width = width + 10;
                        end
                        if ( width > maxWidth ) then
                            maxWidth = width;
                        end
                    end
                end
            end
            if ( want > 0 and seen < want ) then
                return; -- measures not landed yet; next update
            end
            if ( maxWidth == 0 ) then
                maxWidth = 130;
            end
            for i=1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                getglobal(listFrameName.."Button"..i):SetWidth(maxWidth);
            end
            listFrame:SetWidth(maxWidth + 15);
            listFrame.pendingWidth = nil;
        end

        -- Which of the list's corners meets which corner of its seat once the list is known to hang
        -- off the bottom and/or the right of the screen. Level 1 re-seats against the anchor Toggle
        -- stored and needs no nudge; a submenu flips around the row that opened it, and the nudge
        -- is what keeps the flipped list glued to that row.
        local FLIP = {
            bottomRight = { seat = { "BOTTOMRIGHT", "BOTTOMLEFT" },
                            row  = { "BOTTOMRIGHT", "BOTTOMLEFT", -11, -14 } },
            bottom      = { seat = { "BOTTOMLEFT", "TOPLEFT" },
                            row  = { "BOTTOMLEFT", "BOTTOMRIGHT", 0, -14 } },
            right       = { seat = { "TOPRIGHT", "TOPLEFT" },
                            row  = { "TOPRIGHT", "TOPLEFT", -11, 14 } },
        };

        -- The off-screen flip, from the same OnUpdate chain as the width (it needs the resolved
        -- rect — the header's second settle).
        function UIDropDownMenu_SettleFlip(listFrame)
            local x, y = listFrame:GetCenter();
            if ( not x or not y ) then
                return; -- not resolved yet; next update
            end
            listFrame.pendingFlip = nil;
            local rightEdge = listFrame:GetRight();
            local offBottom = (y - listFrame:GetHeight()/2) < 0;
            local offRight = (rightEdge ~= nil) and (rightEdge > GetScreenWidth());
            local flip;
            if ( offBottom and offRight ) then
                flip = FLIP.bottomRight;
            elseif ( offBottom ) then
                flip = FLIP.bottom;
            elseif ( offRight ) then
                flip = FLIP.right;
            else
                return; -- it fits; the seat Toggle gave it stands
            end
            listFrame:ClearAllPoints();
            if ( listFrame:GetID() == 1 ) then
                local corner = flip.seat;
                if ( listFrame.cursorMode ) then
                    -- Cursor menus keep their screen-space seat; only the corner changes.
                    listFrame:SetPoint(corner[1], "UIParent", "BOTTOMLEFT", listFrame.seatX, listFrame.seatY);
                else
                    listFrame:SetPoint(corner[1], listFrame.seatTo, corner[2], listFrame.seatX, listFrame.seatY);
                end
            else
                local corner = flip.row;
                listFrame:SetPoint(corner[1], listFrame.anchorFrame, corner[2], corner[3], corner[4]);
            end
        end

        -- The list's per-frame work: settle the width, then the flip (both wait on measures that
        -- land a frame after the open — the header), then run the hover-away countdown.
        function UIDropDownMenu_OnUpdate(elapsed)
            if ( this.pendingWidth ) then
                UIDropDownMenu_SettleWidth(this);
            elseif ( this.pendingFlip ) then
                UIDropDownMenu_SettleFlip(this);
            end
            -- The countdown runs only on a visible list that a StartCounting has armed (never on
            -- open); reaching zero is what closes a menu the mouse walked away from.
            if ( not this:IsVisible() or not this.isCounting or not this.showTimer ) then
                return;
            end
            if ( this.showTimer < 0 ) then
                this.showTimer = nil;
                this.isCounting = nil;
                this:Hide();
            else
                this.showTimer = this.showTimer - elapsed;
            end
        end

        -- A submenu's hover state drives its ROOT list's timer, so the whole open stack lives or
        -- dies together: both ends of the countdown climb `parent` to the list that owns the stack.
        local function timerRoot(frame)
            while ( frame.parent ) do
                frame = frame.parent;
            end
            return frame;
        end

        function UIDropDownMenu_StartCounting(frame)
            local root = timerRoot(frame);
            root.showTimer = UIDROPDOWNMENU_SHOW_TIME;
            root.isCounting = 1;
        end

        function UIDropDownMenu_StopCounting(frame)
            local root = timerRoot(frame);
            root.isCounting = nil;
        end

        -- The kit's one selection test, answering in the reference's own `[nil, 1]` currency. Name
        -- beats id beats value, and only the first key the capsule actually carries is consulted —
        -- note that GetSelectedID answers for a value-selected capsule too (it scans the open level
        -- for the row), so the value arm below is reached only when that scan found nothing.
        local function rowChecked(frame, button)
            local name = UIDropDownMenu_GetSelectedName(frame);
            if ( name ) then
                return button:GetText() == name and 1 or nil;
            end
            local id = UIDropDownMenu_GetSelectedID(frame);
            if ( id ) then
                return button:GetID() == id and 1 or nil;
            end
            local value = UIDropDownMenu_GetSelectedValue(frame);
            if ( value ) then
                return button.value == value and 1 or nil;
            end
        end

        -- Paint one row's checked state. The tick and the locked highlight always move together,
        -- and the row remembers what it was told (its click handler reads it back).
        local function paintChecked(button, checked)
            if ( checked ) then
                button:LockHighlight();
                menuChild(button, "Check"):Show();
            else
                button:UnlockHighlight();
                menuChild(button, "Check"):Hide();
            end
            button.checked = checked;
        end

        -- Build one menu row from an `info` table — `.text`/`.value`/`.func`/`.checked`/`.isTitle`/
        -- `.disabled`/`.notClickable`/`.notCheckable`/`.hasArrow`/`.icon` + `.tCoord*`/`.textR-G-B`/
        -- `.justifyH`/`.keepShownOnClick`/`.owner`/`.arg1`/`.arg2`/the tooltip pair/the colour-swatch
        -- set. That table is the published API and its field names are the contract. Width rides the
        -- settle (header), not an AddButton-time measure.
        function UIDropDownMenu_AddButton(info, level)
            level = level or 1;
            local listFrame = getglobal("DropDownList"..level);
            local listFrameName = listFrame:GetName();
            local index = listFrame.numButtons + 1;
            if ( index > UIDROPDOWNMENU_MAXBUTTONS or level > UIDROPDOWNMENU_MAXLEVELS ) then
                return; -- the ref raises a dev-error dialog here (OUT, header)
            end
            listFrame.numButtons = index;

            local button = listRow(level, index);
            local normalText = menuChild(button, "NormalText");
            local icon = menuChild(button, "Icon");
            -- Captures OnEnter/OnLeave over a disabled row so the menu doesn't time out.
            local invisibleButton = menuChild(button, "InvisibleButton");
            invisibleButton:Hide();
            button:Enable();

            -- The label, and its colour: a row carrying its own textR/G/B wears it in both the
            -- normal and the highlight state, so the label doesn't change colour under the mouse.
            if ( info.text ) then
                button:SetText(info.text);
                local r, g, b = info.textR, info.textG, info.textB;
                if ( not r ) then
                    r, g, b = HIGHLIGHT_FONT_COLOR.r, HIGHLIGHT_FONT_COLOR.g, HIGHLIGHT_FONT_COLOR.b;
                end
                button:SetTextColor(r, g, b);
                button:SetHighlightTextColor(r, g, b);
            else
                button:SetText("");
            end

            -- The right-hand icon rides on the label: a row with no text has no icon either.
            if ( info.text and info.icon ) then
                icon:SetTexture(info.icon);
                if ( info.tCoordLeft ) then
                    icon:SetTexCoord(info.tCoordLeft, info.tCoordRight, info.tCoordTop, info.tCoordBottom);
                end
                icon:Show();
            else
                icon:Hide();
            end

            -- Everything the row simply carries over, then the value, which falls back to the label
            -- so a menu built from plain text rows still has values to dispatch on.
            for _, field in ipairs(ROW_FIELDS) do
                button[field] = info[field];
            end
            button.value = info.value or info.text;

            local expandArrow = menuChild(button, "ExpandArrow");
            if ( info.hasArrow ) then
                expandArrow:Show();
            else
                expandArrow:Hide();
            end

            -- The row's left inset, and its label's seat inside it. A notCheckable row (titles,
            -- plain actions) pulls the label to the row's left edge and sits 10px in; a checkable
            -- row leaves the 27px check column and sits 12px in — 6px tighter under MENU mode,
            -- whose frames have no capsule for the rows to line up beneath.
            local xPos = 5;
            local yPos = -((button:GetID() - 1) * UIDROPDOWNMENU_BUTTON_HEIGHT) - UIDROPDOWNMENU_BORDER_HEIGHT;
            normalText:ClearAllPoints();
            if ( not info.notCheckable ) then
                xPos = xPos + 12;
                normalText:SetPoint("LEFT", button:GetName(), "LEFT", 27, 0);
            elseif ( info.justifyH == "CENTER" ) then
                xPos = xPos + 10;
                normalText:SetPoint("CENTER", button:GetName(), "CENTER", -7, 0);
            else
                xPos = xPos + 10;
                normalText:SetPoint("LEFT", button:GetName(), "LEFT", 0, 0);
            end

            -- Whose menu this is: the open capsule, or — nothing open yet — the one initializing.
            local frame = UIDROPDOWNMENU_OPEN_MENU and getglobal(UIDROPDOWNMENU_OPEN_MENU);
            if ( frame and frame.displayMode == "MENU" and not info.notCheckable ) then
                xPos = xPos - 6;
            end
            frame = frame or getglobal(UIDROPDOWNMENU_INIT_MENU);
            button:SetPoint("TOPLEFT", listFrameName, "TOPLEFT", xPos, yPos);

            -- A row the owning capsule points at comes up checked. `info.checked` is only ever set
            -- here, never cleared: a caller that declared the row checked keeps it.
            if ( frame and rowChecked(frame, button) ) then
                info.checked = 1;
            end
            paintChecked(button, info.checked);

            -- The colour square: its NormalTexture IS the swatch art, tinted to the row's colour,
            -- and the row keeps r/g/b so the square's own OnClick can seed the picker from them.
            local colorSwatch = menuChild(button, "ColorSwatch");
            if ( info.hasColorSwatch ) then
                button.r, button.g, button.b = info.r, info.g, info.b;
                menuChild(colorSwatch, "NormalTexture"):SetVertexColor(button.r, button.g, button.b);
                colorSwatch:Show();
            else
                colorSwatch:Hide();
            end

            -- Three ways a row lands disabled, each choosing the colour its label wears while it is:
            -- a title is gold, a notClickable row is white, a plainly disabled one keeps the gray
            -- default. A title wins, which is the reference's own order (it applies isTitle second).
            local disabledColor = GRAY_FONT_COLOR;
            if ( info.notClickable ) then
                info.disabled = 1;
                disabledColor = HIGHLIGHT_FONT_COLOR;
            end
            if ( info.isTitle ) then
                info.disabled = 1;
                disabledColor = NORMAL_FONT_COLOR;
            end
            button:SetDisabledTextColor(disabledColor.r, disabledColor.g, disabledColor.b);
            if ( info.disabled ) then
                button:Disable();
                invisibleButton:Show();
            end

            listFrame:SetHeight((index * UIDROPDOWNMENU_BUTTON_HEIGHT) + (UIDROPDOWNMENU_BORDER_HEIGHT * 2));
            button:Show();
        end

        -- Re-derive every row's check + lock state on one level, and push the selected row's label
        -- into the capsule's own text. Width stays the settle's job (header).
        function UIDropDownMenu_Refresh(frame, useValue, dropdownLevel)
            frame = frame or this;
            dropdownLevel = dropdownLevel or UIDROPDOWNMENU_MENU_LEVEL;
            for i = 1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                local button = listRow(dropdownLevel, i);
                local checked = rowChecked(frame, button);
                if ( checked ) then
                    if ( useValue ) then
                        UIDropDownMenu_SetText(button.value, frame);
                    else
                        UIDropDownMenu_SetText(button:GetText(), frame);
                    end
                end
                paintChecked(button, checked);
            end
        end

        -- The three setters are one operation: adopt one selection key, drop the other two, repaint.
        local function selectBy(frame, key, selection, useValue)
            for _, field in ipairs(SELECTION_KEYS) do
                frame[field] = nil;
            end
            frame[key] = selection;
            UIDropDownMenu_Refresh(frame, useValue);
        end

        function UIDropDownMenu_SetSelectedName(frame, name, useValue)
            selectBy(frame, "selectedName", name, useValue);
        end

        function UIDropDownMenu_SetSelectedValue(frame, value, useValue)
            selectBy(frame, "selectedValue", value, useValue);
        end

        function UIDropDownMenu_SetSelectedID(frame, id, useValue)
            selectBy(frame, "selectedID", id, useValue);
        end

        function UIDropDownMenu_GetSelectedName(frame)
            return frame.selectedName;
        end

        function UIDropDownMenu_GetSelectedValue(frame)
            return frame.selectedValue;
        end

        -- With no explicit id, answer with the index of the row the selected name — failing that,
        -- the selected value — points at on the open level.
        function UIDropDownMenu_GetSelectedID(frame)
            if ( frame.selectedID ) then
                return frame.selectedID;
            end
            local name = UIDropDownMenu_GetSelectedName(frame);
            local value = UIDropDownMenu_GetSelectedValue(frame);
            if ( not name and not value ) then
                return nil;
            end
            for i = 1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                local button = listRow(UIDROPDOWNMENU_MENU_LEVEL, i);
                if ( name ) then
                    if ( button:GetText() == name ) then
                        return i;
                    end
                elseif ( button.value == value ) then
                    return i;
                end
            end
        end

        -- A row's click: run its func with `this` still on the row, then either flip the check in
        -- place (keepShownOnClick) or shut the list the row belongs to. A row with no func does
        -- nothing at all — not even the sound.
        function UIDropDownMenuButton_OnClick()
            if ( not this.func ) then
                return;
            end
            this.func(this.arg1, this.arg2);
            if ( not this.keepShownOnClick ) then
                this:GetParent():Hide();
            elseif ( this.checked ) then
                this.checked = nil;
                menuChild(this, "Check"):Hide();
            else
                this.checked = 1;
                menuChild(this, "Check"):Show();
            end
            PlaySound("UChatScrollButton");
        end

        function HideDropDownMenu(level)
            getglobal("DropDownList"..(level or 1)):Hide();
        end

        -- Open (or re-open) one level of the shared menu. The capsule that is already showing this
        -- level closes it; anything else rebuilds through the stored initialize, seats the list (the
        -- capsule seat, a named anchor, or the cursor), dresses it for its display mode and shows
        -- it. Width and the off-screen flip settle from OnUpdate (header).
        function ToggleDropDownMenu(level, value, dropDownFrame, anchorName, xOffset, yOffset)
            level = level or 1;
            UIDROPDOWNMENU_MENU_LEVEL = level;
            UIDROPDOWNMENU_MENU_VALUE = value;
            local listFrameName = "DropDownList"..level;
            local listFrame = getglobal(listFrameName);
            -- Called straight off a capsule's scroll button, `this` is that button and the capsule
            -- it serves is its parent.
            local owner = dropDownFrame or this:GetParent();
            if ( listFrame:IsVisible() and UIDROPDOWNMENU_OPEN_MENU == owner:GetName() ) then
                listFrame:Hide();
                return;
            end
            listFrame:Hide();

            -- The uiScale correction, arriving with its first scaled customer (0992: the options
            -- window rides SetScale, and a list at scale 1 would draw its rows ~28% larger than the
            -- capsule they serve): the shared list wears the OWNER's effective scale for this open.
            -- Every pre-0992 customer sits at effective scale 1 — no-op.
            local listScale = owner:GetEffectiveScale();
            listFrame:SetScale(listScale);

            if ( level == 1 ) then
                dropDownFrame = owner;
                UIDROPDOWNMENU_OPEN_MENU = dropDownFrame:GetName();
                listFrame:ClearAllPoints();
                listFrame.cursorMode = nil;
                local point, relativeTo, relativePoint;
                if ( not anchorName ) then
                    -- The capsule seat (header deviation), overridable via SetAnchor.
                    point = dropDownFrame.point or "TOPLEFT";
                    relativeTo = dropDownFrame.relativeTo or dropDownFrame:GetName();
                    relativePoint = dropDownFrame.relativePoint or "BOTTOMLEFT";
                    xOffset = dropDownFrame.xOffset or 8;
                    yOffset = dropDownFrame.yOffset or 7;
                elseif ( anchorName == "cursor" ) then
                    -- Cursor coords are scale-1 units, and a scaled list's anchor offsets are in
                    -- ITS space, so divide (the reference's own cursor/uiScale dance).
                    local cursorX, cursorY = GetCursorPosition();
                    point = "TOPLEFT";
                    relativeTo = "UIParent";
                    relativePoint = "BOTTOMLEFT";
                    xOffset = cursorX / listScale + (xOffset or 0);
                    yOffset = cursorY / listScale + (yOffset or 0);
                    listFrame.cursorMode = 1;
                else
                    point = "TOPLEFT";
                    relativeTo = anchorName;
                    relativePoint = "BOTTOMLEFT";
                    if ( not xOffset or not yOffset ) then
                        xOffset = 8;
                        yOffset = 22;
                    end
                end
                listFrame:SetPoint(point, relativeTo, relativePoint, xOffset, yOffset);
                -- What the flip re-seats against (SettleFlip).
                listFrame.seatTo = relativeTo;
                listFrame.seatX = xOffset;
                listFrame.seatY = yOffset;
            else
                dropDownFrame = dropDownFrame or getglobal(UIDROPDOWNMENU_OPEN_MENU);
                listFrame:ClearAllPoints();
                -- Anchor to the row itself, whether `this` is the row (whose parent is the bare
                -- list — name length 13) or the row's ExpandArrow child.
                local parentName = this:GetParent():GetName();
                local anchorFrame = parentName;
                if ( string.sub(parentName, 1, 12) == "DropDownList" and string.len(parentName) == 13 ) then
                    anchorFrame = this:GetName();
                end
                listFrame:SetPoint("TOPLEFT", anchorFrame, "TOPRIGHT", 0, 0);
                listFrame.anchorFrame = anchorFrame;
            end

            -- MENU mode swaps the dialog box for the tooltip-style backdrop; exactly one is up.
            local wanted, unwanted = "Backdrop", "MenuBackdrop";
            if ( dropDownFrame and dropDownFrame.displayMode == "MENU" ) then
                wanted, unwanted = "MenuBackdrop", "Backdrop";
            end
            getglobal(listFrameName..wanted):Show();
            getglobal(listFrameName..unwanted):Hide();

            UIDropDownMenu_Initialize(dropDownFrame, dropDownFrame.initialize, nil, level);
            if ( listFrame.numButtons == 0 ) then
                return;
            end

            -- A capsule that declared a width applies it synchronously (the proven pre-0434 path);
            -- auto-sized menus ride the settle.
            listFrame.fixedWidth = nil;
            if ( dropDownFrame.noResize and dropDownFrame.dropWidth ) then
                listFrame.fixedWidth = dropDownFrame.dropWidth;
                for i = 1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                    listRow(level, i):SetWidth(listFrame.fixedWidth);
                end
                listFrame:SetWidth(listFrame.fixedWidth + 32);
            end
            listFrame:Show();
        end

        function CloseDropDownMenus(level)
            for i = (level or 1), UIDROPDOWNMENU_MAXLEVELS, 1 do
                getglobal("DropDownList"..i):Hide();
            end
        end

        -- CloseMenus() — in the ref a C function (the ESC ladder's rung between the game-menu
        -- checks and SpellStopCasting, UIParent.lua l.1488): close any open menu, truthy iff one
        -- was open so the ladder eats the press. Every menu we have is a DropDownList, so the
        -- Lua equivalent lives here with them (decision 0454).
        function CloseMenus()
            local closed
            for i=1, UIDROPDOWNMENU_MAXLEVELS, 1 do
                local list = getglobal("DropDownList"..i)
                if list and list:IsVisible() then
                    closed = 1
                end
            end
            if closed then
                CloseDropDownMenus()
            end
            return closed
        end

        -- The capsule's declared width: the Middle art stretches to it, the frame itself carries the
        -- two 25px end caps, and the label gets 25px less than the art. `dropWidth` is ours — the
        -- fixed-width path in Toggle reuses the number (see the header).
        function UIDropDownMenu_SetWidth(width, frame)
            frame = frame or this;
            menuChild(frame, "Middle"):SetWidth(width);
            frame:SetWidth(width + 25 + 25);
            menuChild(frame, "Text"):SetWidth(width - 25);
            frame.dropWidth = width;
            frame.noResize = 1;
        end

        function UIDropDownMenu_SetButtonWidth(width, frame)
            frame = frame or this;
            if ( width == "TEXT" ) then
                width = menuChild(frame, "Text"):GetWidth();
            end
            menuChild(frame, "Button"):SetWidth(width);
            frame.noResize = 1;
        end

        function UIDropDownMenu_SetText(text, frame)
            frame = frame or this;
            menuChild(frame, "Text"):SetText(text);
        end

        function UIDropDownMenu_GetText(frame)
            frame = frame or this;
            return menuChild(frame, "Text"):GetText();
        end

        -- Forget the selection and strip the marks off the open level's rows. Deliberately NOT a
        -- Refresh: the reference found refreshing from here a bottleneck, and the rows are about to
        -- be rebuilt anyway.
        function UIDropDownMenu_ClearAll(frame)
            for _, field in ipairs(SELECTION_KEYS) do
                frame[field] = nil;
            end
            UIDropDownMenu_SetText("", frame);
            for i = 1, UIDROPDOWNMENU_MAXBUTTONS, 1 do
                local button = listRow(UIDROPDOWNMENU_MENU_LEVEL, i);
                button:UnlockHighlight();
                menuChild(button, "Check"):Hide();
            end
        end

        -- Where the capsule's own label sits: against the left cap, against the right one (clear of
        -- the scroll button), or centred on the Middle art. {point, art piece, its point, x, y}.
        local JUSTIFY = {
            LEFT   = { "LEFT",   "Left",   "LEFT",    27, 2 },
            RIGHT  = { "RIGHT",  "Right",  "RIGHT",  -43, 2 },
            CENTER = { "CENTER", "Middle", "CENTER",  -5, 2 },
        };

        function UIDropDownMenu_JustifyText(justification, frame)
            frame = frame or this;
            local text = menuChild(frame, "Text");
            text:ClearAllPoints();
            local seat = JUSTIFY[justification];
            if ( seat ) then
                text:SetPoint(seat[1], frame:GetName()..seat[2], seat[3], seat[4], seat[5]);
            end
        end

        function UIDropDownMenu_SetAnchor(xOffset, yOffset, dropdown, point, relativeTo, relativePoint)
            dropdown = dropdown or this;
            dropdown.point, dropdown.relativeTo, dropdown.relativePoint = point, relativeTo, relativePoint;
            dropdown.xOffset, dropdown.yOffset = xOffset, yOffset;
        end

        -- The dropdown a menu handler is acting for: the open capsule, or `this` when nothing is
        -- open (a row's own func asking who it belongs to).
        function UIDropDownMenu_GetCurrentDropDown()
            if ( not UIDROPDOWNMENU_OPEN_MENU ) then
                return this;
            end
            return getglobal(UIDROPDOWNMENU_OPEN_MENU);
        end

        function UIDropDownMenuButton_GetChecked()
            return menuChild(this, "Check"):IsVisible();
        end

        function UIDropDownMenuButton_GetName()
            return menuChild(this, "NormalText"):GetText();
        end

        -- The picker fields a swatch row seeds under the same name on both sides. `swatchFunc` is
        -- the exception, set beside them: it lands on the picker as `func`, which is why it is the
        -- LIVE-preview callback and not an on-accept one.
        local PICKER_FIELDS = { "hasOpacity", "opacity", "opacityFunc", "cancelFunc" };

        -- THE entry point to the colour picker (spec: UIDropDownMenu.lua l.801-815): every colour
        -- option in every FrameXML dropdown and every Ace2/Dewdrop menu row lands here. Note what it
        -- does that the picker itself does not — `previousValues` is captured HERE, and it is the
        -- table `cancelFunc` is handed, so Cancel restoring the old colour is this function's doing.
        function UIDropDownMenuButton_OpenColorPicker(button)
            CloseMenus();
            button = button or this;
            UIDROPDOWNMENU_MENU_VALUE = button.value;
            ColorPickerFrame.func = button.swatchFunc;
            for _, field in ipairs(PICKER_FIELDS) do
                ColorPickerFrame[field] = button[field];
            end
            ColorPickerFrame:SetColorRGB(button.r, button.g, button.b);
            ColorPickerFrame.previousValues = {r = button.r, g = button.g, b = button.b, opacity = button.opacity};
            ShowUIPanel(ColorPickerFrame);
        end

        -- The by-address trio: an addon that knows a row's level and index, rather than holding the
        -- row itself, reaches it through these.
        function UIDropDownMenu_DisableButton(level, id)
            listRow(level, id):Disable();
        end

        function UIDropDownMenu_EnableButton(level, id)
            listRow(level, id):Enable();
        end

        function UIDropDownMenu_SetButtonText(level, id, text, r, g, b)
            local button = listRow(level, id);
            button:SetText(text);
            if ( r ) then
                button:SetTextColor(r, g, b);
                button:SetHighlightTextColor(r, g, b);
            end
        end

        -- ── What the row template's handlers do ───────────────────────────────────────────────
        -- Everything that sits on a menu row — the row itself, its colour square, its expand arrow,
        -- the invisible cover over a disabled row — means the same two things to the menu when the
        -- mouse arrives and when it leaves, and both are about the row's LIST rather than the row:
        -- the timeout that closes a menu the mouse walked away from lives on the list, and so does
        -- the level number that decides which lists count as deeper than this one. Five handlers
        -- want exactly that, so it is written here once instead of five times in markup.

        function UIDropDownMenuRow_HoverIn(list)
            UIDropDownMenu_StopCounting(list);
            CloseDropDownMenus(list:GetID() + 1);
        end

        function UIDropDownMenuRow_HoverOut(list)
            UIDropDownMenu_StartCounting(list);
        end

        -- A `hasArrow` row opens its submenu one level below the list it sits in, carrying the row's
        -- value as that submenu's context. Hovering the row, hovering the arrow and clicking the
        -- arrow are three ways to ask for the same thing.
        function UIDropDownMenuRow_OpenSubmenu(row)
            ToggleDropDownMenu(row:GetParent():GetID() + 1, row.value);
        end

        -- The colour square's hover feedback. The square itself IS the row's colour, so the only
        -- thing free to react is the 14x14 backing behind it: gold under the mouse, white off it.
        function UIDropDownMenuSwatch_Highlight(swatch, color)
            getglobal(swatch:GetName().."SwatchBg"):SetVertexColor(color.r, color.g, color.b);
        end
    ]]></Script>

    <!-- One menu row (ref UIDropDownMenuButtonTemplate: highlight, check, right-side icon, the
         expand arrow, the disabled-row InvisibleButton; text re-anchored per AddButton). -->
    <Button name="UIDropDownMenuButtonTemplate" virtual="true" hidden="true">
        <Size><AbsDimension x="128" y="16"/></Size>
        <Layers>
            <Layer level="BACKGROUND">
                <Texture name="$parentHighlight" file="Interface\QuestFrame\UI-QuestTitleHighlight" alphaMode="ADD" setAllPoints="true" hidden="true"/>
            </Layer>
            <Layer level="ARTWORK">
                <Texture name="$parentCheck" file="Interface\Buttons\UI-CheckBox-Check">
                    <Size><AbsDimension x="24" y="24"/></Size>
                    <Anchors><Anchor point="LEFT"/></Anchors>
                </Texture>
                <Texture name="$parentIcon" hidden="true">
                    <Size><AbsDimension x="15" y="15"/></Size>
                    <Anchors><Anchor point="RIGHT"><Offset><AbsDimension x="-5" y="0"/></Offset></Anchor></Anchors>
                </Texture>
            </Layer>
        </Layers>
        <Frames>
            <!-- ref UIDropDownMenuTemplates.xml l.38-83. The colour square: a 16x16 button whose
                 NormalTexture is the ChatFrameColorSwatch art, tinted per row, over a 14x14
                 `$parentSwatchBg` that the hover recolours (gold in, white out) — that background
                 is the row's only hover feedback, since the square itself is the row's colour.
                 Clicking it is the ONLY thing in the whole reference UI that opens the colour
                 picker. -->
            <Button name="$parentColorSwatch" hidden="true">
                <Size><AbsDimension x="16" y="16"/></Size>
                <Anchors><Anchor point="RIGHT"><Offset><AbsDimension x="-6" y="0"/></Offset></Anchor></Anchors>
                <Layers>
                    <Layer level="BACKGROUND">
                        <Texture name="$parentSwatchBg">
                            <Size><AbsDimension x="14" y="14"/></Size>
                            <Anchors><Anchor point="CENTER"/></Anchors>
                            <Color r="1.0" g="1.0" b="1.0"/>
                        </Texture>
                    </Layer>
                </Layers>
                <Scripts>
                    <!-- The open closes the menu first — that is `OpenColorPicker`'s own first
                         line, so it is not repeated here. -->
                    <OnClick>
                        UIDropDownMenuButton_OpenColorPicker(this:GetParent());
                    </OnClick>
                    <OnEnter>
                        UIDropDownMenuRow_HoverIn(this:GetParent():GetParent());
                        UIDropDownMenuSwatch_Highlight(this, NORMAL_FONT_COLOR);
                    </OnEnter>
                    <OnLeave>
                        UIDropDownMenuRow_HoverOut(this:GetParent():GetParent());
                        UIDropDownMenuSwatch_Highlight(this, HIGHLIGHT_FONT_COLOR);
                    </OnLeave>
                </Scripts>
                <NormalTexture name="$parentNormalTexture" file="Interface\ChatFrame\ChatFrameColorSwatch"/>
            </Button>
            <Button name="$parentExpandArrow" hidden="true">
                <Size><AbsDimension x="16" y="16"/></Size>
                <Anchors><Anchor point="RIGHT"><Offset><AbsDimension x="-6" y="0"/></Offset></Anchor></Anchors>
                <Scripts>
                    <OnClick>
                        UIDropDownMenuRow_OpenSubmenu(this:GetParent());
                    </OnClick>
                    <!-- Hovering the arrow opens the submenu, so this is the one hover on the row
                         that must NOT close the deeper levels — only the timeout stops. -->
                    <OnEnter>
                        UIDropDownMenuRow_OpenSubmenu(this:GetParent());
                        UIDropDownMenu_StopCounting(this:GetParent():GetParent());
                    </OnEnter>
                    <OnLeave>
                        UIDropDownMenuRow_HoverOut(this:GetParent():GetParent());
                    </OnLeave>
                </Scripts>
                <NormalTexture file="Interface\ChatFrame\ChatFrameExpandArrow"/>
            </Button>
            <!-- Disabled rows don't get mouse events; this transparent cover keeps the hover
                 alive (timeout + deeper-level close). It stops at the colour swatch's LEFT edge
                 (ref l.111-113) so a disabled row's swatch is still clickable. -->
            <Button name="$parentInvisibleButton" hidden="true">
                <Anchors>
                    <Anchor point="TOPLEFT"/>
                    <Anchor point="BOTTOMLEFT"/>
                    <Anchor point="RIGHT" relativeTo="$parentColorSwatch" relativePoint="LEFT"><Offset><AbsDimension x="0" y="0"/></Offset></Anchor>
                </Anchors>
                <Scripts>
                    <OnEnter>
                        UIDropDownMenuRow_HoverIn(this:GetParent():GetParent());
                    </OnEnter>
                    <OnLeave>
                        UIDropDownMenuRow_HoverOut(this:GetParent():GetParent());
                    </OnLeave>
                </Scripts>
            </Button>
        </Frames>
        <Scripts>
            <OnClick>
                UIDropDownMenuButton_OnClick();
            </OnClick>
            <!-- A row that has a submenu opens it on hover; a row that has not closes whatever is
                 deeper. Either way the list's timeout stops and the row lights up. -->
            <OnEnter>
                if ( this.hasArrow ) then
                    UIDropDownMenuRow_OpenSubmenu(this);
                    UIDropDownMenu_StopCounting(this:GetParent());
                else
                    UIDropDownMenuRow_HoverIn(this:GetParent());
                end
                getglobal(this:GetName().."Highlight"):Show();
            </OnEnter>
            <OnLeave>
                getglobal(this:GetName().."Highlight"):Hide();
                UIDropDownMenuRow_HoverOut(this:GetParent());
            </OnLeave>
        </Scripts>
        <ButtonText name="$parentNormalText">
            <Anchors><Anchor point="LEFT"><Offset><AbsDimension x="27" y="0"/></Offset></Anchor></Anchors>
        </ButtonText>
        <NormalFont inherits="GameFontHighlightSmall" justifyH="LEFT"/>
        <HighlightFont inherits="GameFontHighlightSmall" justifyH="LEFT"/>
        <DisabledFont inherits="GameFontDisableSmall" justifyH="LEFT"/>
    </Button>

    <!-- The list (ref UIDropDownListTemplate): the two swappable backdrops + 32 rows.
         FULLSCREEN_DIALOG, not the ref's DIALOG: the list must sort above ANY opener, and the
         world map is FULLSCREEN strata — DIALOG would render the list underneath it (the strata
         escalation later reference versions added to ToggleDropDownMenu, applied statically
         here since our customer set is known). -->
    <Button name="UIDropDownListTemplate" frameStrata="FULLSCREEN_DIALOG" virtual="true" hidden="true">
        <Size><AbsDimension x="180" y="32"/></Size>
        <Frames>
            <Frame name="$parentBackdrop" setAllPoints="true">
                <Backdrop bgFile="Interface\DialogFrame\UI-DialogBox-Background" edgeFile="Interface\DialogFrame\UI-DialogBox-Border" tile="true">
                    <BackgroundInsets><AbsInset left="11" right="12" top="12" bottom="11"/></BackgroundInsets>
                    <TileSize><AbsValue val="32"/></TileSize>
                    <EdgeSize><AbsValue val="32"/></EdgeSize>
                </Backdrop>
            </Frame>
            <Frame name="$parentMenuBackdrop" setAllPoints="true" hidden="true">
                <Backdrop bgFile="Interface\Tooltips\UI-Tooltip-Background" edgeFile="Interface\Tooltips\UI-Tooltip-Border" tile="true">
                    <BackgroundInsets><AbsInset left="5" right="5" top="5" bottom="5"/></BackgroundInsets>
                    <TileSize><AbsValue val="16"/></TileSize>
                    <EdgeSize><AbsValue val="16"/></EdgeSize>
                </Backdrop>
                <Scripts>
                    <OnLoad>
                        this:SetBackdropBorderColor(TOOLTIP_DEFAULT_COLOR.r, TOOLTIP_DEFAULT_COLOR.g, TOOLTIP_DEFAULT_COLOR.b);
                        this:SetBackdropColor(TOOLTIP_DEFAULT_BACKGROUND_COLOR.r, TOOLTIP_DEFAULT_BACKGROUND_COLOR.g, TOOLTIP_DEFAULT_BACKGROUND_COLOR.b);
                    </OnLoad>
                </Scripts>
            </Frame>
            <Button name="$parentButton1" inherits="UIDropDownMenuButtonTemplate" id="1"/>
            <Button name="$parentButton2" inherits="UIDropDownMenuButtonTemplate" id="2"/>
            <Button name="$parentButton3" inherits="UIDropDownMenuButtonTemplate" id="3"/>
            <Button name="$parentButton4" inherits="UIDropDownMenuButtonTemplate" id="4"/>
            <Button name="$parentButton5" inherits="UIDropDownMenuButtonTemplate" id="5"/>
            <Button name="$parentButton6" inherits="UIDropDownMenuButtonTemplate" id="6"/>
            <Button name="$parentButton7" inherits="UIDropDownMenuButtonTemplate" id="7"/>
            <Button name="$parentButton8" inherits="UIDropDownMenuButtonTemplate" id="8"/>
            <Button name="$parentButton9" inherits="UIDropDownMenuButtonTemplate" id="9"/>
            <Button name="$parentButton10" inherits="UIDropDownMenuButtonTemplate" id="10"/>
            <Button name="$parentButton11" inherits="UIDropDownMenuButtonTemplate" id="11"/>
            <Button name="$parentButton12" inherits="UIDropDownMenuButtonTemplate" id="12"/>
            <Button name="$parentButton13" inherits="UIDropDownMenuButtonTemplate" id="13"/>
            <Button name="$parentButton14" inherits="UIDropDownMenuButtonTemplate" id="14"/>
            <Button name="$parentButton15" inherits="UIDropDownMenuButtonTemplate" id="15"/>
            <Button name="$parentButton16" inherits="UIDropDownMenuButtonTemplate" id="16"/>
            <Button name="$parentButton17" inherits="UIDropDownMenuButtonTemplate" id="17"/>
            <Button name="$parentButton18" inherits="UIDropDownMenuButtonTemplate" id="18"/>
            <Button name="$parentButton19" inherits="UIDropDownMenuButtonTemplate" id="19"/>
            <Button name="$parentButton20" inherits="UIDropDownMenuButtonTemplate" id="20"/>
            <Button name="$parentButton21" inherits="UIDropDownMenuButtonTemplate" id="21"/>
            <Button name="$parentButton22" inherits="UIDropDownMenuButtonTemplate" id="22"/>
            <Button name="$parentButton23" inherits="UIDropDownMenuButtonTemplate" id="23"/>
            <Button name="$parentButton24" inherits="UIDropDownMenuButtonTemplate" id="24"/>
            <Button name="$parentButton25" inherits="UIDropDownMenuButtonTemplate" id="25"/>
            <Button name="$parentButton26" inherits="UIDropDownMenuButtonTemplate" id="26"/>
            <Button name="$parentButton27" inherits="UIDropDownMenuButtonTemplate" id="27"/>
            <Button name="$parentButton28" inherits="UIDropDownMenuButtonTemplate" id="28"/>
            <Button name="$parentButton29" inherits="UIDropDownMenuButtonTemplate" id="29"/>
            <Button name="$parentButton30" inherits="UIDropDownMenuButtonTemplate" id="30"/>
            <Button name="$parentButton31" inherits="UIDropDownMenuButtonTemplate" id="31"/>
            <Button name="$parentButton32" inherits="UIDropDownMenuButtonTemplate" id="32"/>
        </Frames>
        <Scripts>
            <OnClick>
                this:Hide();
            </OnClick>
            <OnEnter>
                UIDropDownMenu_StopCounting(this);
            </OnEnter>
            <OnLeave>
                UIDropDownMenu_StartCounting(this);
            </OnLeave>
            <OnUpdate>
                UIDropDownMenu_OnUpdate(arg1);
            </OnUpdate>
            <OnShow>
                if ( this:GetID() > 1 ) then
                    this.parent = getglobal("DropDownList"..(this:GetID() - 1));
                end
                this.showTimer = nil;
                this.isCounting = nil;
                if ( not this.fixedWidth ) then
                    this.pendingWidth = 1;
                end
                this.pendingFlip = 1;
            </OnShow>
        </Scripts>
    </Button>

    <!-- The capsule (spec: ref UIDropDownMenuTemplate). Its art, geometry and texcoords are the
         reference's own numbers — that is what makes it the same widget rather than a lookalike. -->
    <Frame name="UIDropDownMenuTemplate" virtual="true">
        <Size><AbsDimension x="40" y="32"/></Size>
        <Layers>
            <Layer level="ARTWORK">
                <Texture name="$parentLeft" file="Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame">
                    <Size><AbsDimension x="25" y="64"/></Size>
                    <Anchors><Anchor point="TOPLEFT"><Offset><AbsDimension x="0" y="17"/></Offset></Anchor></Anchors>
                    <TexCoords left="0" right="0.1953125" top="0" bottom="1"/>
                </Texture>
                <Texture name="$parentMiddle" file="Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame">
                    <Size><AbsDimension x="115" y="64"/></Size>
                    <Anchors><Anchor point="LEFT" relativeTo="$parentLeft" relativePoint="RIGHT"/></Anchors>
                    <TexCoords left="0.1953125" right="0.8046875" top="0" bottom="1"/>
                </Texture>
                <Texture name="$parentRight" file="Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame">
                    <Size><AbsDimension x="25" y="64"/></Size>
                    <Anchors><Anchor point="LEFT" relativeTo="$parentMiddle" relativePoint="RIGHT"/></Anchors>
                    <TexCoords left="0.8046875" right="1" top="0" bottom="1"/>
                </Texture>
                <FontString name="$parentText" inherits="GameFontHighlightSmall" justifyH="RIGHT">
                    <Size><AbsDimension x="0" y="10"/></Size>
                    <Anchors><Anchor point="RIGHT" relativeTo="$parentRight"><Offset><AbsDimension x="-43" y="2"/></Offset></Anchor></Anchors>
                </FontString>
            </Layer>
        </Layers>
        <Frames>
            <Button name="$parentButton">
                <Size><AbsDimension x="24" y="24"/></Size>
                <Anchors>
                    <Anchor point="TOPRIGHT" relativeTo="$parentRight">
                        <Offset><AbsDimension x="-16" y="-18"/></Offset>
                    </Anchor>
                </Anchors>
                <Scripts>
                    <OnClick>
                        ToggleDropDownMenu();
                        PlaySound("igMainMenuOptionCheckBoxOn");
                    </OnClick>
                </Scripts>
                <NormalTexture file="Interface\ChatFrame\UI-ChatIcon-ScrollDown-Up"/>
                <PushedTexture file="Interface\ChatFrame\UI-ChatIcon-ScrollDown-Down"/>
                <DisabledTexture file="Interface\ChatFrame\UI-ChatIcon-ScrollDown-Disabled"/>
                <HighlightTexture file="Interface\Buttons\UI-Common-MouseHilight" alphaMode="ADD"/>
            </Button>
        </Frames>
        <Scripts>
            <OnHide>
                CloseDropDownMenus();
            </OnHide>
        </Scripts>
    </Frame>

    <!-- The two shared lists (the ref authors DropDownList1..3; level 3 waits for a customer).

         The per-instance <Scripts> answer the three jobs the reference hangs off these two elements
         (spec: ref UIDropDownMenu.xml l.9-18, l.25-28). They were missing here entirely until they
         were measured; each earns its place separately:

         · `CloseDropDownMenus(level+1)` is the SUBMENU CATCH-ALL, and it is why the ref hangs it
           off OnHide rather than off the toggle. `ToggleDropDownMenu`'s close arm is a bare
           `listFrame:Hide()` (l.15-19 of the function) — so with no OnHide, opening a menu with a
           `hasArrow` row, hovering the submenu open and then toggling level 1 shut LEFT
           DropDownList2 on screen with its parent gone. OnHide catches that path and every other
           one that hides level 1 (a parent Hide, the ESC ladder, an addon calling
           `DropDownList1:Hide()` itself) — which is the point of putting it on the event.

         · `OPEN_DROPDOWNMENUS[level] = nil` closes a real leak: UnitPopup.xml WRITES the level
           (l.191, l.239) and its every-frame driver READS it (l.481), and nothing here ever
           cleared it, so an entry survived its menu forever. No player-visible symptom is
           reachable today and that is stated rather than implied — `UnitPopup_OnUpdate` returns
           early unless DropDownList1 is visible AND a UnitPopupFrame owns the open menu, and
           `UIDropDownMenu_AddButton` calls `button:Enable()` unconditionally, so a stale level's
           Disable is undone the next time that list is built. Both of those are guards belonging
           to other code; the divergence from the ref is here, so it is fixed here.

         · UIDROPDOWNMENU_DEFAULT_TEXT_HEIGHT is DERIVED, never a literal. The ref forward-declares
           it nil (UIDropDownMenu.lua l.16) and this OnLoad is the only thing that ever assigns it,
           reading the height off Button1's own NormalText. `UIDropDownMenu_AddButton` then passes
           it straight into `SetFont` (l.187) for every row without an explicit `info.textHeight`.
           Dewdrop-2.0 does the same at its own l.489 — 64 corpus addon folders embed a copy, but
           it is ONE library file replicated, and only that one of its two sites is unguarded (the
           other is `info.textHeight or UIDROPDOWNMENU_DEFAULT_TEXT_HEIGHT or 10`). Writing a
           literal here would have been a silent fidelity divergence, not a fix. -->
    <!-- `toplevel` is authored on the ref's INSTANCES, not its template (decision 1318). -->
    <Button name="DropDownList1" inherits="UIDropDownListTemplate" id="1" toplevel="true" parent="UIParent">
        <Scripts>
            <OnLoad>
                local fontName, fontHeight, fontFlags = getglobal("DropDownList1Button1NormalText"):GetFont();
                UIDROPDOWNMENU_DEFAULT_TEXT_HEIGHT = fontHeight;
            </OnLoad>
            <OnHide>
                CloseDropDownMenus(2);
                OPEN_DROPDOWNMENUS[1] = nil;
            </OnHide>
        </Scripts>
    </Button>
    <Button name="DropDownList2" inherits="UIDropDownListTemplate" id="2" toplevel="true" parent="UIParent">
        <Scripts>
            <OnHide>
                CloseDropDownMenus(3);
                OPEN_DROPDOWNMENUS[2] = nil;
            </OnHide>
        </Scripts>
    </Button>
</Ui>