Merge pull request flutter#20 from canonical/feature/mir-positioning-code

Use Mir positioning code

Author: hbatagelo

shell/platform/windows/client_wrapper/BUILD.gn

@@ -13,6 +13,7 @@ _wrapper_includes = [
   "include/flutter/flutter_view.h",
   "include/flutter/flutter_win32_window.h",
   "include/flutter/flutter_window_controller.h",
+  "include/flutter/flutter_window_types.h",
   "include/flutter/plugin_registrar_windows.h",
   "include/flutter/win32_window.h",
 ]

shell/platform/windows/client_wrapper/flutter_window_controller.cc

@@ -6,6 +6,7 @@
 #include <dwmapi.h>
 
 namespace {
+
 auto const* const kChannel{"flutter/windowing"};
 auto const* const kErrorCodeInvalidValue{"INVALID_VALUE"};
 auto const* const kErrorCodeUnavailable{"UNAVAILABLE"};
@@ -131,7 +132,7 @@ void handleCreateWindow(flutter::FlutterWindowArchetype archetype,
   }
 
   std::optional<flutter::FlutterWindowPositioner> positioner;
-  std::optional<flutter::FlutterWindowPositioner::Rect> anchor_rect;
+  std::optional<flutter::FlutterWindowRectangle> anchor_rect;
 
   if (archetype == flutter::FlutterWindowArchetype::satellite ||
       archetype == flutter::FlutterWindowArchetype::popup) {
@@ -144,11 +145,10 @@ void handleCreateWindow(flutter::FlutterWindowArchetype archetype,
         if (!anchor_rect_list) {
           return;
         }
-        anchor_rect = flutter::FlutterWindowPositioner::Rect{
-            .x = anchor_rect_list->at(0),
-            .y = anchor_rect_list->at(1),
-            .width = anchor_rect_list->at(2),
-            .height = anchor_rect_list->at(3)};
+        anchor_rect = flutter::FlutterWindowRectangle{
+            {.x = anchor_rect_list->at(0), .y = anchor_rect_list->at(1)},
+            {.width = anchor_rect_list->at(2),
+             .height = anchor_rect_list->at(3)}};
       }
     } else {
       result->Error(kErrorCodeInvalidValue,
@@ -166,36 +166,9 @@ void handleCreateWindow(flutter::FlutterWindowArchetype archetype,
     if (!positioner_child_anchor) {
       return;
     }
-
-    auto const gravity{[](flutter::FlutterWindowPositioner::Anchor anchor)
-                           -> flutter::FlutterWindowPositioner::Gravity {
-      // Convert from |FlutterWindowPositioner::Anchor| (originally a
-      // |WindowPositionerAnchor|) to |FlutterWindowPositioner::Gravity|
-      switch (anchor) {
-        case flutter::FlutterWindowPositioner::Anchor::none:
-          return flutter::FlutterWindowPositioner::Gravity::none;
-        case flutter::FlutterWindowPositioner::Anchor::top:
-          return flutter::FlutterWindowPositioner::Gravity::bottom;
-        case flutter::FlutterWindowPositioner::Anchor::bottom:
-          return flutter::FlutterWindowPositioner::Gravity::top;
-        case flutter::FlutterWindowPositioner::Anchor::left:
-          return flutter::FlutterWindowPositioner::Gravity::right;
-        case flutter::FlutterWindowPositioner::Anchor::right:
-          return flutter::FlutterWindowPositioner::Gravity::left;
-        case flutter::FlutterWindowPositioner::Anchor::top_left:
-          return flutter::FlutterWindowPositioner::Gravity::bottom_right;
-        case flutter::FlutterWindowPositioner::Anchor::bottom_left:
-          return flutter::FlutterWindowPositioner::Gravity::top_right;
-        case flutter::FlutterWindowPositioner::Anchor::top_right:
-          return flutter::FlutterWindowPositioner::Gravity::bottom_left;
-        case flutter::FlutterWindowPositioner::Anchor::bottom_right:
-          return flutter::FlutterWindowPositioner::Gravity::top_left;
-      }
-      std::cerr << "Unhandled anchor value: " << static_cast<int>(anchor)
-                << "\n";
-      std::abort();
-    }(static_cast<flutter::FlutterWindowPositioner::Anchor>(
-                               positioner_child_anchor.value()))};
+    auto const child_anchor{
+        static_cast<flutter::FlutterWindowPositioner::Anchor>(
+            positioner_child_anchor.value())};
 
     auto const positioner_offset_list{getListValuesForKeyOrSendError<int, 2>(
         "positionerOffset", map, result)};
@@ -210,13 +183,14 @@ void handleCreateWindow(flutter::FlutterWindowArchetype archetype,
     }
     positioner = flutter::FlutterWindowPositioner{
         .anchor_rect = anchor_rect,
-        .anchor = static_cast<flutter::FlutterWindowPositioner::Anchor>(
+        .parent_anchor = static_cast<flutter::FlutterWindowPositioner::Anchor>(
             positioner_parent_anchor.value()),
-        .gravity = gravity,
-        .offset = {.dx = positioner_offset_list->at(0),
-                   .dy = positioner_offset_list->at(1)},
+        .child_anchor = child_anchor,
+        .offset = {.x = positioner_offset_list->at(0),
+                   .y = positioner_offset_list->at(1)},
         .constraint_adjustment =
-            static_cast<uint32_t>(positioner_constraint_adjustment.value())};
+            static_cast<flutter::FlutterWindowPositioner::ConstraintAdjustment>(
+                positioner_constraint_adjustment.value())};
   }
 
   std::optional<flutter::FlutterViewId> parent_view_id;
@@ -260,9 +234,7 @@ void handleCreateWindow(flutter::FlutterWindowArchetype archetype,
 
   if (auto const data_opt{
           flutter::FlutterWindowController::instance().createWindow(
-              title,
-              {static_cast<unsigned int>(size_list->at(0)),
-               static_cast<unsigned int>(size_list->at(1))},
+              title, {.width = size_list->at(0), .height = size_list->at(1)},
               archetype, positioner, parent_view_id)}) {
     auto const& data{data_opt.value()};
     result->Success(flutter::EncodableValue(flutter::EncodableMap{
@@ -352,7 +324,7 @@ void FlutterWindowController::setEngine(std::shared_ptr<FlutterEngine> engine) {
 
 auto FlutterWindowController::createWindow(
     std::wstring const& title,
-    Win32Window::Size const& size,
+    FlutterWindowSize const& size,
     FlutterWindowArchetype archetype,
     std::optional<FlutterWindowPositioner> positioner,
     std::optional<FlutterViewId> parent_view_id)

shell/platform/windows/client_wrapper/include/flutter/flutter_window_controller.h

@@ -6,24 +6,12 @@
 #include <mutex>
 
 #include "flutter_engine.h"
-#include "flutter_view.h"
 #include "flutter_win32_window.h"
+#include "flutter_window_types.h"
 #include "method_channel.h"
 
 namespace flutter {
 
-struct FlutterWindowSize {
-  int width = 0;
-  int height = 0;
-};
-
-struct FlutterWindowCreationResult {
-  FlutterViewId view_id;
-  std::optional<FlutterViewId> parent_id = std::nullopt;
-  FlutterWindowArchetype archetype;
-  FlutterWindowSize size;
-};
-
 // A singleton controller for Flutter windows.
 class FlutterWindowController {
  public:
@@ -45,7 +33,7 @@ class FlutterWindowController {
 
   void setEngine(std::shared_ptr<FlutterEngine> engine);
   auto createWindow(std::wstring const& title,
-                    Win32Window::Size const& size,
+                    FlutterWindowSize const& size,
                     FlutterWindowArchetype archetype,
                     std::optional<FlutterWindowPositioner> positioner,
                     std::optional<FlutterViewId> parent_view_id)

shell/platform/windows/client_wrapper/include/flutter/flutter_window_types.h

@@ -0,0 +1,96 @@
+#ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_CLIENT_WRAPPER_INCLUDE_FLUTTER_FLUTTER_WINDOW_TYPES_H_
+#define FLUTTER_SHELL_PLATFORM_WINDOWS_CLIENT_WRAPPER_INCLUDE_FLUTTER_FLUTTER_WINDOW_TYPES_H_
+
+#include "flutter_view.h"
+
+#include <optional>
+
+namespace flutter {
+
+struct FlutterWindowSize {
+  int width{0};
+  int height{0};
+};
+
+struct FlutterWindowPoint {
+  int x{0};
+  int y{0};
+
+  auto operator+(FlutterWindowSize const& size) const -> FlutterWindowPoint {
+    return {x + size.width, y + size.height};
+  }
+
+  friend auto operator+(FlutterWindowPoint const& lhs,
+                        FlutterWindowPoint const& rhs) -> FlutterWindowPoint {
+    return {lhs.x + rhs.x, lhs.y + rhs.y};
+  }
+};
+
+struct FlutterWindowRectangle {
+  FlutterWindowPoint top_left;
+  FlutterWindowSize size;
+
+  // Checks if this rectangle fully contains |rect|.
+  // Note: An empty rectangle can still contain other empty rectangles,
+  // which are treated as points or lines of thickness zero
+  auto contains(FlutterWindowRectangle const& rect) const -> bool {
+    return rect.top_left.x >= top_left.x &&
+           rect.top_left.x + rect.size.width <= top_left.x + size.width &&
+           rect.top_left.y >= top_left.y &&
+           rect.top_left.y + rect.size.height <= top_left.y + size.height;
+  }
+};
+
+struct FlutterWindowPositioner {
+  enum class Anchor {
+    none,
+    top,
+    bottom,
+    left,
+    right,
+    top_left,
+    bottom_left,
+    top_right,
+    bottom_right,
+  };
+
+  enum ConstraintAdjustment {
+    none = 0,
+    slide_x = 1 << 0,
+    slide_y = 1 << 1,
+    flip_x = 1 << 2,
+    flip_y = 1 << 3,
+    resize_x = 1 << 4,
+    resize_y = 1 << 5,
+    antipodes = 1 << 6,
+    flip_any = flip_x | flip_y,
+    slide_any = slide_x | slide_y,
+    resize_any = resize_x | resize_y,
+  };
+
+  std::optional<FlutterWindowRectangle> anchor_rect;
+  Anchor parent_anchor{Anchor::none};
+  Anchor child_anchor{Anchor::none};
+  FlutterWindowPoint offset;
+  ConstraintAdjustment constraint_adjustment{ConstraintAdjustment::none};
+};
+
+enum class FlutterWindowArchetype {
+  regular,
+  floating_regular,
+  dialog,
+  satellite,
+  popup,
+  tip,
+};
+
+struct FlutterWindowCreationResult {
+  FlutterViewId view_id{0};
+  std::optional<FlutterViewId> parent_id;
+  FlutterWindowArchetype archetype{FlutterWindowArchetype::regular};
+  FlutterWindowSize size;
+};
+
+}  // namespace flutter
+
+#endif  // FLUTTER_SHELL_PLATFORM_WINDOWS_CLIENT_WRAPPER_INCLUDE_FLUTTER_FLUTTER_WINDOW_TYPES_H_

shell/platform/windows/client_wrapper/include/flutter/win32_window.h

@@ -1,6 +1,8 @@
 #ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_CLIENT_WRAPPER_INCLUDE_FLUTTER_WIN32_WINDOW_H_
 #define FLUTTER_SHELL_PLATFORM_WINDOWS_CLIENT_WRAPPER_INCLUDE_FLUTTER_WIN32_WINDOW_H_
 
+#include "flutter_window_types.h"
+
 #include <windows.h>
 
 #include <optional>
@@ -9,92 +11,11 @@
 
 namespace flutter {
 
-enum class FlutterWindowArchetype {
-  regular,
-  floating_regular,
-  dialog,
-  satellite,
-  popup,
-  tip
-};
-
-struct FlutterWindowPositioner {
-  struct Size {
-    int32_t width;
-    int32_t height;
-  };
-
-  struct Rect {
-    int32_t x;
-    int32_t y;
-    int32_t width;
-    int32_t height;
-  };
-
-  struct Offset {
-    int32_t dx;
-    int32_t dy;
-  };
-
-  enum class Anchor {
-    none,
-    top,
-    bottom,
-    left,
-    right,
-    top_left,
-    bottom_left,
-    top_right,
-    bottom_right
-  };
-
-  enum class Gravity {
-    none,
-    top,
-    bottom,
-    left,
-    right,
-    top_left,
-    bottom_left,
-    top_right,
-    bottom_right
-  };
-
-  enum class ConstraintAdjustment {
-    none = 0,
-    slide_x = 1,
-    slide_y = 2,
-    flip_x = 4,
-    flip_y = 8,
-    resize_x = 16,
-    resize_y = 32
-  };
-
-  std::optional<Rect> anchor_rect;
-  Anchor anchor;
-  Gravity gravity;
-  Offset offset;
-  uint32_t constraint_adjustment;
-};
-
 // A class abstraction for a high DPI-aware Win32 Window. Intended to be
 // inherited from by classes that wish to specialize with custom
 // rendering and input handling.
 class Win32Window {
  public:
-  struct Point {
-    unsigned int x;
-    unsigned int y;
-    Point(unsigned int x, unsigned int y) : x(x), y(y) {}
-  };
-
-  struct Size {
-    unsigned int width;
-    unsigned int height;
-    Size(unsigned int width, unsigned int height)
-        : width(width), height(height) {}
-  };
-
   Win32Window();
   virtual ~Win32Window();
 
@@ -106,7 +27,7 @@ class Win32Window {
   // is created if |parent| is specified; otherwise, the dialog is modeless.
   // After creation, |OnCreate| is called and its result is returned.
   auto Create(std::wstring const& title,
-              Size const& client_size,
+              FlutterWindowSize const& client_size,
               FlutterWindowArchetype archetype,
               std::optional<HWND> parent,
               std::optional<FlutterWindowPositioner> positioner) -> bool;