Merge pull request #19 from 06Games/patch-4

5argon · web-flow · commit d5f7dd12a9da · 2019-06-17T13:55:13.000+07:00
Partial support of notches + The debug scene displays the simulated information + Some other changes
diff --git a/DebugScene/DebugRect.cs b/DebugScene/DebugRect.cs
@@ -24,12 +24,12 @@ public void PlaceItselfAtScreenRect(Rect screenRect, Color color = default)
         RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRect, screenRect.position, Camera.main, out Vector2 localPoint);
         RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRect, screenRect.size, Camera.main, out Vector2 localSize);
 
-        localSize = localSize + (parentRect.sizeDelta /2);
+        localSize = localSize + (parentRect.sizeDelta / 2);
 
         debugText.text = $"{screenRect}";
-        
+
         rectTransform.localPosition = localPoint;
         rectTransform.sizeDelta = localSize;
-        
+
     }
 }
diff --git a/DebugScene/NotchSolutionDebugger.cs b/DebugScene/NotchSolutionDebugger.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections;
+﻿using E7.NotchSolution;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -20,29 +21,56 @@ void Update()
 
         sb.AppendLine($"<b>-- PLEASE ROTATE THE DEVICE TO GET BOTH ORIENTATION'S DETAILS! --</b>\n");
 
-        sb.AppendLine($"Safe area : {Screen.safeArea}\n");
-        PlaceRect(Screen.safeArea, Color.red);
+#if UNITY_EDITOR
+        var safeArea = RealSize(NotchSolutionUtility.SimulateSafeAreaRelative);
+#else
+        var safeArea = Screen.safeArea;
+#endif
+        PlaceRect(safeArea, Color.red);
+        if (Screen.orientation != NotchSolutionUtility.GetCurrentOrientation())
+            safeArea.Set(Screen.width - safeArea.x, Screen.height - safeArea.y, safeArea.width, safeArea.height);
+        sb.AppendLine($"Safe area : {safeArea}\n");
 
 #if UNITY_2019_2_OR_NEWER
-        sb.AppendLine($"Cutouts : {string.Join(" / ", Screen.cutouts.Select(x => x.ToString()))} \n");
-        foreach (Rect r in Screen.cutouts)
+#if UNITY_EDITOR
+        var relativeCutouts = NotchSolutionUtility.SimulateCutoutsRelative;
+        List<Rect> rectCutouts = new List<Rect>();
+        foreach (Rect rect in relativeCutouts) rectCutouts.Add(RealSize(rect));
+        var cutouts = rectCutouts.ToArray();
+#else
+        var cutouts = Screen.cutouts;
+#endif
+        foreach (Rect r in cutouts) PlaceRect(r, Color.blue);
+
+        if (Screen.orientation != NotchSolutionUtility.GetCurrentOrientation())
         {
-            PlaceRect(r, Color.blue);
+            foreach (Rect rect in cutouts) rect.Set(Screen.width - rect.x, Screen.height - rect.y, rect.width, rect.height);
         }
+        sb.AppendLine($"Cutouts : {string.Join(" / ", cutouts.Select(x => x.ToString()))} \n");
 #endif
 
         sb.AppendLine($"Current resolution : {Screen.currentResolution}\n");
         sb.AppendLine($"All Resolutions : {string.Join(" / ", Screen.resolutions.Select(x => x.ToString()))}\n");
         sb.AppendLine($"DPI : {Screen.dpi} WxH : {Screen.width}x{Screen.height} Orientation : {Screen.orientation}\n");
-        var joinedProps = string.Join( " / ", typeof(SystemInfo).GetProperties(BindingFlags.Public | BindingFlags.Static).Select( x => $"{x.Name} : {x.GetValue(null)}"));
+        var joinedProps = string.Join(" / ", typeof(SystemInfo).GetProperties(BindingFlags.Public | BindingFlags.Static).Select(x => $"{x.Name} : {x.GetValue(null)}"));
         sb.AppendLine(joinedProps);
