func (w *Widget) Children() []widget.Widget {
	var children []widget.Widget
	if w.cfg.first != nil {
		children = append(children, w.cfg.first)
	}
	if w.cfg.second != nil {
		children = append(children, w.cfg.second)
	}
	return children
}

func CollapsibleOpt(v bool) Option {
	return func(c *config) { c.collapsible = v }
}

func ColorSchemeOpt(cs DividerColorScheme) Option {
	return func(c *config) { c.colorScheme = cs }
}

func DividerWidth(w float32) Option {
	return func(c *config) { c.dividerWidth = w }
}

func (w *Widget) Draw(ctx widget.Context, canvas widget.Canvas) {
	bounds := w.Bounds()
	if bounds.IsEmpty() {
		return
	}

	// Push transform for local coordinate space (children use local bounds).
	canvas.PushTransform(bounds.Min)

	// Draw first panel.
	if w.cfg.first != nil {
		widget.StampScreenOrigin(w.cfg.first, canvas)
		w.cfg.first.Draw(ctx, canvas)
	}

	// Draw divider.
	divRect := w.dividerRect()
	ps := PaintState{
		DividerRect:	divRect,
		Orientation:	w.cfg.orientation,
		Hovered:	w.hovered,
		Dragging:	w.dragging,
		Collapsed:	w.collapsed,
		ColorScheme:	w.cfg.colorScheme,
	}
	w.painter.PaintDivider(canvas, ps)

	// Draw second panel.
	if w.cfg.second != nil {
		widget.StampScreenOrigin(w.cfg.second, canvas)
		w.cfg.second.Draw(ctx, canvas)
	}

	canvas.PopTransform()
}

func (w *Widget) Event(ctx widget.Context, e event.Event) bool {
	// Translate mouse events to local coordinates.
	if me, ok := e.(*event.MouseEvent); ok {
		local := *me
		local.Position = me.Position.Sub(w.Bounds().Min)
		return w.handleMouseEvent(ctx, &local)
	}

	// Translate wheel events to local coordinates.
	if we, ok := e.(*event.WheelEvent); ok {
		local := *we
		local.Position = we.Position.Sub(w.Bounds().Min)
		return w.handleWheelEvent(ctx, &local)
	}

	// Non-positional events (keyboard, focus) broadcast to children.
	if w.cfg.first != nil {
		if w.cfg.first.Event(ctx, e) {
			return true
		}
	}
	if w.cfg.second != nil {
		if w.cfg.second.Event(ctx, e) {
			return true
		}
	}

	return false
}

func First(w widget.Widget) Option {
	return func(c *config) { c.first = w }
}

func (w *Widget) FirstPanel() widget.Widget {
	return w.cfg.first
}

func FixedFirst(px float32) Option {
	return func(c *config) { c.fixedFirst = px }
}

func InitialRatio(r float32) Option {
	return func(c *config) { c.ratio = clampRatio(r) }
}

func (w *Widget) IsCollapsed() bool {
	return w.collapsed
}

func (w *Widget) Layout(ctx widget.Context, constraints geometry.Constraints) geometry.Size {
	size := constraints.Biggest()
	if size.Width <= 0 || size.Height <= 0 {
		fallback := geometry.Sz(defaultViewportWidth, defaultViewportHeight)
		if constraints.MaxWidth > 0 {
			fallback.Width = constraints.MaxWidth
		}
		if constraints.MaxHeight > 0 {
			fallback.Height = constraints.MaxHeight
		}
		size = fallback
	}

	divW := w.cfg.resolvedDividerWidth()

	// If fixedFirst is set, recompute ratio from pixel size each layout pass.
	// This keeps the first panel at a constant pixel size regardless of window size.
	if w.cfg.fixedFirst > 0 {
		totalSpace := size.Width
		if w.cfg.orientation == Vertical {
			totalSpace = size.Height
		}
		totalSpace -= divW
		if totalSpace > 0 {
			w.cfg.ratio = clampRatio(w.cfg.fixedFirst / totalSpace)
		}
	}

	ratio := w.effectiveRatio()

	// Use local origin (0,0) for child placement. The parent positions us
	// via SetBounds after Layout returns, and Draw applies PushTransform
	// to map local coordinates to parent space. Using w.Bounds().Min here
	// is incorrect because Bounds is stale during Layout (parent calls
	// Layout first, then SetBounds).
	origin := geometry.Point{}
	firstRect, secondRect := computePanelRects(size, origin, ratio, divW, w.cfg.orientation)

	w.layoutChild(ctx, w.cfg.first, firstRect)
	w.layoutChild(ctx, w.cfg.second, secondRect)

	return size
}

