TF-3479 Rename & separate function to make it readable and understand more about the case.

Signed-off-by: dab246 <tdvu@linagora.com>

lib/features/composer/presentation/extensions/update_screen_display_mode_extension.dart

@@ -39,7 +39,7 @@ extension UpdateScreenDisplayModeExtension on ComposerController {
     final composerManager = mailboxDashBoardController.composerManager;
     final screenWidth = responsiveUtils.getSizeScreenWidth(currentContext!);
 
-    composerManager.syncComposerStateWhenComposerDisplayModeChanged(
+    composerManager.arrangeComposerWhenComposerDisplayModeChanged(
       screenWidth: screenWidth,
       updatedComposerId: composerId!,
       newDisplayMode: newDisplayMode,

lib/features/composer/presentation/manager/composer_manager.dart

@@ -1,6 +1,7 @@
 import 'dart:collection';
 import 'package:collection/collection.dart';
 import 'package:core/presentation/utils/responsive_utils.dart';
+import 'package:core/utils/app_logger.dart';
 import 'package:flutter/material.dart';
 import 'package:get/get.dart';
 import 'package:tmail_ui_user/features/composer/presentation/composer_bindings.dart';
@@ -25,7 +26,7 @@ class ComposerManager extends GetxController {
     composers[id] = ComposerView(key: Key(id), composerId: id);
     composerIdsQueue.add(id);
 
-    _syncQueueIfNeeded();
+    _arrangeComposerIfNeeded();
   }
 
   void removeComposer(String id) {
@@ -35,47 +36,23 @@ class ComposerManager extends GetxController {
     composers.remove(id);
     ComposerBindings(composerId: id).dispose();
 
-    _syncQueueIfNeeded();
+    _arrangeComposerIfNeeded();
   }
 
-  void _syncQueueIfNeeded() {
+  void _arrangeComposerIfNeeded() {
     if (currentContext != null && composerIdsQueue.isNotEmpty) {
-      syncComposerStateWhenComposerQueueChanged(
+      arrangeComposerWhenComposerQueueChanged(
         screenWidth: _responsiveUtils.getSizeScreenWidth(currentContext!),
       );
     }
   }
 
-  ({
-    String? previousTargetId,
-    String? targetId,
-    String? nextTargetId,
-  }) findSurroundingComposerIds(String targetId) {
-    var ids = composerIdsQueue.toList(),
-        index = ids.indexOf(targetId);
-
-    return index == -1
-      ? (previousTargetId: null, targetId: null, nextTargetId: null)
-      : (
-          previousTargetId: index > 0 ? ids[index - 1] : null,
-          targetId: ids[index],
-          nextTargetId: index < ids.length - 1 ? ids[index + 1] : null
-        );
-  }
-
-  String? findFirstNormalComposerIdInQueue() {
-    return composerIdsQueue
-      .toList()
-      .reversed
-      .firstWhereOrNull((id) => getComposerView(id).controller.isNormalScreen);
-  }
-
   (
-    double availableWidth,
+    double availableScreenWidth,
-    double totalWidth,
+    double totalOpenedComposersWidth,
     Map<String, ComposerController> composerControllers
-  ) _setUpDataToSyncComposerQueue({required double screenWidth}) {
+  ) _getSizeToArrangeComposer({required double screenWidth}) {
-    double totalWidth = 0;
+    double totalOpenedComposersWidth = 0;
     double countDisplayedComposer = 0;
     final composerControllers = <String, ComposerController>{};
 
@@ -86,39 +63,44 @@ class ComposerManager extends GetxController {
         countDisplayedComposer++;
       }
       composerControllers[id] = controller;
-      totalWidth += composerWidth;
+      totalOpenedComposersWidth += composerWidth;
     }
 
-    final availableWidth = screenWidth
+    final availableScreenWidth = screenWidth
       - ComposerStyle.composerExpandMoreButtonMaxWidth
-      - ComposerStyle.padding * 3
+      - ComposerStyle.padding * 2
       - (countDisplayedComposer - 1) * ComposerStyle.space;
-
+    log('ComposerManager::_getSizeToArrangeComposers:screenWidth = $screenWidth | availableScreenWidth = $availableScreenWidth | totalOpenedComposersWidth = $totalOpenedComposersWidth');
     return (
-      availableWidth,
+      availableScreenWidth,
-      totalWidth,
+      totalOpenedComposersWidth,
       composerControllers,
     );
   }
 
-  void syncComposerStateWhenComposerQueueChanged({required double screenWidth}) {
+  void _showMinimizedComposersIfOverflow({
-    var (availableWidth, totalWidth, composerControllers) =
+    required double availableScreenWidth,
-      _setUpDataToSyncComposerQueue(screenWidth: screenWidth);
+    required double totalOpenedComposersWidth,
-
+    required Map<String, ComposerController> composerControllers,
-    if (totalWidth < availableWidth) {
+  }) {
     final currentHiddenComposerIds = hiddenComposerIds;
     if (currentHiddenComposerIds.isEmpty) return;
 
     for (var index = currentHiddenComposerIds.length - 1; index >= 0; index--) {
-        final newTotalWidth = totalWidth + ComposerStyle.minimizeWidth;
+      final newTotalWidth = totalOpenedComposersWidth + ComposerStyle.minimizeWidth;
-        if (newTotalWidth > availableWidth) break;
+      if (newTotalWidth > availableScreenWidth) break;
 
       final id = currentHiddenComposerIds.elementAt(index);
-        final controller = composerControllers[id]!;
+      composerControllers[id]!.setScreenDisplayMode(ScreenDisplayMode.minimize);
-        controller.setScreenDisplayMode(ScreenDisplayMode.minimize);
+      totalOpenedComposersWidth = newTotalWidth;
-        totalWidth = newTotalWidth;
     }
-    } else if (totalWidth > availableWidth) {
+  }
+
+  void _hideComposersIfFit({
+    required double availableScreenWidth,
+    required double totalOpenedComposersWidth,
+    required Map<String, ComposerController> composerControllers,
+  }) {
     final currentDisplayedComposerIds = displayedComposerIds;
     if (currentDisplayedComposerIds.isEmpty) return;
 
@@ -126,82 +108,108 @@ class ComposerManager extends GetxController {
       final controller = composerControllers[id]!;
 
       if (controller.isNormalScreen) {
-          var newTotalWidth = totalWidth - (ComposerStyle.normalWidth - ComposerStyle.minimizeWidth);
+        var newTotalWidth = totalOpenedComposersWidth - (ComposerStyle.normalWidth - ComposerStyle.minimizeWidth);
         var newDisplayMode = ScreenDisplayMode.minimize;
 
-          if (newTotalWidth > availableWidth) {
+        if (newTotalWidth > availableScreenWidth) {
-            newTotalWidth = totalWidth - ComposerStyle.normalWidth;
+          newTotalWidth = totalOpenedComposersWidth - ComposerStyle.normalWidth;
           newDisplayMode = ScreenDisplayMode.hidden;
         }
 
         controller.setScreenDisplayMode(newDisplayMode);
-          totalWidth = newTotalWidth;
+        totalOpenedComposersWidth = newTotalWidth;
       } else if (controller.isMinimizeScreen) {
-          final newTotalWidth = totalWidth - ComposerStyle.minimizeWidth;
+        final newTotalWidth = totalOpenedComposersWidth - ComposerStyle.minimizeWidth;
         controller.setScreenDisplayMode(ScreenDisplayMode.hidden);
-          totalWidth = newTotalWidth;
+        totalOpenedComposersWidth = newTotalWidth;
       }
 
-        if (totalWidth <= availableWidth) break;
+      if (totalOpenedComposersWidth <= availableScreenWidth) break;
-      }
     }
   }
 
-  void syncComposerStateWhenComposerDisplayModeChanged({
+  void arrangeComposerWhenComposerQueueChanged({required double screenWidth}) {
-    required double screenWidth,
+    var (availableScreenWidth, totalOpenedComposersWidth, composerControllers) =
+      _getSizeToArrangeComposer(screenWidth: screenWidth);
+
+    if (totalOpenedComposersWidth < availableScreenWidth) {
+      _showMinimizedComposersIfOverflow(
+        availableScreenWidth: availableScreenWidth,
+        totalOpenedComposersWidth: totalOpenedComposersWidth,
+        composerControllers: composerControllers,
+      );
+    } else if (totalOpenedComposersWidth > availableScreenWidth) {
+      _hideComposersIfFit(
+        availableScreenWidth: availableScreenWidth,
+        totalOpenedComposersWidth: totalOpenedComposersWidth,
+        composerControllers: composerControllers,
+      );
+    }
+  }
+
+  void _hideComposersPreferringMinimizedIfFit({
     required String updatedComposerId,
-    required ScreenDisplayMode newDisplayMode,
+    required double availableScreenWidth,
+    required double totalOpenedComposersWidth,
+    required Map<String, ComposerController> composerControllers,
   }) {
-    if (composerIdsQueue.isEmpty) return;
-
-    var (availableWidth, totalWidth, composerControllers) =
-      _setUpDataToSyncComposerQueue(screenWidth: screenWidth);
-
-    if (totalWidth < availableWidth) {
-      final currentHiddenComposerIds = hiddenComposerIds;
-      if (currentHiddenComposerIds.isEmpty) return;
-
-      for (var index = currentHiddenComposerIds.length - 1; index >= 0; index--) {
-        final newTotalWidth = totalWidth + ComposerStyle.minimizeWidth;
-        if (newTotalWidth > availableWidth) break;
-
-        final id = currentHiddenComposerIds.elementAt(index);
-        composerControllers[id]!.setScreenDisplayMode(ScreenDisplayMode.minimize);
-        totalWidth = newTotalWidth;
-      }
-    } else if (totalWidth > availableWidth) {
     for (var id in minimizeComposerIds) {
       if (id == updatedComposerId) continue;
 
       composerControllers[id]!.setScreenDisplayMode(ScreenDisplayMode.hidden);
-        totalWidth -= ComposerStyle.minimizeWidth;
+      totalOpenedComposersWidth -= ComposerStyle.minimizeWidth;
-        if (totalWidth <= availableWidth) return;
+      if (totalOpenedComposersWidth <= availableScreenWidth) return;
     }
 
     for (var id in normalComposerIds) {
       if (id == updatedComposerId) continue;
 
       final controller = composerControllers[id]!;
-        var newTotalWidth = totalWidth - (ComposerStyle.normalWidth - ComposerStyle.minimizeWidth);
+      var newTotalWidth = totalOpenedComposersWidth - (ComposerStyle.normalWidth - ComposerStyle.minimizeWidth);
 
-        if (newTotalWidth <= availableWidth) {
+      if (newTotalWidth <= availableScreenWidth) {
         controller.setScreenDisplayMode(ScreenDisplayMode.minimize);
         return;
       }
 
-        newTotalWidth = totalWidth - ComposerStyle.normalWidth;
+      newTotalWidth = totalOpenedComposersWidth - ComposerStyle.normalWidth;
-        if (newTotalWidth <= availableWidth) {
+      if (newTotalWidth <= availableScreenWidth) {
         controller.setScreenDisplayMode(ScreenDisplayMode.hidden);
         return;
       }
 
-        totalWidth = newTotalWidth;
+      totalOpenedComposersWidth = newTotalWidth;
-      }
     }
   }
 
-  void syncComposerStateWhenResponsiveChanged({required double screenWidth}) =>
+  void arrangeComposerWhenComposerDisplayModeChanged({
-      syncComposerStateWhenComposerQueueChanged(screenWidth: screenWidth);
+    required double screenWidth,
+    required String updatedComposerId,
+    required ScreenDisplayMode newDisplayMode,
+  }) {
+    if (composerIdsQueue.isEmpty) return;
+
+    var (availableScreenWidth, totalOpenedComposersWidth, composerControllers) =
+      _getSizeToArrangeComposer(screenWidth: screenWidth);
+
+    if (totalOpenedComposersWidth < availableScreenWidth) {
+      _showMinimizedComposersIfOverflow(
+        availableScreenWidth: availableScreenWidth,
+        totalOpenedComposersWidth: totalOpenedComposersWidth,
+        composerControllers: composerControllers,
+      );
+    } else if (totalOpenedComposersWidth > availableScreenWidth) {
+      _hideComposersPreferringMinimizedIfFit(
+        updatedComposerId: updatedComposerId,
+        availableScreenWidth: availableScreenWidth,
+        totalOpenedComposersWidth: totalOpenedComposersWidth,
+        composerControllers: composerControllers,
+      );
+    }
+  }
+
+  void arrangeComposerWhenResponsiveChanged({required double screenWidth}) =>
+    arrangeComposerWhenComposerQueueChanged(screenWidth: screenWidth);
 
   bool get hasComposer => composerIdsQueue.isNotEmpty;
 
@@ -267,7 +275,7 @@ class ComposerManager extends GetxController {
     composerIdsQueue.add(composerId);
     final composerView = getComposerView(composerId);
     composerView.controller.setScreenDisplayMode(ScreenDisplayMode.normal);
-    _syncQueueIfNeeded();
+    _arrangeComposerIfNeeded();
   }
 
   ComposerView getComposerView(String id) => composers[id]!;

lib/features/composer/presentation/view/web/composer_overlay_view.dart

@@ -18,7 +18,7 @@ class ComposerOverlayView extends StatelessWidget {
     final screenWidth = MediaQuery.sizeOf(context).width;
 
     if (_composerManager.composers.isNotEmpty) {
-      _composerManager.syncComposerStateWhenResponsiveChanged(screenWidth: screenWidth);
+      _composerManager.arrangeComposerWhenResponsiveChanged(screenWidth: screenWidth);
     }
 
     return Obx(() {