-        debugText.text = sb.ToString(); 
+        debugText.text = sb.ToString();
+    }
+
+    Rect RealSize(Rect relative)
+    {
+        return new Rect(
+            relative.x * Screen.width,
+            relative.y * Screen.height,
+            relative.width * Screen.width,
+            relative.height * Screen.height
+        );
     }
 
     private List<DebugRect> debugRects = new List<DebugRect>();
     public void ClearRects()
     {
-        foreach(var dbr in debugRects)
+        foreach (var dbr in debugRects)
         {
             GameObject.Destroy(dbr.gameObject);
         }
@@ -55,8 +83,7 @@ public void PlaceRect(Rect rct, Color c)
         go.transform.localScale = Vector3.one;
         //go.transform.SetAsFirstSibling();
         var dbr = go.GetComponent<DebugRect>();
-        dbr.PlaceItselfAtScreenRect(rct);
+        dbr.PlaceItselfAtScreenRect(rct, c);
         debugRects.Add(dbr);
     }
-
 }
diff --git a/Editor/EnumButtonsDrawer.cs b/Editor/EnumButtonsDrawer.cs
@@ -18,5 +18,5 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
         }
     }
 
-    
+
 }
diff --git a/Editor/NotchSimulator.cs b/Editor/NotchSimulator.cs
@@ -3,7 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using UnityEditor;
 using UnityEditor.Experimental.SceneManagement;
 using UnityEditor.SceneManagement;
@@ -16,13 +15,29 @@ namespace E7.NotchSolution
     public class NotchSimulator : EditorWindow
     {
         internal static NotchSimulator win;
+        Vector2 gameviewResolution;
 
         [MenuItem("Window/General/Notch Simulator")]
         public static void ShowWindow()
         {
             win = (NotchSimulator)EditorWindow.GetWindow(typeof(NotchSimulator));
             win.titleContent = new GUIContent("Notch Simulator");
         }
+
+        [ExecuteInEditMode] private void OnEnable() { EditorApplication.update += RespawnMockup; }
+        [ExecuteInEditMode] private void OnDisable() { EditorApplication.update -= RespawnMockup; }
+        void RespawnMockup()
+        {
+            //When the game view is changed, the mockup sometimes disappears or isn't scaled correctly
+            if (gameviewResolution != Handles.GetMainGameViewSize())
+            {
+                DestroyHiddenCanvas(); //So we delete the old canvas
+                UpdateAllMockups(); //And we respawn it
+                UpdateSimulatorTargets();
+                gameviewResolution = Handles.GetMainGameViewSize(); //Update the saved game view
+            }
+        }
+
         /// <summary>
         /// It is currently active only when Notch Simulator tab is present.
         /// </summary>
@@ -88,14 +103,16 @@ void OnGUI()
         internal static void UpdateSimulatorTargets()
         {
             var simulatedRect = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.SimulatorSafeAreaRelative : new Rect(0, 0, 1, 1);
+            var simulatedCutouts = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.SimulatorCutoutsRelative : new Rect[0];
 
             //This value could be used by the component statically.
             NotchSolutionUtility.SimulateSafeAreaRelative = simulatedRect;
+            NotchSolutionUtility.SimulateCutoutsRelative = simulatedCutouts;
 
             var normalSceneSimTargets = GameObject.FindObjectsOfType<UIBehaviour>().OfType<INotchSimulatorTarget>();
             foreach (var nst in normalSceneSimTargets)
             {
-                nst.SimulatorUpdate(simulatedRect);
+                nst.SimulatorUpdate(simulatedRect, simulatedCutouts);
             }
 
             //Now find one in the prefab mode scene as well
@@ -105,7 +122,7 @@ internal static void UpdateSimulatorTargets()
                 var prefabSceneSimTargets = prefabStage.stageHandle.FindComponentsOfType<UIBehaviour>().OfType<INotchSimulatorTarget>();
                 foreach (var nst in prefabSceneSimTargets)
                 {
-                    nst.SimulatorUpdate(simulatedRect);
+                    nst.SimulatorUpdate(simulatedRect, simulatedCutouts);
                 }
             }
         }
@@ -177,7 +194,7 @@ internal static void UpdateAllMockups()
 
             //Make the editing environment contains an another copy of mockup canvas.
             var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
