func (w *Widget) AccessibilityActions() []a11y.Action {
	return []a11y.Action{a11y.ActionScrollUp, a11y.ActionScrollDown}
}

func (w *Widget) AccessibilityHint() string {
	return ""
}

func (w *Widget) AccessibilityLabel() string {
	if w.cfg.a11yLabel != "" {
		return w.cfg.a11yLabel
	}
	return "Tree"
}

func (w *Widget) AccessibilityRole() a11y.Role {
	return a11y.RoleTree
}

func (w *Widget) AccessibilityState() a11y.State {
	return a11y.State{
		Disabled: w.cfg.ResolvedDisabled(),
	}
}

func (w *Widget) AccessibilityValue() string {
	selectedID := w.cfg.ResolvedSelectedNodeID()
	root := w.cfg.ResolvedRoot()
	if selectedID != "" && root != nil {
		if node := findNodeByID(root, selectedID); node != nil {
			return fmt.Sprintf("Selected: %s, %d visible rows", node.Label, len(w.rows))
		}
	}
	return fmt.Sprintf("%d visible rows", len(w.rows))
}

func (w *Widget) Children() []widget.Widget {
	return nil
}

func (w *Widget) CollapseAll() {
	root := w.cfg.ResolvedRoot()
	if root == nil {
		return
	}
	setExpandedAll(root, false)
	w.rebuildRows()
	w.SetNeedsRedraw(true)
}

func (w *Widget) Draw(ctx widget.Context, canvas widget.Canvas) {
	if !w.IsVisible() {
		return
	}

	bounds := w.Bounds()
	if bounds.IsEmpty() {
		return
	}

	// Empty state.
	if len(w.rows) == 0 {
		w.painter.PaintEmptyState(canvas, bounds)
		return
	}

	// Clip to bounds.
	canvas.PushClip(bounds)

	// Determine visible range.
	startIdx, endIdx := w.visibleRange()

	selectedID := w.cfg.ResolvedSelectedNodeID()
	isFocused := w.IsFocused()
	isDisabled := w.cfg.ResolvedDisabled()

	for i := startIdx; i < endIdx; i++ {
		row := w.rows[i]
		rowBounds := w.rowBounds(i, bounds)

		isSelected := selectedID != "" && row.node.ID == selectedID
		isHovered := i == w.hoveredIndex

		rowState := RowPaintState{
			Bounds:		rowBounds,
			Node:		row.node,
			Depth:		row.depth,
			Selected:	isSelected,
			Focused:	isFocused && isSelected,
			Hovered:	isHovered,
			Disabled:	isDisabled,
		}

		// Paint backgrounds.
		w.painter.PaintRowBackground(canvas, rowState)
		w.painter.PaintSelection(canvas, rowState)

		// Paint connector lines if enabled.
		if w.cfg.showLines && row.depth > 0 {
			connState := w.buildConnectorState(i, rowBounds)
			w.painter.PaintConnectorLines(canvas, connState)
		}

		// Paint expand icon for branch nodes.
		if !row.node.IsLeaf() {
			iconBounds := w.expandIconBounds(row.depth, rowBounds)
			w.painter.PaintExpandIcon(canvas, ExpandIconState{
				Bounds:		iconBounds,
				Expanded:	row.node.Expanded,
				Hovered:	isHovered,
			})
		}

		// Paint label.
		labelBounds := w.labelBounds(row.depth, rowBounds)
		w.painter.PaintLabel(canvas, LabelState{
			Bounds:		labelBounds,
			Text:		row.node.Label,
			Selected:	isSelected,
			Disabled:	isDisabled,
		})
	}

	canvas.PopClip()
}

func (w *Widget) Event(ctx widget.Context, e event.Event) bool {
	if !w.IsVisible() || !w.IsEnabled() {
		return false
	}
	return handleEvent(w, ctx, e)
}

