From f8fe454c595d8e8e10b0fbabbdfa2cee08b03080 Mon Sep 17 00:00:00 2001 From: Travis Ralston Date: Wed, 20 Jan 2021 14:42:24 -0700 Subject: [PATCH] Replace looping resizer with actual math --- src/stores/widgets/WidgetLayoutStore.ts | 43 +++++++++++++++++-------- 1 file changed, 30 insertions(+), 13 deletions(-) diff --git a/src/stores/widgets/WidgetLayoutStore.ts b/src/stores/widgets/WidgetLayoutStore.ts index 9742712fcf..d54cb36a6c 100644 --- a/src/stores/widgets/WidgetLayoutStore.ts +++ b/src/stores/widgets/WidgetLayoutStore.ts @@ -270,20 +270,37 @@ export class WidgetLayoutStore extends ReadyWatchingStore { for (let i = 0; i < widths.length; i++) { widths[i] = 100 / widths.length; } - } + } else { + // If we're not autobalancing then it means that we're trying to make + // sure that widgets make up exactly 100% of space (not over, not under) + const difference = sum(...widths) - 100; // positive = over, negative = under + if (difference < 0) { + // For a deficit we just fill everything in equally + for (let i = 0; i < widths.length; i++) { + widths[i] += Math.abs(difference) / widths.length; + } + } else if (difference > 0) { + // When we're over, we try to scale all the widgets within range first. + // We clamp values to try and keep ourselves sane and within range. + for (let i = 0; i < widths.length; i++) { + widths[i] = clamp(widths[i] - (difference / widths.length), MIN_WIDGET_WIDTH_PCT, 100); + } - // TODO: There is probably a more efficient way to do this. - // All we're doing is making sure that our widths sum up to 100 and take - // any excess width off all widgets equally to keep the proportions. - let toReclaim = sum(...widths) - 100; - while (toReclaim > 0 && topWidgets.length > 0) { - for (let i = 0; i < widths.length; i++) { - if (toReclaim <= 0) break; - const w = widths[i]; - const adjusted = clamp(w - 1, MIN_WIDGET_WIDTH_PCT, 100); - if (adjusted !== w) { - toReclaim -= 1; - widths[i] = adjusted; + // If we're still over, find the widgets which have more width than the minimum + // and balance them out until we're at 100%. This should keep us as close as possible + // to the intended distributions. + // + // Note: if we ever decide to set a minimum which is larger than 100%/MAX_WIDGETS then + // we probably have other issues - this code assumes we don't do that. + const toReclaim = sum(...widths) - 100; + if (toReclaim > 0) { + const largeIndices = widths + .map((v, i) => ([i, v])) + .filter(p => p[1] > MIN_WIDGET_WIDTH_PCT) + .map(p => p[0]); + for (const idx of largeIndices) { + widths[idx] -= toReclaim / largeIndices.length; + } } } }