-            if(prefabStage != null)
+            if (prefabStage != null)
             {
                 EnsureCanvasAndEventSetup(prefabStage: prefabStage);
             }
@@ -202,11 +219,11 @@ internal static void UpdateAllMockups()
                 {
                     mockup.Show();
                     mockup.SetMockupSprite(
-                        sprite: mockupSprite,
-                        orientation: NotchSimulatorUtility.GetGameViewOrientation(),
-                        simulate: enableSimulation,
-                        flipped: NotchSimulatorUtility.flipOrientation
-                    );
+                         sprite: mockupSprite,
+                         orientation: NotchSimulatorUtility.GetGameViewOrientation(),
+                         simulate: enableSimulation,
+                         flipped: NotchSimulatorUtility.flipOrientation
+                     );
                 }
             }
             else
@@ -245,7 +262,7 @@ private static void EnsureCanvasAndEventSetup(PrefabStage prefabStage = null)
                 else
                 {
                     var prefabGuids = AssetDatabase.FindAssets(mockupCanvasName);
-                    if(prefabGuids.Length == 0)
+                    if (prefabGuids.Length == 0)
                     {
                         return;
                     }
@@ -266,17 +283,9 @@ private static void EnsureCanvasAndEventSetup(PrefabStage prefabStage = null)
                     }
                 }
 
-
-                if (prefabMode)
-                {
-                    canvasObject.PrefabStage = true;
-                    prefabMockupCanvas = canvasObject;
-                }
-                else
-                {
-                    canvasObject.PrefabStage = false;
-                    mockupCanvas = canvasObject;
-                }
+                canvasObject.PrefabStage = prefabMode;
+                if (prefabMode) prefabMockupCanvas = canvasObject;
+                else mockupCanvas = canvasObject;
 
                 if (eventAdded == false)
                 {
diff --git a/Editor/NotchSimulatorUtility.cs b/Editor/NotchSimulatorUtility.cs
@@ -14,31 +14,54 @@ internal static Rect SimulatorSafeAreaRelative
             get
             {
                 var orientation = GetGameViewOrientation();
-                var device = SimulationDatabase.db.ContainsKey(selectedDevice) ?  selectedDevice : default;
+                var device = SimulationDatabase.db.ContainsKey(selectedDevice) ? selectedDevice : default;
                 var safe = orientation == ScreenOrientation.Landscape ? SimulationDatabase.db[device].landscapeSafeArea : SimulationDatabase.db[device].portraitSafeArea;
                 var screenSize = SimulationDatabase.db[device].screenSize;
-                if(orientation == ScreenOrientation.Landscape)
+                if (orientation == ScreenOrientation.Landscape)
                 {
                     var swap = screenSize.x;
                     screenSize.x = screenSize.y;
                     screenSize.y = swap;
                 }
-                var relativeSafeArea = new Rect(safe.xMin / screenSize.x, safe.yMin / screenSize.y, safe.width / screenSize.x, safe.height / screenSize.y);
+                return GetRelative(safe, screenSize);
+            }
+        }
 
-                if (NotchSimulatorUtility.flipOrientation)
-                {
-                    return new Rect(
-                        1 - (relativeSafeArea.width + relativeSafeArea.xMin),
-                        1 - (relativeSafeArea.height + relativeSafeArea.yMin),
-                        relativeSafeArea.width,
-                        relativeSafeArea.height
-                    );
-                }
-                else
+        internal static Rect[] SimulatorCutoutsRelative
+        {
+            get
+            {
+                var orientation = GetGameViewOrientation();
+                var device = SimulationDatabase.db.ContainsKey(selectedDevice) ? selectedDevice : default;
+                var cutouts = orientation == ScreenOrientation.Landscape ? SimulationDatabase.db[device].landscapeCutouts : SimulationDatabase.db[device].portraitCutouts;
+                if (cutouts is null) return new Rect[0];
+                var screenSize = SimulationDatabase.db[device].screenSize;
+                if (orientation == ScreenOrientation.Landscape)
                 {
-                    return relativeSafeArea;
+                    var swap = screenSize.x;
+                    screenSize.x = screenSize.y;
+                    screenSize.y = swap;
                 }
+
+                System.Collections.Generic.List<Rect> rects = new System.Collections.Generic.List<Rect>();
+                foreach (var cutout in cutouts) rects.Add(GetRelative(cutout, screenSize));
+                return rects.ToArray();
+            }
+        }
+
+        static Rect GetRelative(Rect original, Vector2 screenSize)
+        {
+            var relativeCutout = new Rect(original.xMin / screenSize.x, original.yMin / screenSize.y, original.width / screenSize.x, original.height / screenSize.y);
+            if (flipOrientation)
+            {
+                return new Rect(
+                    1 - (relativeCutout.width + relativeCutout.xMin),
+                    1 - (relativeCutout.height + relativeCutout.yMin),
+                    relativeCutout.width,
+                    relativeCutout.height
+                );
             }
+            else return relativeCutout;
         }
 
         internal static ScreenOrientation GetGameViewOrientation()
