Say what may be done to a drawing, and default to nothing

`SizeDependence::{None, Internal, External}` becomes
`OnResize::{Scale, Translate, Redraw}`, which says what the retained path
may do rather than leaving the reader to work it out from a dependency.

`Redraw` is now the default, and that is the substance of this rather
than the naming. `Translate` was, and nothing opted into it: `SetSize`
reports one size and hands its child the whole box, so its pixels change
with the box and carrying them stretched a 100x100 rect across half the
window. A default that is only right for widgets that happen to qualify
is the same fault as an unchecked reuse flag.

`Translate` still does nothing, and now for the reason rather than the
one I gave before: `mov` translates perfectly well, but `ActiveData`'s
`region` is both the box a widget was given and the box its primitives
occupy, and `mov` remaps out of it. Keeping a drawing at its old size
while the box grows leaves those two disagreeing, and the next move
stretches it. Separating them is what the offset chain does.

Caught by rendering `tabs` against `main` rather than by a test, which is
the argument for keeping that check in the loop.

tests/retained.rs

@@ -10,7 +10,7 @@ use iris::prelude::*;
 struct Counted {
     draws: Rc<Cell<usize>>,
     size: Size,
-    dependence: SizeDependence,
+    dependence: OnResize,
 }
 
 impl Widget for Counted {
@@ -19,7 +19,7 @@ impl Widget for Counted {
         painter.set_size(self.size);
     }
 
-    fn size_dependence(&self, _: Axis) -> SizeDependence {
+    fn on_resize(&self, _: Axis) -> OnResize {
         self.dependence
     }
 }
@@ -32,11 +32,7 @@ impl Counts {
     }
 }
 
-fn counted(
-    h: &mut Harness,
-    size: Size,
-    dependence: SizeDependence,
-) -> (WeakWidget<Counted>, Counts) {
+fn counted(h: &mut Harness, size: Size, dependence: OnResize) -> (WeakWidget<Counted>, Counts) {
     let draws = Rc::new(Cell::new(0));
     let id = Counted {
         draws: draws.clone(),
@@ -49,8 +45,8 @@ fn counted(
 
 /// A fixed-width leaf beside one that takes the rest, so changing the first
 /// hands the second a different box without the output changing.
-fn pair(h: &mut Harness, rest: SizeDependence) -> (WeakWidget<Counted>, Counts, WidgetId) {
-    let (first, _) = counted(h, Size::from((100, 200)), SizeDependence::Internal);
+fn pair(h: &mut Harness, rest: OnResize) -> (WeakWidget<Counted>, Counts, WidgetId) {
+    let (first, _) = counted(h, Size::from((100, 200)), OnResize::Translate);
     let (second, draws) = counted(h, Size::REST, rest);
     h.set_root((first, second).span(Dir::RIGHT));
     (first, draws, second.id())
@@ -59,7 +55,7 @@ fn pair(h: &mut Harness, rest: SizeDependence) -> (WeakWidget<Counted>, Counts,
 #[test]
 fn a_leaf_that_ignores_its_box_is_not_drawn_again_when_the_box_changes() {
     let mut h = Harness::new((400, 200));
-    let (first, draws, second) = pair(&mut h, SizeDependence::None);
+    let (first, draws, second) = pair(&mut h, OnResize::Scale);
     let settled = draws.get();
     assert_corners!(h, second, (100, 0), (400, 200));
 
@@ -77,7 +73,7 @@ fn a_leaf_that_ignores_its_box_is_not_drawn_again_when_the_box_changes() {
 #[test]
 fn a_leaf_that_depends_on_its_box_is_drawn_again_when_the_box_changes() {
     let mut h = Harness::new((400, 200));
-    let (first, draws, second) = pair(&mut h, SizeDependence::External);
+    let (first, draws, second) = pair(&mut h, OnResize::Redraw);
     let settled = draws.get();
 
     h.rsc[first].size = Size::from((150, 200));
@@ -93,8 +89,8 @@ fn a_leaf_that_depends_on_its_box_is_drawn_again_when_the_box_changes() {
 #[test]
 fn a_span_child_that_declares_its_length_is_drawn_once() {
     let mut h = Harness::new((400, 200));
-    let (told, told_draws) = counted(&mut h, Size::from((100, 200)), SizeDependence::Internal);
-    let (asked, asked_draws) = counted(&mut h, Size::from((100, 200)), SizeDependence::Internal);
+    let (told, told_draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
+    let (asked, asked_draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
     // The span takes one child's length from its hint and has to draw the
     // other to find out, so only the second is drawn before it is placed.
     let hinted = told.width(100).add(&mut h.rsc);
@@ -111,7 +107,7 @@ fn a_span_child_that_declares_its_length_is_drawn_once() {
 #[test]
 fn a_span_relays_out_when_a_child_it_measured_changes() {
     let mut h = Harness::new((400, 200));
-    let (first, _, second) = pair(&mut h, SizeDependence::Internal);
+    let (first, _, second) = pair(&mut h, OnResize::Translate);
 
     h.rsc[first].size = Size::from((250, 200));
     h.frame();