func MinFirst(px float32) Option {
	return func(c *config) { c.minFirst = px }
}

func MinSecond(px float32) Option {
	return func(c *config) { c.minSecond = px }
}

func (w *Widget) Mount(ctx widget.Context) {
	sched := ctx.Scheduler()
	if sched == nil {
		return
	}
	if w.cfg.readonlyRatioSignal != nil {
		b := state.BindToScheduler(w.cfg.readonlyRatioSignal, w, sched)
		w.AddBinding(b)
	} else if w.cfg.ratioSignal != nil {
		b := state.BindToScheduler(w.cfg.ratioSignal, w, sched)
		w.AddBinding(b)
	}
}

func New(opts ...Option) *Widget {
	w := &Widget{
		painter: DefaultPainter{},
	}
	w.SetVisible(true)
	w.SetEnabled(true)

	w.cfg.ratio = defaultRatio

	for _, opt := range opts {
		opt(&w.cfg)
	}

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

	// ADR-028: parent chain for upward dirty propagation.
	// Flutter: RenderObject.adoptChild sets parent on each child.
	type parentSetter interface{ SetParent(widget.Widget) }
	if w.cfg.first != nil {
		if ps, ok := w.cfg.first.(parentSetter); ok {
			ps.SetParent(w)
		}
	}
	if w.cfg.second != nil {
		if ps, ok := w.cfg.second.(parentSetter); ok {
			ps.SetParent(w)
		}
	}

	return w
}

func OnRatioChange(fn func(float32)) Option {
	return func(c *config) { c.onRatioChange = fn }
}

func OrientationOpt(o Orientation) Option {
	return func(c *config) { c.orientation = o }
}

func PainterOpt(p Painter) Option {
	return func(c *config) { c.painter = p }
}

func (w *Widget) Ratio() float32 {
	return w.cfg.ResolvedRatio()
}

func RatioReadonlySignal(sig state.ReadonlySignal[float32]) Option {
	return func(c *config) { c.readonlyRatioSignal = sig }
}

func RatioSignal(sig state.Signal[float32]) Option {
	return func(c *config) { c.ratioSignal = sig }
}

func (c *config) ResolvedRatio() float32 {
	if c.readonlyRatioSignal != nil {
		return c.readonlyRatioSignal.Get()
	}
	if c.ratioSignal != nil {
		return c.ratioSignal.Get()
	}
	return c.ratio
}

func Second(w widget.Widget) Option {
	return func(c *config) { c.second = w }
}

func (w *Widget) SecondPanel() widget.Widget {
	return w.cfg.second
}

func (o Orientation) String() string {
	if int(o) < len(orientationNames) {
		return orientationNames[o]
	}
	return orientationUnknownStr
}

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

type Widget struct {
	widget.WidgetBase
	cfg	config
	painter	Painter

	// Interaction state.
	hovered		bool
	dragging	bool
	dragStart	geometry.Point
	dragStartRatio	float32

	// Collapse state.
	collapsed	bool
	preCollapse	float32	// ratio before collapse, for restore
	lastClickAt	time.Time
	lastClickPos	geometry.Point
}