@@ -57,13 +80,13 @@ internal static Vector2 GetMainGameViewSize()
             return (Vector2)argsForOut[0];
         }
 
-        internal static bool enableSimulation 
+        internal static bool enableSimulation
         {
             get { return EditorPrefs.GetBool(enableSimulationKey); }
             set { EditorPrefs.SetBool(enableSimulationKey, value); }
         }
 
-        internal static bool flipOrientation 
+        internal static bool flipOrientation
         {
             get { return EditorPrefs.GetBool(flipOrientationKey); }
             set { EditorPrefs.SetBool(flipOrientationKey, value); }
diff --git a/Editor/SafeAreaPaddingDrawer.cs b/Editor/SafeAreaPaddingDrawer.cs
@@ -75,5 +75,5 @@ public override void OnInspectorGUI()
         }
     }
 
-    
+
 }
diff --git a/Editor/SafeAreaPaddingSidesDrawer.cs b/Editor/SafeAreaPaddingSidesDrawer.cs
@@ -9,5 +9,5 @@ public class SafeAreaPaddingModeDrawer : EnumButtonsDrawer { }
 
     [CustomPropertyDrawer(typeof(SafeAreaPaddingOrientationType))]
     public class SafeAreaPaddingOrientationTypeDrawer : EnumButtonsDrawer { }
-    
+
 }
diff --git a/README.md b/README.md
@@ -111,7 +111,7 @@ Please see the Issue section.
 - iPhone X
 - iPad Pro
 
