adaptive style

examples/adaptive_style_example/lib/main.dart

@@ -22,21 +22,24 @@ class MyHomePage extends StatelessWidget {
   Widget build(context) => Material(
         child: AdaptiveStackBuilder(
           builder: (context, scaleRef, parentSize) => [
-            AdaptiveAnchorPositioned(
+            AdaptivePositioned(
               parentSize: parentSize,
               data: const AdaptiveAnchorData(
                 dimension: 100,
-                edges: AnchorEdges.bottom(),
+                anchor: AnchorEdges.bottom(),
               ),
               builder: (context, scaleRef, parentSize) => AdaptiveStack(
                 parentSize: parentSize,
                 builder: (context, scaleRef, parentSize) => [
                   const SizedBox.expand(child: ColoredBox(color: Colors.red)),
-                  Center(
-                    child: SizedBox.square(
-                      dimension: 50 * scaleRef.scale.min,
-                      child: const FlutterLogo(),
+                  AdaptivePositioned(
+                    builder: (context, scaleRef, parentSize) =>
+                        const FlutterLogo(),
+                    data: const AdaptiveAlignmentData(
+                      alignment: AdaptiveAlignment.center(),
+                      size: Size.square(54),
                     ),
+                    parentSize: parentSize,
                   ),
                 ],
               ),

packages/adaptive_style/CHANGELOG.md

@@ -1,2 +1,2 @@
-### 0.0.2
+### 0.0.3
 - initial releases

packages/adaptive_style/README.md

@@ -26,9 +26,9 @@ ScaleRefProvider(
 
 ### what's included?
 
-- `AdaptiveWidget` the base to build your own custom adaptive widget
-- `AdaptiveStack` just like a `Stack` but builds it's children as an `AdaptiveWidget`
-- `AdaptiveAnchorPositioned` a `Positioned` that place itself at one of the parent's edges
+- `AdaptiveWidget`: the base to build your own custom adaptive widget
+- `AdaptiveStack`: just like a `Stack` but builds it's children as an `AdaptiveWidget`
+- `AdaptivePositioned`: a `Positioned` that place itself at one of the parent's edges
 
 
 

packages/adaptive_style/lib/adaptive_style.dart

@@ -1,15 +1,19 @@
 library adaptive_style;
 
-export 'src/adaptive_achor_positioned.dart';
-export 'src/scale_mediaquery_widget.dart';
+export 'src/adaptive_alignment.dart';
+export 'src/adaptive_alignment_data.dart';
+export 'src/adaptive_anchor_data.dart';
+export 'src/adaptive_data.dart';
+export 'src/adaptive_positioned.dart';
 export 'src/adaptive_stack.dart';
 export 'src/adaptive_widget_builder.dart';
 export 'src/adaptive_widget.dart';
+export 'src/anchor_edges.dart';
 export 'src/device_size.dart';
-export 'src/extension.dart';
+export 'src/extensions.dart';
 export 'src/inherited_scale_ref.dart';
+export 'src/positioned_data.dart';
+export 'src/scale_mediaquery_widget.dart';
 export 'src/scale_ref_provider.dart';
 export 'src/scale_ref.dart';
 export 'src/size_scale.dart';
-export 'src/anchor_edges.dart';
-export 'src/positioned_data.dart';

packages/adaptive_style/lib/src/adaptive_alignment.dart

@@ -0,0 +1,147 @@
+import 'dart:ui';
+
+import 'package:meta/meta.dart';
+
+abstract class AdaptiveAlignment {
+  const factory AdaptiveAlignment.topLeft({Offset padding}) =
+      AdaptiveAlignmentTopLeft;
+  const factory AdaptiveAlignment.topRight({Offset padding}) =
+      AdaptiveAlignmentTopRight;
+  const factory AdaptiveAlignment.bottomLeft({Offset padding}) =
+      AdaptiveAlignmentBottomLeft;
+  const factory AdaptiveAlignment.bottomRight({Offset padding}) =
+      AdaptiveAlignmentBottomRight;
+  const factory AdaptiveAlignment.centerLeft({double padding}) =
+      AdaptiveAlignmentCenterLeft;
+  const factory AdaptiveAlignment.centerRight({double padding}) =
+      AdaptiveAlignmentCenterRight;
+  const factory AdaptiveAlignment.topCenter({double padding}) =
+      AdaptiveAlignmentTopCenter;
+  const factory AdaptiveAlignment.bottomCenter({double padding}) =
+      AdaptiveAlignmentBottomCenter;
+  const factory AdaptiveAlignment.center() = AdaptiveAlignmentCenter;
+}
+
+class AdaptiveAlignmentTopLeft implements AdaptiveAlignment {
+  const AdaptiveAlignmentTopLeft({this.padding = Offset.zero});
+
+  final Offset padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentTopRight implements AdaptiveAlignment {
+  const AdaptiveAlignmentTopRight({this.padding = Offset.zero});
+
+  final Offset padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentBottomLeft implements AdaptiveAlignment {
+  const AdaptiveAlignmentBottomLeft({this.padding = Offset.zero});
+
+  final Offset padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentBottomRight implements AdaptiveAlignment {
+  const AdaptiveAlignmentBottomRight({this.padding = Offset.zero});
+
+  final Offset padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentTopCenter implements AdaptiveAlignment {
+  const AdaptiveAlignmentTopCenter({this.padding = 0});
+
+  final double padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentBottomCenter implements AdaptiveAlignment {
+  const AdaptiveAlignmentBottomCenter({this.padding = 0});
+
+  final double padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentCenterLeft implements AdaptiveAlignment {
+  const AdaptiveAlignmentCenterLeft({this.padding = 0});
+
+  final double padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentCenterRight implements AdaptiveAlignment {
+  const AdaptiveAlignmentCenterRight({this.padding = 0});
+
+  final double padding;
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => Object.hash(runtimeType, padding);
+}
+
+class AdaptiveAlignmentCenter implements AdaptiveAlignment {
+  const AdaptiveAlignmentCenter();
+
+  @override
+  @nonVirtual
+  bool operator ==(other) => other.hashCode == hashCode;
+
+  @override
+  @nonVirtual
+  int get hashCode => runtimeType.hashCode;
+}

packages/adaptive_style/lib/src/adaptive_alignment_data.dart

@@ -0,0 +1,163 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/rendering.dart';
+
+import 'adaptive_alignment.dart';
+import 'adaptive_data.dart';
+import 'positioned_data.dart';
+
+final class AdaptiveAlignmentData implements AdaptiveData {
+  final AdaptiveAlignment alignment;
+  final Size size;
+
+  const AdaptiveAlignmentData({
+    required this.alignment,
+    required this.size,
+  });
+
+  @override
+  @nonVirtual
+  PositionedData positioned({
+    double scale = 0,
+    required Size parentSize,
+  }) {
+    final scaledSize = size * scale;
+    final leftovers = (parentSize - scaledSize) as Offset;
+    switch (AdaptiveAlignment) {
+      case (AdaptiveAlignmentTopRight alignment):
+        {
+          final scaledAdaptiveAlignmentPadding =
+              alignment.padding.scale(scale, scale);
+          return PositionedData(
+            EdgeInsets.only(
+              top: scaledAdaptiveAlignmentPadding.dy,
+              right: scaledAdaptiveAlignmentPadding.dx,
+              bottom: leftovers.dy - scaledAdaptiveAlignmentPadding.dy,
+              left: leftovers.dx - scaledAdaptiveAlignmentPadding.dx,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentTopLeft alignment):
+        {
+          final scaledAdaptiveAlignmentPadding =
+              alignment.padding.scale(scale, scale);
+          return PositionedData(
+            EdgeInsets.only(
+              top: scaledAdaptiveAlignmentPadding.dy,
+              left: scaledAdaptiveAlignmentPadding.dx,
+              bottom: leftovers.dy - scaledAdaptiveAlignmentPadding.dy,
+              right: leftovers.dx - scaledAdaptiveAlignmentPadding.dx,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentBottomRight alignment):
+        {
+          final scaledAdaptiveAlignmentPadding =
+              alignment.padding.scale(scale, scale);
+          return PositionedData(
+            EdgeInsets.only(
+              bottom: scaledAdaptiveAlignmentPadding.dy,
+              right: scaledAdaptiveAlignmentPadding.dx,
+              top: leftovers.dy - scaledAdaptiveAlignmentPadding.dy,
+              left: leftovers.dx - scaledAdaptiveAlignmentPadding.dx,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentBottomLeft alignment):
+        {
+          final scaledAdaptiveAlignmentPadding =
+              alignment.padding.scale(scale, scale);
+          return PositionedData(
+            EdgeInsets.only(
+              bottom: scaledAdaptiveAlignmentPadding.dy,
+              left: scaledAdaptiveAlignmentPadding.dx,
+              top: leftovers.dy - scaledAdaptiveAlignmentPadding.dy,
+              right: leftovers.dx - scaledAdaptiveAlignmentPadding.dx,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentTopCenter alignment):
+        {
+          final scaledAdaptiveAlignmentPadding = alignment.padding * scale;
+          final crossAxisLeftovers = leftovers.dx / 2;
+          return PositionedData(
+            EdgeInsets.only(
+              top: scaledAdaptiveAlignmentPadding,
+              bottom: leftovers.dy - scaledAdaptiveAlignmentPadding,
+              left: crossAxisLeftovers,
+              right: crossAxisLeftovers,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentBottomCenter alignment):
+        {
+          final scaledAdaptiveAlignmentPadding = alignment.padding * scale;
+          final crossAxisLeftovers = leftovers.dx / 2;
+          return PositionedData(
+            EdgeInsets.only(
+              top: scaledAdaptiveAlignmentPadding,
+              bottom: leftovers.dy - scaledAdaptiveAlignmentPadding,
+              left: crossAxisLeftovers,
+              right: crossAxisLeftovers,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentCenterRight alignment):
+        {
+          final scaledAdaptiveAlignmentPadding = alignment.padding * scale;
+          final crossAxisLeftovers = leftovers.dy / 2;
+          return PositionedData(
+            EdgeInsets.only(
+              top: crossAxisLeftovers,
+              bottom: crossAxisLeftovers,
+              left: leftovers.dx - scaledAdaptiveAlignmentPadding,
+              right: scaledAdaptiveAlignmentPadding,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentCenterLeft alignment):
+        {
+          final scaledAdaptiveAlignmentPadding = alignment.padding * scale;
+          final crossAxisLeftovers = leftovers.dy / 2;
+          return PositionedData(
+            EdgeInsets.only(
+              top: crossAxisLeftovers,
+              bottom: crossAxisLeftovers,
+              right: leftovers.dx - scaledAdaptiveAlignmentPadding,
+              left: scaledAdaptiveAlignmentPadding,
+            ),
+            scaledSize,
+          );
+        }
+      case (AdaptiveAlignmentCenter _):
+        {
+          final verticalLeftovers = leftovers.dy / 2;
+          final horizontalsLeftovers = leftovers.dx / 2;
+          return PositionedData(
+            EdgeInsets.only(
+              top: verticalLeftovers,
+              bottom: verticalLeftovers,
+              right: horizontalsLeftovers,
+              left: horizontalsLeftovers,
+            ),
+            scaledSize,
+          );
+        }
+      default:
+        throw Exception('undefined AdaptiveAlignment');
+    }
+  }
+
+  @override
+  bool operator ==(other) =>
+      other is AdaptiveAlignmentData && other.hashCode == hashCode;
+
+  @override
+  int get hashCode => Object.hash(alignment, size);
+}