register

pub fn register(self: *WidgetData) void {
    self.rectSet(self.rect);

    if (self.options.theme) |t| {
        dvui.currentWindow().addEmbeddedFontsFromTheme(t);
    }

    if (self.options.role) |role| {
        _ = dvui.currentWindow().accesskit.nodeCreate(self, role);
    }

    if (self.options.data_out) |do| {
        do.* = self.*;
    }

    // for normal widgets this is fine, but subwindows have to take care to
    // call captureMouseMaintain after subwindowCurrentSet and subwindowAdd
    if (!self.init_options.subwindow) {
        dvui.captureMouseMaintain(.{ .id = self.id, .rect = self.borderRectScale().r, .subwindow_id = dvui.subwindowCurrentId() });
    }

    var cw = dvui.currentWindow();

    if (self.options.tag) |t| {
        dvui.tag(t, .{ .id = self.id, .rect = self.rectScale().r, .visible = self.visible() });
    }

    cw.last_registered_id_this_frame = self.id;

    // First widget to register this frame marks the end of the event phase and
    // the start of the build phase for frame timing (see `Window.frameTiming`).
    if (cw.ft_awaiting_build) {
        cw.ft_awaiting_build = false;
        cw.ft_build_start = cw.backend.nanoTime();
    }

    // Record this widget if a machine-readable frame dump is being captured (see
    // `Debug.captureFrame`/`dumpFrame`). Off by default, so this is one branch.
    if (dvui.debug.capturing) {
        dvui.debug.captureWidget(cw.gpa, self);
    }

    const focused_widget_id = dvui.focusedWidgetId();
    if (self.id == focused_widget_id) {
        cw.last_focused_id_this_frame = self.id;

        if (cw.scroll_to_focused) {
            cw.scroll_to_focused = false;
            dvui.scrollTo(.{
                .screen_rect = self.rectScale().r,
            });
        }
    }

    if (self.id == dvui.focusedWidgetIdInCurrentSubwindow()) {
        cw.last_focused_id_in_subwindow = self.id;
    }

    if (dvui.testing.widget_hasher) |*hasher| {
        hasher.update(std.mem.asBytes(&self.init_options));
        hasher.update(std.mem.asBytes(&self.options.hash()));
        hasher.update(std.mem.asBytes(&self.rectScale()));
        hasher.update(std.mem.asBytes(&(self.id == focused_widget_id)));
    }

    if (dvui.debug.target == .focused and self.id == focused_widget_id) {
        dvui.debug.widget_id = self.id;
    }

    if (cw.min_sizes.containsUsed(self.id)) |used| {
        if (used) {
            const name: []const u8 = self.options.name orelse "???";
            dvui.log.err("{s}:{d} duplicate widget id {x} (widget \"{s}\" highlighted in red); you may need to pass .{{.id_extra=<loop index>}} as widget options (see https://github.com/david-vanderson/dvui/blob/master/readme-implementation.md#widget-ids )\n", .{ self.src.file, self.src.line, self.id, name });
            dvui.Debug.errorOutline(self.rectScale().r);
        }
    }

    if (dvui.debug.target.mouse() or self.id == dvui.debug.widget_id) {
        var rs = self.rectScale();

        if (dvui.debug.target.mouse() and
            rs.r.contains(cw.mouse_pt) and
            // prevents stuff in scroll area outside viewport being caught
            dvui.clipGet().contains(cw.mouse_pt) and
            // prevents stuff in lower subwindows being caught
            cw.subwindows.windowFor(cw.mouse_pt) == dvui.subwindowCurrentId())
        {
            dvui.debug.under_mouse_stack.append(cw.gpa, .{
                .id = self.id,
                // Fallback must be empty so that freeing the name will be valid
                .name = cw.gpa.dupe(u8, self.options.name orelse "") catch "",
            }) catch |err| {
                dvui.logError(@src(), err, "Could not add debug info for widgets under mouse position. Widget {x} {s}", .{ self.id, self.options.name orelse "???" });
            };
            dvui.debug.widget_id = self.id;
        }

        if (self.id == dvui.debug.widget_id) {
            if (dvui.debug.widget_panic) {
                @panic("Debug Window Panic");
            }

            dvui.debug.target_wd = self.*;
            dvui.debug.target_wd.?.parent = undefined;

            dvui.Debug.errorOutline(rs.r);
        }
    }
}