-(Contributed by @06Games)
+(Contributed by [06Games](https://github.com/06Games))
 
 - Huawei Mate 20 Pro 
 - OnePlus 6T
@@ -128,4 +128,4 @@ My own other (paid) assets... haha. Asides from code contribution, you could als
 
 The game at the top is [Duel Otters/ตัวนากท้าดวล/かわうそバトル](http://exceed7.com/duel-otters).
 
-One another is an in-development game [Mel Cadence/メルカデンツ](http://exceed7.com/mel-cadence).
+One another is an in-development game [Mel Cadence/メルカデンツ](http://exceed7.com/mel-cadence).
diff --git a/Runtime/INotchSimulatorTarget.cs b/Runtime/INotchSimulatorTarget.cs
@@ -4,6 +4,6 @@ namespace E7.NotchSolution
 {
     public interface INotchSimulatorTarget
     {
-        void SimulatorUpdate(Rect simulatedSafeArea);
+        void SimulatorUpdate(Rect simulatedSafeArea, Rect[] simulatedCutouts);
     }
 }
diff --git a/Runtime/NotchSolutionUtility.cs b/Runtime/NotchSolutionUtility.cs
diff --git a/Runtime/SafeAreaPadding/SafeAreaPadding.cs b/Runtime/SafeAreaPadding/SafeAreaPadding.cs

Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ public void PlaceItselfAtScreenRect(Rect screenRect, Color color = default)`
`24`	`24`	`RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRect, screenRect.position, Camera.main, out Vector2 localPoint);`
`25`	`25`	`RectTransformUtility.ScreenPointToLocalPointInRectangle(parentRect, screenRect.size, Camera.main, out Vector2 localSize);`
`26`	`26`
`27`		`- localSize = localSize + (parentRect.sizeDelta /2);`
	`27`	`+ localSize = localSize + (parentRect.sizeDelta / 2);`
`28`	`28`
`29`	`29`	`debugText.text = $"{screenRect}";`
`30`		`-`
	`30`	`+`
`31`	`31`	`rectTransform.localPosition = localPoint;`
`32`	`32`	`rectTransform.sizeDelta = localSize;`
`33`		`-`
	`33`	`+`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,5 +18,5 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
`21`		`-`
	`21`	`+`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`using System;`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Linq;`
`6`		`-using System.Reflection;`
`7`	`6`	`using UnityEditor;`
`8`	`7`	`using UnityEditor.Experimental.SceneManagement;`
`9`	`8`	`using UnityEditor.SceneManagement;`
`@@ -16,13 +15,29 @@ namespace E7.NotchSolution`
`16`	`15`	`public class NotchSimulator : EditorWindow`
`17`	`16`	`{`
`18`	`17`	`internal static NotchSimulator win;`
	`18`	`+ Vector2 gameviewResolution;`
`19`	`19`
`20`	`20`	`[MenuItem("Window/General/Notch Simulator")]`
`21`	`21`	`public static void ShowWindow()`
`22`	`22`	`{`
`23`	`23`	`win = (NotchSimulator)EditorWindow.GetWindow(typeof(NotchSimulator));`
`24`	`24`	`win.titleContent = new GUIContent("Notch Simulator");`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+ [ExecuteInEditMode] private void OnEnable() { EditorApplication.update += RespawnMockup; }`
	`28`	`+ [ExecuteInEditMode] private void OnDisable() { EditorApplication.update -= RespawnMockup; }`
	`29`	`+ void RespawnMockup()`
	`30`	`+ {`
	`31`	`+ //When the game view is changed, the mockup sometimes disappears or isn't scaled correctly`
	`32`	`+ if (gameviewResolution != Handles.GetMainGameViewSize())`
	`33`	`+ {`
	`34`	`+ DestroyHiddenCanvas(); //So we delete the old canvas`
	`35`	`+ UpdateAllMockups(); //And we respawn it`
	`36`	`+ UpdateSimulatorTargets();`
	`37`	`+ gameviewResolution = Handles.GetMainGameViewSize(); //Update the saved game view`
	`38`	`+ }`
	`39`	`+ }`
	`40`	`+`
`26`	`41`	`/// <summary>`
`27`	`42`	`/// It is currently active only when Notch Simulator tab is present.`
`28`	`43`	`/// </summary>`
`@@ -88,14 +103,16 @@ void OnGUI()`
`88`	`103`	`internal static void UpdateSimulatorTargets()`
`89`	`104`	`{`
`90`	`105`	`var simulatedRect = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.SimulatorSafeAreaRelative : new Rect(0, 0, 1, 1);`
	`106`	`+ var simulatedCutouts = NotchSimulatorUtility.enableSimulation ? NotchSimulatorUtility.SimulatorCutoutsRelative : new Rect[0];`
`91`	`107`
`92`	`108`	`//This value could be used by the component statically.`
`93`	`109`	`NotchSolutionUtility.SimulateSafeAreaRelative = simulatedRect;`
	`110`	`+ NotchSolutionUtility.SimulateCutoutsRelative = simulatedCutouts;`
`94`	`111`
`95`	`112`	`var normalSceneSimTargets = GameObject.FindObjectsOfType<UIBehaviour>().OfType<INotchSimulatorTarget>();`
`96`	`113`	`foreach (var nst in normalSceneSimTargets)`
`97`	`114`	`{`
`98`		`- nst.SimulatorUpdate(simulatedRect);`
	`115`	`+ nst.SimulatorUpdate(simulatedRect, simulatedCutouts);`
`99`	`116`	`}`
`100`	`117`
`101`	`118`	`//Now find one in the prefab mode scene as well`
`@@ -105,7 +122,7 @@ internal static void UpdateSimulatorTargets()`
`105`	`122`	`var prefabSceneSimTargets = prefabStage.stageHandle.FindComponentsOfType<UIBehaviour>().OfType<INotchSimulatorTarget>();`
`106`	`123`	`foreach (var nst in prefabSceneSimTargets)`
`107`	`124`	`{`
`108`		`- nst.SimulatorUpdate(simulatedRect);`
	`125`	`+ nst.SimulatorUpdate(simulatedRect, simulatedCutouts);`
`109`	`126`	`}`
`110`	`127`	`}`
`111`	`128`	`}`
`@@ -177,7 +194,7 @@ internal static void UpdateAllMockups()`
`177`	`194`
`178`	`195`	`//Make the editing environment contains an another copy of mockup canvas.`
`179`	`196`	`var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();`
`180`		`- if(prefabStage != null)`
	`197`	`+ if (prefabStage != null)`
`181`	`198`	`{`
`182`	`199`	`EnsureCanvasAndEventSetup(prefabStage: prefabStage);`
`183`	`200`	`}`
`@@ -202,11 +219,11 @@ internal static void UpdateAllMockups()`
`202`	`219`	`{`
`203`	`220`	`mockup.Show();`
`204`	`221`	`mockup.SetMockupSprite(`
`205`		`- sprite: mockupSprite,`
`206`		`- orientation: NotchSimulatorUtility.GetGameViewOrientation(),`
`207`		`- simulate: enableSimulation,`
`208`		`- flipped: NotchSimulatorUtility.flipOrientation`
`209`		`- );`
	`222`	`+ sprite: mockupSprite,`
	`223`	`+ orientation: NotchSimulatorUtility.GetGameViewOrientation(),`
	`224`	`+ simulate: enableSimulation,`
	`225`	`+ flipped: NotchSimulatorUtility.flipOrientation`
	`226`	`+ );`
`210`	`227`	`}`
`211`	`228`	`}`
`212`	`229`	`else`
`@@ -245,7 +262,7 @@ private static void EnsureCanvasAndEventSetup(PrefabStage prefabStage = null)`
`245`	`262`	`else`
`246`	`263`	`{`
`247`	`264`	`var prefabGuids = AssetDatabase.FindAssets(mockupCanvasName);`
`248`		`- if(prefabGuids.Length == 0)`
	`265`	`+ if (prefabGuids.Length == 0)`
`249`	`266`	`{`
`250`	`267`	`return;`
`251`	`268`	`}`
`@@ -266,17 +283,9 @@ private static void EnsureCanvasAndEventSetup(PrefabStage prefabStage = null)`
`266`	`283`	`}`
`267`	`284`	`}`
`268`	`285`
`269`		`-`
`270`		`- if (prefabMode)`
`271`		`- {`
`272`		`- canvasObject.PrefabStage = true;`
`273`		`- prefabMockupCanvas = canvasObject;`
`274`		`- }`
`275`		`- else`
`276`		`- {`
`277`		`- canvasObject.PrefabStage = false;`
`278`		`- mockupCanvas = canvasObject;`
`279`		`- }`
	`286`	`+ canvasObject.PrefabStage = prefabMode;`
	`287`	`+ if (prefabMode) prefabMockupCanvas = canvasObject;`
	`288`	`+ else mockupCanvas = canvasObject;`
`280`	`289`
`281`	`290`	`if (eventAdded == false)`
`282`	`291`	`{`
Original file line number	Diff line number	Diff line change
`@@ -75,5 +75,5 @@ public override void OnInspectorGUI()`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`78`		`-`
	`78`	`+`
`79`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ public class SafeAreaPaddingModeDrawer : EnumButtonsDrawer { }`
`9`	`9`
`10`	`10`	`[CustomPropertyDrawer(typeof(SafeAreaPaddingOrientationType))]`
`11`	`11`	`public class SafeAreaPaddingOrientationTypeDrawer : EnumButtonsDrawer { }`
`12`		`-`
	`12`	`+`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace E7.NotchSolution`
`4`	`4`	`{`
`5`	`5`	`public interface INotchSimulatorTarget`
`6`	`6`	`{`
`7`		`- void SimulatorUpdate(Rect simulatedSafeArea);`
	`7`	`+ void SimulatorUpdate(Rect simulatedSafeArea, Rect[] simulatedCutouts);`
`8`	`8`	`}`
`9`	`9`	`}`