func (w *Widget) ExpandAll() {
	root := w.cfg.ResolvedRoot()
	if root == nil {
		return
	}
	setExpandedAll(root, true)
	w.rebuildRows()
	w.SetNeedsRedraw(true)
}

func (w *Widget) InvalidateData() {
	w.rebuildRows()
	w.SetNeedsRedraw(true)
}

func (w *Widget) IsFocusable() bool {
	return w.IsVisible() && w.IsEnabled() && !w.cfg.ResolvedDisabled()
}

func (w *Widget) Layout(_ widget.Context, constraints geometry.Constraints) geometry.Size {
	// Rebuild rows in case root changed via signal.
	w.rebuildRows()

	size := constraints.BiggestFinite(defaultViewportWidth, defaultViewportHeight)

	// For unconstrained height, use content height clamped to default.
	if constraints.HasInfiniteHeight() {
		totalH := float32(len(w.rows)) * w.cfg.itemHeight
		if totalH > defaultViewportHeight {
			totalH = defaultViewportHeight
		}
		if totalH <= 0 {
			totalH = defaultViewportHeight
		}
		size.Height = totalH
	}

	if size.Width <= 0 {
		size.Width = defaultViewportWidth
	}
	if size.Height <= 0 {
		size.Height = defaultViewportHeight
	}

	w.viewportWidth = size.Width
	w.viewportHeight = size.Height

	return size
}

func (w *Widget) Mount(ctx widget.Context) {
	sched := ctx.Scheduler()
	if sched == nil {
		return
	}

	// Bind root signals.
	if w.cfg.readonlyRootSignal != nil {
		b := state.BindToScheduler(w.cfg.readonlyRootSignal, w, sched)
		w.AddBinding(b)
	} else if w.cfg.rootSignal != nil {
		b := state.BindToScheduler(w.cfg.rootSignal, w, sched)
		w.AddBinding(b)
	}

	// Bind selected node signals.
	if w.cfg.readonlySelectedNodeSignal != nil {
		b := state.BindToScheduler(w.cfg.readonlySelectedNodeSignal, w, sched)
		w.AddBinding(b)
	} else if w.cfg.selectedNodeIDSignal != nil {
		b := state.BindToScheduler(w.cfg.selectedNodeIDSignal, w, sched)
		w.AddBinding(b)
	}

	// Bind disabled signals.
	if w.cfg.readonlyDisabledSignal != nil {
		b := state.BindToScheduler(w.cfg.readonlyDisabledSignal, w, sched)
		w.AddBinding(b)
	} else if w.cfg.disabledSignal != nil {
		b := state.BindToScheduler(w.cfg.disabledSignal, w, sched)
		w.AddBinding(b)
	}
}

func New(opts ...Option) *Widget {
	cfg := defaultConfig()
	for _, opt := range opts {
		opt(&cfg)
	}

	w := &Widget{
		cfg:		cfg,
		painter:	DefaultPainter{},
		hoveredIndex:	noHoveredIndex,
	}
	w.SetVisible(true)
	w.SetEnabled(true)

	if w.cfg.painter != nil {
		w.painter = w.cfg.painter
	}

	// Build initial flattened rows.
	w.rebuildRows()

	return w
}

func (w *Widget) RowCount() int {
	return len(w.rows)
}

func (w *Widget) ScrollToNode(id string) {
	idx := w.findRowIndex(id)
	if idx < 0 {
		return
	}
	w.scrollToIndex(idx)
}

func (w *Widget) Unmount() {
	// Bindings are cleaned up automatically by WidgetBase.CleanupBindings().
}

func (w *Widget) VisibleRange() (start, end int) {
	return w.visibleRange()
}

type Widget struct {
	widget.WidgetBase
	cfg	config
	painter	Painter

	// Flattened visible rows (rebuilt on expand/collapse).
	rows	[]flatRow

	// Viewport state for virtualization.
	scrollY		float32
	viewportWidth	float32
	viewportHeight	float32

	// Interaction state.
	hoveredIndex	int
}