diff --git a/res/drawable/ic_apps_filled_24px.xml b/res/drawable/ic_apps_filled_24px.xml
new file mode 100644
index 0000000..af6fcef
--- /dev/null
+++ b/res/drawable/ic_apps_filled_24px.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2024 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="960" android:viewportHeight="960" android:tint="?attr/colorControlNormal">
+    <path android:fillColor="@android:color/white" android:pathData="M240,800Q207,800 183.5,776.5Q160,753 160,720Q160,687 183.5,663.5Q207,640 240,640Q273,640 296.5,663.5Q320,687 320,720Q320,753 296.5,776.5Q273,800 240,800ZM480,800Q447,800 423.5,776.5Q400,753 400,720Q400,687 423.5,663.5Q447,640 480,640Q513,640 536.5,663.5Q560,687 560,720Q560,753 536.5,776.5Q513,800 480,800ZM720,800Q687,800 663.5,776.5Q640,753 640,720Q640,687 663.5,663.5Q687,640 720,640Q753,640 776.5,663.5Q800,687 800,720Q800,753 776.5,776.5Q753,800 720,800ZM240,560Q207,560 183.5,536.5Q160,513 160,480Q160,447 183.5,423.5Q207,400 240,400Q273,400 296.5,423.5Q320,447 320,480Q320,513 296.5,536.5Q273,560 240,560ZM480,560Q447,560 423.5,536.5Q400,513 400,480Q400,447 423.5,423.5Q447,400 480,400Q513,400 536.5,423.5Q560,447 560,480Q560,513 536.5,536.5Q513,560 480,560ZM720,560Q687,560 663.5,536.5Q640,513 640,480Q640,447 663.5,423.5Q687,400 720,400Q753,400 776.5,423.5Q800,447 800,480Q800,513 776.5,536.5Q753,560 720,560ZM240,320Q207,320 183.5,296.5Q160,273 160,240Q160,207 183.5,183.5Q207,160 240,160Q273,160 296.5,183.5Q320,207 320,240Q320,273 296.5,296.5Q273,320 240,320ZM480,320Q447,320 423.5,296.5Q400,273 400,240Q400,207 423.5,183.5Q447,160 480,160Q513,160 536.5,183.5Q560,207 560,240Q560,273 536.5,296.5Q513,320 480,320ZM720,320Q687,320 663.5,296.5Q640,273 640,240Q640,207 663.5,183.5Q687,160 720,160Q753,160 776.5,183.5Q800,207 800,240Q800,273 776.5,296.5Q753,320 720,320Z"/>
+</vector>
\ No newline at end of file
diff --git a/res/drawable/ic_category_filled_24px.xml b/res/drawable/ic_category_filled_24px.xml
new file mode 100644
index 0000000..ae87e03
--- /dev/null
+++ b/res/drawable/ic_category_filled_24px.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2024 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="960" android:viewportHeight="960" android:tint="?attr/colorControlNormal">
+    <path android:fillColor="@android:color/white" android:pathData="M260,440L480,80L700,440L260,440ZM700,880Q625,880 572.5,827.5Q520,775 520,700Q520,625 572.5,572.5Q625,520 700,520Q775,520 827.5,572.5Q880,625 880,700Q880,775 827.5,827.5Q775,880 700,880ZM120,860L120,540L440,540L440,860L120,860Z"/>
+</vector>
\ No newline at end of file
diff --git a/res/layout/customization_option_entry_app_shape_and_grid.xml b/res/layout/customization_option_entry_app_shape_grid.xml
similarity index 90%
rename from res/layout/customization_option_entry_app_shape_and_grid.xml
rename to res/layout/customization_option_entry_app_shape_grid.xml
index ea6da46..8d18e7c 100644
--- a/res/layout/customization_option_entry_app_shape_and_grid.xml
+++ b/res/layout/customization_option_entry_app_shape_grid.xml
@@ -24,20 +24,20 @@
     android:clickable="true">
 
     <TextView
-        android:id="@+id/option_entry_app_grid_title"
+        android:id="@+id/option_entry_app_shape_grid_title"
         style="@style/CustomizationOptionEntryTitleTextStyle"
         android:layout_width="0dp"
         android:layout_height="wrap_content"
-        android:text="@string/grid_title"
+        android:text="@string/shape_and_grid_title"
         android:layout_marginEnd="@dimen/customization_option_entry_text_margin_end"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintEnd_toStartOf="@+id/option_entry_app_grid_icon_container"
-        app:layout_constraintBottom_toTopOf="@+id/option_entry_app_grid_description"
+        app:layout_constraintBottom_toTopOf="@+id/option_entry_app_shape_grid_description"
         app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintVertical_chainStyle="packed" />
 
     <TextView
-        android:id="@+id/option_entry_app_grid_description"
+        android:id="@+id/option_entry_app_shape_grid_description"
         style="@style/CustomizationOptionEntrySubtitleTextStyle"
         android:layout_width="0dp"
         android:layout_height="wrap_content"
@@ -45,7 +45,7 @@
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toStartOf="@+id/option_entry_app_grid_icon_container"
         app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toBottomOf="@+id/option_entry_app_grid_title" />
+        app:layout_constraintTop_toBottomOf="@+id/option_entry_app_shape_grid_title" />
 
     <FrameLayout
         android:id="@+id/option_entry_app_grid_icon_container"
@@ -58,7 +58,7 @@
         app:layout_constraintBottom_toBottomOf="parent">
 
         <ImageView
-            android:id="@+id/option_entry_app_grid_icon"
+            android:id="@+id/option_entry_app_shape_grid_icon"
             android:layout_width="match_parent"
             android:layout_height="match_parent"
             android:contentDescription="@string/grid_preview_card_content_description" />
diff --git a/res/layout/floating_sheet_shape_and_grid.xml b/res/layout/floating_sheet_shape_and_grid.xml
deleted file mode 100644
index 01a7a89..0000000
--- a/res/layout/floating_sheet_shape_and_grid.xml
+++ /dev/null
@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?><!--
-  ~ Copyright (C) 2024 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  -->
-
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:paddingHorizontal="@dimen/floating_sheet_horizontal_padding"
-    android:orientation="vertical">
-
-    <FrameLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:paddingVertical="@dimen/floating_sheet_content_vertical_padding"
-        android:background="@drawable/floating_sheet_content_background"
-        android:clipToPadding="false"
-        android:clipChildren="false">
-
-        <!--
-        This is just an invisible placeholder put in place so that the parent keeps its height
-        stable as the RecyclerView updates from 0 items to N items. Keeping it stable allows the
-        layout logic to keep the size of the preview container stable as well, which bodes well
-        for setting up the SurfaceView for remote rendering without changing its size after the
-        content is loaded into the RecyclerView.
-
-        It's critical for any TextViews inside the included layout to have text.
-        -->
-        <include
-            layout="@layout/grid_option"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:visibility="invisible" />
-
-        <androidx.recyclerview.widget.RecyclerView
-            android:id="@id/options"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center_horizontal"
-            android:clipToPadding="false"
-            android:clipChildren="false" />
-    </FrameLayout>
-</LinearLayout>
\ No newline at end of file
diff --git a/res/layout/floating_sheet_shape_grid.xml b/res/layout/floating_sheet_shape_grid.xml
new file mode 100644
index 0000000..4e2409b
--- /dev/null
+++ b/res/layout/floating_sheet_shape_grid.xml
@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (C) 2024 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:paddingHorizontal="@dimen/floating_sheet_horizontal_padding"
+    android:orientation="vertical">
+
+    <FrameLayout
+        android:id="@+id/shape_grid_floating_sheet_content_container"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="@drawable/floating_sheet_content_background"
+        android:paddingVertical="@dimen/floating_sheet_content_vertical_padding"
+        android:orientation="vertical"
+        android:clipToPadding="false"
+        android:clipChildren="false">
+
+        <FrameLayout
+            android:id="@+id/app_shape_container"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:clipToPadding="false"
+            android:clipChildren="false">
+
+            <!--
+            This is just an invisible placeholder put in place so that the parent keeps its height
+            stable as the RecyclerView updates from 0 items to N items. Keeping it stable allows the
+            layout logic to keep the size of the preview container stable as well, which bodes well
+            for setting up the SurfaceView for remote rendering without changing its size after the
+            content is loaded into the RecyclerView.
+
+            It's critical for any TextViews inside the included layout to have text.
+            -->
+            <include
+                layout="@layout/shape_option"
+                android:layout_width="64dp"
+                android:layout_height="64dp"
+                android:visibility="invisible" />
+
+            <androidx.recyclerview.widget.RecyclerView
+                android:id="@+id/shape_options"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_gravity="center_horizontal"
+                android:clipToPadding="false"
+                android:clipChildren="false" />
+        </FrameLayout>
+
+        <FrameLayout
+            android:id="@+id/app_grid_container"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:clipToPadding="false"
+            android:clipChildren="false">
+
+            <!--
+            This is just an invisible placeholder put in place so that the parent keeps its height
+            stable as the RecyclerView updates from 0 items to N items. Keeping it stable allows the
+            layout logic to keep the size of the preview container stable as well, which bodes well
+            for setting up the SurfaceView for remote rendering without changing its size after the
+            content is loaded into the RecyclerView.
+
+            It's critical for any TextViews inside the included layout to have text.
+            -->
+            <include
+                layout="@layout/grid_option"
+                android:id="@+id/invisible_grid_option"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:visibility="invisible"/>
+
+            <androidx.recyclerview.widget.RecyclerView
+                android:id="@+id/grid_options"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:clipToPadding="false"
+                android:clipChildren="false"
+                android:layout_gravity="center_horizontal" />
+        </FrameLayout>
+    </FrameLayout>
+
+    <com.android.wallpaper.picker.customization.ui.view.FloatingToolbar
+        android:id="@+id/floating_toolbar"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_horizontal"
+        android:layout_marginVertical="@dimen/floating_sheet_tab_toolbar_vertical_margin" />
+</LinearLayout>
\ No newline at end of file
diff --git a/res/layout/shape_option.xml b/res/layout/shape_option.xml
new file mode 100644
index 0000000..d2eb2f2
--- /dev/null
+++ b/res/layout/shape_option.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2024 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="64dp"
+    android:layout_height="64dp"
+    android:clipChildren="false">
+
+    <ImageView
+        android:id="@id/selection_border"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="@drawable/option_item_border"
+        android:alpha="0"
+        android:importantForAccessibility="no" />
+
+    <ImageView
+        android:id="@id/background"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:background="@drawable/option_item_background"
+        android:importantForAccessibility="no" />
+
+    <ImageView
+        android:id="@id/foreground"
+        android:layout_width="40dp"
+        android:layout_height="40dp"
+        android:layout_gravity="center" />
+</FrameLayout>
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 0f14a04..aab0643 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Klein"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"’n Klein horlosie word in die hoek van jou skerm gewys"</string>
     <string name="grid_title" msgid="1688173478777254123">"Approoster"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Pas toe"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tik om te wysig"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Hou huidige muurpapier"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index 2eaab87..dea744f 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ትንሽ"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"በእርስዎ ማያ ገፅ ጥግ ላይ ትንሽ ሰዓት ይታያል"</string>
     <string name="grid_title" msgid="1688173478777254123">"የመተግበሪያ ፍርግርግ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ተግብር"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ለማርትዕ መታ ያድርጉ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"የአሁኑን ልጣፍ ያቆዩት"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 6056def..4efd2af 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"صغير"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"تظهر ساعة صغيرة في زاوية الشاشة"</string>
     <string name="grid_title" msgid="1688173478777254123">"شبكة التطبيقات"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"تطبيق"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"انقُر للتعديل."</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"الاحتفاظ بالخلفية الحالية"</string>
diff --git a/res/values-as/strings.xml b/res/values-as/strings.xml
index e4418d5..b186b31 100644
--- a/res/values-as/strings.xml
+++ b/res/values-as/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"সৰু"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"আপোনাৰ স্ক্ৰীনখনৰ চুকত এটা সৰু ঘড়ীয়ে দেখুৱায়"</string>
     <string name="grid_title" msgid="1688173478777254123">"এপৰ গ্ৰিড"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"প্ৰয়োগ কৰক"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"সম্পাদনা কৰিবলৈ টিপক"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"বৰ্তমানৰ ৱালপেপাৰখন ৰাখক"</string>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index 76c2725..fb811ba 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Kiçik"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ekranın mərkəzində kiçik saat görünür"</string>
     <string name="grid_title" msgid="1688173478777254123">"Tətbiq toru"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tətbiq edin"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Redaktə etmək üçün klikləyin"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Cari divar kağızını saxlayın"</string>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
index 59ef259..cb606e0 100644
--- a/res/values-b+sr+Latn/strings.xml
+++ b/res/values-b+sr+Latn/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mali"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Mali sat se prikazuje u uglu ekrana"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža apl."</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da biste izmenili"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Zadrži aktuelnu pozadinu"</string>
diff --git a/res/values-be/strings.xml b/res/values-be/strings.xml
index 1005abf..37d3d96 100644
--- a/res/values-be/strings.xml
+++ b/res/values-be/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Дробны"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Невялікі гадзіннік у вугле экрана"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сетка праграм"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ужыць"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Дакраніцеся, каб рэдагаваць"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Захаваць бягучыя шпалеры"</string>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index f64a018..ecf1221 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Малък"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"В ъгъла на екрана се показва малък часовник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Решетка с прил."</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Прилагане"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Докоснете, за да редактирате"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Запазване на текущия тапет"</string>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 8ef1f37..53bd416 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ছোট করুন"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"স্ক্রিনের কোনায় একটি ছোট ঘড়ি দেখানো হয়"</string>
     <string name="grid_title" msgid="1688173478777254123">"অ্যাপ গ্রিড"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"প্রয়োগ করুন"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"এডিট করতে ট্যাপ করুন"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"এখন যে ওয়ালপেপার আছে সেটি রাখুন"</string>
diff --git a/res/values-bs/strings.xml b/res/values-bs/strings.xml
index 9bd52e2..4b7bdc4 100644
--- a/res/values-bs/strings.xml
+++ b/res/values-bs/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Malo"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Mali sat se prikazuje u uglu vašeg ekrana"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža aplikacija"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primijeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da uredite"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Zadrži trenutnu pozadinsku sliku"</string>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 94ec758..eade8a0 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Petit"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Es mostra un rellotge petit a l\'extrem de la pantalla"</string>
     <string name="grid_title" msgid="1688173478777254123">"Quadrícula d\'apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplica"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca per editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Mantén el fons de pantalla actual"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index aa17400..579614c 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Malá"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"V rohu obrazovky se zobrazují malé hodiny"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mřížka aplikací"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Použít"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Klepnutím upravte"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Zachovat stávající tapetu"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 42a8760..8d9c27f 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Lille"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Et lille ur vises i hjørnet af skærmen"</string>
     <string name="grid_title" msgid="1688173478777254123">"Appgitter"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Anvend"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tryk for at redigere"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Behold den aktuelle baggrund"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 07f05dc..48058ac 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Klein"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Eine kleine Uhr wird in der Ecke des Displays angezeigt"</string>
     <string name="grid_title" msgid="1688173478777254123">"App-Raster"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Anwenden"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Zum Bearbeiten tippen"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Aktuellen Hintergrund behalten"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index a4eb1b9..4b00f25 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Μικρό"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ένα μικρό ρολόι εμφανίζεται στη γωνία της οθόνης"</string>
     <string name="grid_title" msgid="1688173478777254123">"Πλέγμα εφαρμ."</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Εφαρμογή"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Πατήστε για επεξεργασία"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Διατήρηση τρέχουσας ταπετσαρίας"</string>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index d280efd..0d07ab8 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Small"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"A small clock shows in the corner of your screen"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Keep current wallpaper"</string>
diff --git a/res/values-en-rCA/strings.xml b/res/values-en-rCA/strings.xml
index dbfbe94..9e9745a 100644
--- a/res/values-en-rCA/strings.xml
+++ b/res/values-en-rCA/strings.xml
@@ -44,6 +44,8 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Small"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"A small clock shows in the corner of your screen"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
+    <string name="shape_and_grid_title" msgid="9092477491363761054">"App shape &amp; layout"</string>
+    <string name="grid_layout" msgid="370175667652663686">"Layout"</string>
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Keep current wallpaper"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index d280efd..0d07ab8 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Small"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"A small clock shows in the corner of your screen"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Keep current wallpaper"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index d280efd..0d07ab8 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Small"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"A small clock shows in the corner of your screen"</string>
     <string name="grid_title" msgid="1688173478777254123">"App grid"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Apply"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tap to edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Keep current wallpaper"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index 2554601..fd54ee1 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pequeño"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Aparece un reloj pequeño en la esquina de tu pantalla"</string>
     <string name="grid_title" msgid="1688173478777254123">"Cuadrícula de apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Presiona para editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Conservar fondo de pantalla actual"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 753d3a7..d57d4db 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pequeño"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Se muestra un pequeño reloj en la esquina de la pantalla"</string>
     <string name="grid_title" msgid="1688173478777254123">"Cuadrícula de apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca para editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Mantener fondo de pantalla actual"</string>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index 3275eed..d654e17 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Väike"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ekraaninurgas kuvatakse väike kell"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rak. ruudustik"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Rakenda"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Puudutage muutmiseks"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Säilita praegune taustapilt"</string>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index 1599ae1..4277260 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Txikia"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Erloju txiki bat agertzen da pantailaren izkinan"</string>
     <string name="grid_title" msgid="1688173478777254123">"Aplikazioen sareta"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplikatu"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Sakatu editatzeko"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Utzi bere horretan horma-papera"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index de42d86..3eab0f3 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"کوچک"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ساعت کوچکی در گوشه صفحه‌نمایش شما نشان داده می‌شود"</string>
     <string name="grid_title" msgid="1688173478777254123">"شبکه برنامه‌ها"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"اعمال"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"برای ویرایش تک‌ضرب بزنید"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"حفظ کاغذدیواری فعلی"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index fb50649..2812761 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pieni"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Näytön reunassa näkyy pieni kello"</string>
     <string name="grid_title" msgid="1688173478777254123">"Ruudukko"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Käytä"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Muokkaa napauttamalla"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Säilytä nykyinen taustakuva"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 250eba4..b89f2a1 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Petite"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Une petite horloge s\'affiche dans le coin de votre écran"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grille d\'applis"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Appliquer"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toucher pour modifier"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Garder le fond d\'écran actuel"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index b191e3b..cfd8428 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Petite"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Une petite horloge s\'affiche dans le coin de votre écran"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grille d\'applis"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Appliquer"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Appuyer pour modifier"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Conserver le fond d\'écran actuel"</string>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index f35bc56..b3f90c0 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pequeno"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Un pequeno reloxo móstrase na esquina da pantalla"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grade de apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toca para editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Conservar fondo de pantalla actual"</string>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index 2102a73..1b03731 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"નાનું"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"તમારી સ્ક્રીનના ખૂણામાં એક નાની ઘડિયાળ દેખાય છે"</string>
     <string name="grid_title" msgid="1688173478777254123">"ઍપ ગ્રિડ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"લાગુ કરો"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ફેરફાર કરવા માટે ટૅપ કરો"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"હાલનું વૉલપેપર રાખો"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 1457fc5..9da2dfc 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"छोटा"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"आपके डिवाइस की स्क्रीन के कोने में एक छोटी घड़ी दिखती है"</string>
     <string name="grid_title" msgid="1688173478777254123">"ऐप्लिकेशन ग्रिड"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू करें"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"बदलाव करने के लिए टैप करें"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"मौजूदा वॉलपेपर बनाए रखें"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 4a7b0bd..844eb34 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mali sat"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"U kutu zaslona prikazuje se mali sat"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rešetka aplikacija"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Primijeni"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dodirnite da biste uredili"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Zadrži trenutačnu pozadinu"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 84e2d80..cb0c9ae 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Kicsi"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Megjelenik egy kis óra a képernyő sarkában."</string>
     <string name="grid_title" msgid="1688173478777254123">"Alkalmazásrács"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Alkalmaz"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Koppintson a szerkesztéshez"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Jelenlegi háttérkép megtartása"</string>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index 86cbf9d..1adac46 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Փոքր"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Էկրանի անկյունում ցուցադրվում է փոքրիկ ժամացույց"</string>
     <string name="grid_title" msgid="1688173478777254123">"Հավելվածների ցանց"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Կիրառել"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Հպեք՝ փոփոխելու համար"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Պահպանել ընթացիկ պաստառը"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 60672e5..ef60388 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Kecil"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Jam kecil ditampilkan di sudut layar"</string>
     <string name="grid_title" msgid="1688173478777254123">"Petak aplikasi"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Terapkan"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ketuk untuk mengedit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Pertahankan wallpaper saat ini"</string>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index b4fc13e..8a3fc1b 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Lítil"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Lítil klukka birtist í horni skjásins"</string>
     <string name="grid_title" msgid="1688173478777254123">"Forritatafla"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Nota"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ýttu til að breyta"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Halda núverandi veggfóðri"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 37e8b75..8f75181 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Piccole"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Un piccolo orologio visualizzato nell\'angolo dello schermo"</string>
     <string name="grid_title" msgid="1688173478777254123">"Griglia di app"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Applica"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tocca per modificare"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Mantieni lo sfondo corrente"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index b8e1c5f..93548f1 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"קטן"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"שעון קטן מופיע בפינת המסך"</string>
     <string name="grid_title" msgid="1688173478777254123">"תצוגת האפליקציות"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"אישור"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"יש להקיש כדי לערוך"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"שמירת הטפט הנוכחי"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 6f6e045..e587425 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"小"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"画面の隅に小さい時計を表示します"</string>
     <string name="grid_title" msgid="1688173478777254123">"アプリグリッド"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"適用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"タップして編集"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"現在の壁紙を保持"</string>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index 4a82186..761e5c0 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"პატარა"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"პატარა საათი მოთავსებულია თქვენი ეკრანის კუთხეში"</string>
     <string name="grid_title" msgid="1688173478777254123">"აპების ბადე"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"მისადაგება"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"შეეხეთ რედაქტირებისთვის"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ამჟამინდელი ფონის შენარჩუნება"</string>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index b57b8da..46b62c6 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Кішi"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Экранның бұрышында шағын сағат көрсетіледі."</string>
     <string name="grid_title" msgid="1688173478777254123">"Қолданбалар торы"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Қолдану"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Өзгерту үшін түртіңіз"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Қазіргі тұсқағазды қалдыру"</string>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index fbd03b9..47465ef 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"តូច"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"នាឡិកា​តូចមួយ​បង្ហាញ​នៅជ្រុងនៃ​អេក្រង់​របស់អ្នក"</string>
     <string name="grid_title" msgid="1688173478777254123">"ក្រឡា​កម្មវិធី"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ប្រើ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ចុច ដើម្បី​កែ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"រក្សាទុក​ផ្ទាំងរូបភាព​បច្ចុប្បន្ន"</string>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index 32d0e48..ec8ff98 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ಚಿಕ್ಕದು"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ನಿಮ್ಮ ಸ್ಕ್ರೀನ್‌ನ ಮೂಲೆಯಲ್ಲಿ ಸಣ್ಣ ಗಡಿಯಾರವೊಂದು ಕಾಣಿಸುತ್ತದೆ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ಆ್ಯಪ್ ಗ್ರಿಡ್"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ಅನ್ವಯಿಸಿ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ಎಡಿಟ್ ಮಾಡಲು ಟ್ಯಾಪ್ ಮಾಡಿ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ಪ್ರಸ್ತುತ ವಾಲ್‌ಪೇಪರ್ ಅನ್ನು ಉಳಿಸಿ"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 8e869d0..d3502db 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"작게"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"작은 시계가 화면 모서리에 표시됩니다."</string>
     <string name="grid_title" msgid="1688173478777254123">"앱 그리드"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"적용"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"탭하여 수정"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"현재 배경화면 유지"</string>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index fd070ff..c7863bd 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Кичине"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Кичинекей саат экрандын бурчунда көрүнүп турат"</string>
     <string name="grid_title" msgid="1688173478777254123">"Колдонмолор торчосу"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Колдонуу"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Өзгөртүү үчүн таптап коюңуз"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Учурдагы тушкагаз калсын"</string>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index 8e44623..c7ce2ee 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ນ້ອຍ"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ໂມງນ້ອຍທີ່ສະແດງຢູ່ໃນມຸມຂອງໜ້າຈໍທ່ານ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ຕາຕະລາງແອັບ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ນຳໃຊ້"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ແຕະເພື່ອແກ້ໄຂ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ໃຊ້ຮູບພື້ນຫຼັງປັດຈຸບັນ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index e0c8ffd..169acb5 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mažas"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ekrano kampe rodomas nedidelis laikrodis"</string>
     <string name="grid_title" msgid="1688173478777254123">"Pr. tinklelis"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Taikyti"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Palieskite ir redaguokite"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Palikti dabartinį ekrano foną"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 68a6d4b..35d9bef 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mazs"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Jūsu ekrāna stūrī tiek rādīts neliels pulkstenis."</string>
     <string name="grid_title" msgid="1688173478777254123">"Lietotņu režģis"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Lietot"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Pieskarieties, lai rediģētu"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Paturēt pašreizējo fona tapeti"</string>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index cd9690b..01e6215 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Мала"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Во аголот на екранот се прикажува мал часовник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Мрежа"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Примени"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Допрете за да измените"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Задржи тековен тапет"</string>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index 191c066..3fbd693 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ചെറുത്"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"സ്ക്രീനിന്റെ മൂലയിൽ ഒരു ചെറിയ ക്ലോക്ക് കാണിക്കുന്നു"</string>
     <string name="grid_title" msgid="1688173478777254123">"ആപ്പ് ഗ്രിഡ്"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"പ്രയോഗിക്കുക"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"എഡിറ്റ് ചെയ്യാൻ ടാപ്പ് ചെയ്യുക"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"നിലവിലെ വാൾപേപ്പർ നിലനിർത്തുക"</string>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index 2353a9d..dc71165 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Жижиг"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Таны дэлгэцийн буланд жижиг цаг харуулдаг"</string>
     <string name="grid_title" msgid="1688173478777254123">"Аппын хүснэгт"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ашиглах"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Засахын тулд товшино уу"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Одоогийн дэлгэцийн зургийг хадгалах"</string>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index c531514..da52ce2 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"छोटे"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"तुमच्या स्क्रीनच्या कोपऱ्यामध्ये एक लहान घड्याळ दिसते"</string>
     <string name="grid_title" msgid="1688173478777254123">"ॲप ग्रिड"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू करा"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"संपादित करण्‍यासाठी टॅप करा"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"सध्याचा वॉलपेपर ठेवा"</string>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index fb6a237..743e967 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Kecil"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Jam kecil dipaparkan di penjuru skrin"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grid apl"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Gunakan"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Ketik untuk edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Kekalkan kertas dinding semasa"</string>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index 3be7e0b..301b765 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"သေး"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"သင့်ဖန်သားပြင်ထောင့်တွင် ပြသထားသော နာရီအသေးတစ်ခု"</string>
     <string name="grid_title" msgid="1688173478777254123">"အက်ပ်ဇယား"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"အသုံးပြုရန်"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"တည်းဖြတ်ရန် တို့ပါ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"လက်ရှိနောက်ခံပုံ ဆက်ထားရန်"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index f4cd48d..2550b06 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Liten"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"En liten klokke vises i hjørnet av skjermen"</string>
     <string name="grid_title" msgid="1688173478777254123">"Apprutenett"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Bruk"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Trykk for å endre"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Behold den nåværende bakgrunnen"</string>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index 9669e01..0092176 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"सानो"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"तपाईंको स्क्रिनको कुनामा सानो घडी देखा पर्छ"</string>
     <string name="grid_title" msgid="1688173478777254123">"एप ग्रिड"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"लागू गर्नुहोस्"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"सम्पादन गर्न ट्याप गर्नुहोस्"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"अहिले कै वालपेपर राख्नुहोस्"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index f8962ba..b98d289 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Klein"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Er wordt een kleine klok weergegeven in de hoek van het scherm"</string>
     <string name="grid_title" msgid="1688173478777254123">"App-raster"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Toepassen"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tik om te bewerken"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Huidige achtergrond behouden"</string>
diff --git a/res/values-or/strings.xml b/res/values-or/strings.xml
index d66efee..b2c94e7 100644
--- a/res/values-or/strings.xml
+++ b/res/values-or/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ଛୋଟ"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ଆପଣଙ୍କ ସ୍କ୍ରିନର କୋଣରେ ଏକ ଛୋଟ ଘଣ୍ଟା ଦେଖାଯାଏ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ଆପ ଗ୍ରିଡ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ପ୍ରୟୋଗ କରନ୍ତୁ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ଏଡିଟ କରିବା ପାଇଁ ଟାପ କରନ୍ତୁ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ବର୍ତ୍ତମାନର ୱାଲ୍‌ପେପର୍‌କୁ ରଖନ୍ତୁ"</string>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index 66d127b..8c73b77 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"ਛੋਟਾ"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ਤੁਹਾਡੀ ਸਕ੍ਰੀਨ ਦੇ ਕੋਨੇ \'ਤੇ ਇੱਕ ਛੋਟੀ ਘੜੀ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ਐਪ ਗ੍ਰਿਡ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ਲਾਗੂ ਕਰੋ"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ਸੰਪਾਦਨ ਕਰਨ ਲਈ ਟੈਪ ਕਰੋ"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ਮੌਜੂਦਾ ਵਾਲਪੇਪਰ ਬਰਕਰਾਰ ਰੱਖੋ"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index ea5e489..4470118 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mały"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Mały zegar wyświetlany w rogu ekranu"</string>
     <string name="grid_title" msgid="1688173478777254123">"Siatka aplikacji"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Zastosuj"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Kliknij, by edytować"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Pozostaw bieżącą tapetę"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 57c397c..3086f4e 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pequeno"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Um pequeno relógio é apresentado no canto do ecrã"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grelha de apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toque para editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Manter a imagem de fundo atual"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 4f4dc1e..837480f 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Pequeno"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Um relógio pequeno aparece no canto da tela"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grade de apps"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplicar"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Toque para editar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Manter o plano de fundo atual"</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 9e87322..cfea089 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Mică"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Un ceas mic apare în colțul ecranului"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grilă aplicații"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Aplică"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Atinge pentru a modifica"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Păstrează imaginea de fundal actuală"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 61ac300..b1794d1 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Маленький"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Небольшие часы в углу экрана"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сетка приложений"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Применить"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Нажмите, чтобы изменить"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Использовать текущие обои"</string>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index 84ad1f8..d07d043 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"කුඩා"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"ඔබේ තිරයේ කෙළවරේ කුඩා ඔරලෝසුවක් පෙන්වයි"</string>
     <string name="grid_title" msgid="1688173478777254123">"යෙදුම් ජාලකය"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"යොදන්න"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"සංස්කරණයට තට්ටු කරන්න"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"වත්මන් බිතුපත තබා ගන්න"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index adc0323..4b3e677 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Malé"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"V rohu obrazovky sa zobrazujú malé hodiny"</string>
     <string name="grid_title" msgid="1688173478777254123">"Mriežka aplikácií"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Použiť"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Klepnutím upravte"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Ponechať aktuálnu tapetu"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index b53b742..38cbfb2 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Majhna"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"V kotu zaslona je prikazana majhna ura."</string>
     <string name="grid_title" msgid="1688173478777254123">"Mreža aplikacij"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Uporabi"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Dotaknite se za urejanje"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Obdrži trenutno ozadje"</string>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index b7f2111..ac562fc 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"E vogël"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Në këndin e ekranit shfaqet një orë e vogël"</string>
     <string name="grid_title" msgid="1688173478777254123">"Rrjeta e aplikacioneve"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Zbato"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Trokit për të modifikuar"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Mbaj imazhin aktual të sfondit"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 6824fd9..3f6a6c8 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Мали"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Мали сат се приказује у углу екрана"</string>
     <string name="grid_title" msgid="1688173478777254123">"Мрежа апл."</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Примени"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Додирните да бисте изменили"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Задржи актуелну позадину"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 4326de9..69f9d27 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Liten"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"En liten klockas visas i skärmens hörn"</string>
     <string name="grid_title" msgid="1688173478777254123">"Apprutnät"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Använd"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tryck för att redigera"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Behåll befintlig bakgrund"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 40a426b..3f69df3 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Ndogo"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Saa ndogo inaonekana kwenye kona ya skrini yako"</string>
     <string name="grid_title" msgid="1688173478777254123">"Gridi ya programu"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tumia"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Gusa ili ubadilishe"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Tumia mandhari ya sasa"</string>
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index a342784..5e5a226 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"சிறியது"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"உங்கள் திரையின் மூலையில் ஒரு சிறிய கடிகாரம் காட்டப்படும்"</string>
     <string name="grid_title" msgid="1688173478777254123">"ஆப்ஸ் கட்டம்"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"பயன்படுத்து"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"\'தீமைத்\' திருத்த தட்டவும்"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"தற்போதைய வால்பேப்பரே இருக்கட்டும்"</string>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index d292914..ae251dc 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"చిన్నది"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"మీ స్క్రీన్ మూలన ఒక చిన్న గడియారం కనిపిస్తుంది"</string>
     <string name="grid_title" msgid="1688173478777254123">"యాప్ గ్రిడ్"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"వర్తింపజేయి"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ఎడిట్ చేయడానికి నొక్కండి"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ప్రస్తుత వాల్‌పేపర్‌ను అలాగే ఉంచండి"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index b0e7046..35dcf7f 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"เล็ก"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"นาฬิกาขนาดเล็กจะแสดงที่มุมของหน้าจอ"</string>
     <string name="grid_title" msgid="1688173478777254123">"ตารางกริดแอป"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"ใช้"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"แตะเพื่อแก้ไข"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"ใช้วอลเปเปอร์ปัจจุบัน"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 00778e5..af22a07 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Maliit"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"May makikitang maliit na orasan sa sulok ng iyong screen"</string>
     <string name="grid_title" msgid="1688173478777254123">"Grid ng app"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Ilapat"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"I-tap para ma-edit"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Gamitin ang kasalukuyang wallpaper"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 7852cdd..12a4169 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Küçük"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ekranınızın köşesinde küçük bir saat görünür"</string>
     <string name="grid_title" msgid="1688173478777254123">"Uygulama tablosu"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Uygula"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Düzenlemek için dokunun"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Geçerli duvar kağıdını sakla"</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 486a51d..7c3cf10 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Малий"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"У куті екрана відображається маленький годинник"</string>
     <string name="grid_title" msgid="1688173478777254123">"Сітка додатків"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Застосувати"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Торкніться, щоб змінити"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Зберегти поточний фоновий малюнок"</string>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index 019de1f..a39d8d8 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"چھوٹا"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"آپ کی اسکرین کے کونے میں ایک چھوٹی گھڑی دکھائی دیتی ہے"</string>
     <string name="grid_title" msgid="1688173478777254123">"ایپ گرڈ"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"لاگو کریں"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"ترمیم کرنے کے لیے تھپتھپائيں"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"حالیہ وال پیپر رکھیں"</string>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index 4f3cb77..3b2fae8 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Kichik"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Ekran chekkasida kichik soat chiqishi"</string>
     <string name="grid_title" msgid="1688173478777254123">"Ilovalar jadvali"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Tatbiq etish"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Tahrirlash uchun tegining"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Joriy fon rasmini saqlab qolish"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index f775f3d..58e4ec3 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Nhỏ"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Một chiếc đồng hồ nhỏ hiển thị ở góc màn hình"</string>
     <string name="grid_title" msgid="1688173478777254123">"Lưới ứng dụng"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Áp dụng"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Nhấn để chỉnh sửa"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Giữ hình nền hiện tại"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 9502cef..1192a21 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"小"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"一个小型时钟显示在界面一角"</string>
     <string name="grid_title" msgid="1688173478777254123">"应用网格"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"应用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"点按即可修改"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"保留当前壁纸"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index 6ebc6da..b5fd864 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"小"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"在螢幕角落顯示小時鐘"</string>
     <string name="grid_title" msgid="1688173478777254123">"應用程式網格"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"套用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"輕按即可編輯"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"保留目前桌布"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index cf0a4ed..26c9986 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"小"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"在畫面角落顯示小型時鐘"</string>
     <string name="grid_title" msgid="1688173478777254123">"應用程式排列顯示"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"套用"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"輕觸這裡即可編輯"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"繼續使用目前的桌布"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 4056a71..9a4d936 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -44,6 +44,10 @@
     <string name="clock_size_small" msgid="2280449912094164133">"Esincane"</string>
     <string name="clock_size_small_description" msgid="4089511196955732480">"Iwashi elincane livela ekhoneni lesikrini sakho"</string>
     <string name="grid_title" msgid="1688173478777254123">"Igridi ye-app"</string>
+    <!-- no translation found for shape_and_grid_title (9092477491363761054) -->
+    <skip />
+    <!-- no translation found for grid_layout (370175667652663686) -->
+    <skip />
     <string name="apply_theme_btn" msgid="6293081192321303991">"Faka"</string>
     <string name="edit_custom_theme_lbl" msgid="5211377705710775224">"Thepha ukuze uhlele"</string>
     <string name="keep_my_wallpaper" msgid="8012385376769568517">"Gcina isithombe sangemuva samanje"</string>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index aee2393..07b2800 100755
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -100,6 +100,14 @@
         the home screen. [CHAR LIMIT=15] -->
     <string name="grid_title">App grid</string>
 
+    <!-- Title of a section of the customization picker where the user can select app shapes and
+        grid layouts for the home screen. [CHAR LIMIT=15] -->
+    <string name="shape_and_grid_title">App shape &amp; layout</string>
+
+    <!-- Tab title that switch to app grid customization section, where people can customization
+        the grid layout of the apps -->
+    <string name="grid_layout">Layout</string>
+
     <!-- Label for a button that allows the user to apply the currently selected Theme.
         [CHAR LIMIT=20] -->
     <string name="apply_theme_btn">Apply</string>
diff --git a/src/com/android/customization/model/grid/DefaultGridOptionsManager.kt b/src/com/android/customization/model/grid/DefaultShapeGridManager.kt
similarity index 96%
rename from src/com/android/customization/model/grid/DefaultGridOptionsManager.kt
rename to src/com/android/customization/model/grid/DefaultShapeGridManager.kt
index bc862fd..8de5ff2 100644
--- a/src/com/android/customization/model/grid/DefaultGridOptionsManager.kt
+++ b/src/com/android/customization/model/grid/DefaultShapeGridManager.kt
@@ -28,12 +28,12 @@
 import kotlinx.coroutines.withContext
 
 @Singleton
-class DefaultGridOptionsManager
+class DefaultShapeGridManager
 @Inject
 constructor(
     @ApplicationContext private val context: Context,
     @BackgroundDispatcher private val bgDispatcher: CoroutineDispatcher,
-) : GridOptionsManager2 {
+) : ShapeGridManager {
 
     private val authorityMetadataKey: String =
         context.getString(R.string.grid_control_metadata_name)
@@ -59,7 +59,7 @@
                                         context.getString(
                                             com.android.themepicker.R.string.grid_title_pattern,
                                             cols,
-                                            rows
+                                            rows,
                                         ),
                                     isCurrent =
                                         cursor
diff --git a/src/com/android/customization/model/grid/GridOptionsManager2.kt b/src/com/android/customization/model/grid/ShapeGridManager.kt
similarity index 95%
rename from src/com/android/customization/model/grid/GridOptionsManager2.kt
rename to src/com/android/customization/model/grid/ShapeGridManager.kt
index ce8500a..1603ed9 100644
--- a/src/com/android/customization/model/grid/GridOptionsManager2.kt
+++ b/src/com/android/customization/model/grid/ShapeGridManager.kt
@@ -16,7 +16,7 @@
 
 package com.android.customization.model.grid
 
-interface GridOptionsManager2 {
+interface ShapeGridManager {
 
     suspend fun isGridOptionAvailable(): Boolean
 
diff --git a/src/com/android/customization/picker/grid/data/repository/GridRepository2.kt b/src/com/android/customization/picker/grid/data/repository/ShapeGridRepository.kt
similarity index 94%
rename from src/com/android/customization/picker/grid/data/repository/GridRepository2.kt
rename to src/com/android/customization/picker/grid/data/repository/ShapeGridRepository.kt
index 8ce4374..9ae4d18 100644
--- a/src/com/android/customization/picker/grid/data/repository/GridRepository2.kt
+++ b/src/com/android/customization/picker/grid/data/repository/ShapeGridRepository.kt
@@ -18,7 +18,7 @@
 package com.android.customization.picker.grid.data.repository
 
 import com.android.customization.model.grid.GridOptionModel
-import com.android.customization.model.grid.GridOptionsManager2
+import com.android.customization.model.grid.ShapeGridManager
 import com.android.wallpaper.picker.di.modules.BackgroundDispatcher
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -33,10 +33,10 @@
 import kotlinx.coroutines.withContext
 
 @Singleton
-class GridRepository2
+class ShapeGridRepository
 @Inject
 constructor(
-    private val manager: GridOptionsManager2,
+    private val manager: ShapeGridManager,
     @BackgroundDispatcher private val bgScope: CoroutineScope,
     @BackgroundDispatcher private val bgDispatcher: CoroutineDispatcher,
 ) {
diff --git a/src/com/android/customization/picker/grid/domain/interactor/GridInteractor2.kt b/src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractor.kt
similarity index 85%
rename from src/com/android/customization/picker/grid/domain/interactor/GridInteractor2.kt
rename to src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractor.kt
index 30c87d8..c9c2b0c 100644
--- a/src/com/android/customization/picker/grid/domain/interactor/GridInteractor2.kt
+++ b/src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractor.kt
@@ -17,16 +17,12 @@
 
 package com.android.customization.picker.grid.domain.interactor
 
-import com.android.customization.picker.grid.data.repository.GridRepository2
+import com.android.customization.picker.grid.data.repository.ShapeGridRepository
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-class GridInteractor2
-@Inject
-constructor(
-    private val repository: GridRepository2,
-) {
+class ShapeGridInteractor @Inject constructor(private val repository: ShapeGridRepository) {
     suspend fun isGridOptionAvailable(): Boolean = repository.isGridOptionAvailable()
 
     val gridOptions = repository.gridOptions
diff --git a/src/com/android/customization/model/grid/GridOptionsManager2.kt b/src/com/android/customization/picker/grid/ui/viewmodel/ShapeIconViewModel.kt
similarity index 72%
copy from src/com/android/customization/model/grid/GridOptionsManager2.kt
copy to src/com/android/customization/picker/grid/ui/viewmodel/ShapeIconViewModel.kt
index ce8500a..1283603 100644
--- a/src/com/android/customization/model/grid/GridOptionsManager2.kt
+++ b/src/com/android/customization/picker/grid/ui/viewmodel/ShapeIconViewModel.kt
@@ -14,13 +14,6 @@
  * limitations under the License.
  */
 
-package com.android.customization.model.grid
+package com.android.customization.picker.grid.ui.viewmodel
 
-interface GridOptionsManager2 {
-
-    suspend fun isGridOptionAvailable(): Boolean
-
-    suspend fun getGridOptions(): List<GridOptionModel>?
-
-    fun applyGridOption(gridName: String): Int
-}
+data class ShapeIconViewModel(val key: String, val path: String)
diff --git a/src/com/android/customization/picker/mode/data/repository/DarkModeRepository.kt b/src/com/android/customization/picker/mode/data/repository/DarkModeRepository.kt
index 48d5c7f..28f5017 100644
--- a/src/com/android/customization/picker/mode/data/repository/DarkModeRepository.kt
+++ b/src/com/android/customization/picker/mode/data/repository/DarkModeRepository.kt
@@ -16,7 +16,6 @@
 
 package com.android.customization.picker.mode.data.repository
 
-import com.android.app.tracing.coroutines.flow.map
 import com.android.customization.picker.mode.shared.util.DarkModeUtil
 import com.android.wallpaper.system.PowerManagerWrapper
 import com.android.wallpaper.system.UiModeManagerWrapper
@@ -25,6 +24,7 @@
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
 
 @Singleton
 class DarkModeRepository
diff --git a/src/com/android/wallpaper/customization/ui/binder/ShapeAndGridFloatingSheetBinder.kt b/src/com/android/wallpaper/customization/ui/binder/ShapeAndGridFloatingSheetBinder.kt
deleted file mode 100644
index 7217f61..0000000
--- a/src/com/android/wallpaper/customization/ui/binder/ShapeAndGridFloatingSheetBinder.kt
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.wallpaper.customization.ui.binder
-
-import android.content.Context
-import android.view.View
-import android.widget.ImageView
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-import com.android.customization.picker.common.ui.view.SingleRowListItemSpacing
-import com.android.customization.picker.grid.ui.binder.GridIconViewBinder
-import com.android.customization.picker.grid.ui.viewmodel.GridIconViewModel
-import com.android.wallpaper.R
-import com.android.wallpaper.customization.ui.viewmodel.ShapeAndGridPickerViewModel
-import com.android.wallpaper.picker.option.ui.adapter.OptionItemAdapter
-import com.android.wallpaper.picker.option.ui.binder.OptionItemBinder
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.launch
-
-object ShapeAndGridFloatingSheetBinder {
-
-    fun bind(
-        view: View,
-        viewModel: ShapeAndGridPickerViewModel,
-        lifecycleOwner: LifecycleOwner,
-        backgroundDispatcher: CoroutineDispatcher,
-    ) {
-        val adapter = createOptionItemAdapter(view.context, lifecycleOwner, backgroundDispatcher)
-        val gridOptionList =
-            view.requireViewById<RecyclerView>(R.id.options).also {
-                it.initGridOptionList(view.context, adapter)
-            }
-
-        lifecycleOwner.lifecycleScope.launch {
-            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                launch {
-                    viewModel.optionItems.collect { options ->
-                        adapter.setItems(options) {
-                            val indexToFocus =
-                                options.indexOfFirst { it.isSelected.value }.coerceAtLeast(0)
-                            (gridOptionList.layoutManager as LinearLayoutManager).scrollToPosition(
-                                indexToFocus
-                            )
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun createOptionItemAdapter(
-        context: Context,
-        lifecycleOwner: LifecycleOwner,
-        backgroundDispatcher: CoroutineDispatcher,
-    ): OptionItemAdapter<GridIconViewModel> =
-        OptionItemAdapter(
-            layoutResourceId = com.android.themepicker.R.layout.grid_option,
-            lifecycleOwner = lifecycleOwner,
-            backgroundDispatcher = backgroundDispatcher,
-            foregroundTintSpec =
-                OptionItemBinder.TintSpec(
-                    selectedColor = context.getColor(R.color.system_on_surface),
-                    unselectedColor = context.getColor(R.color.system_on_surface),
-                ),
-            bindIcon = { foregroundView: View, gridIcon: GridIconViewModel ->
-                val imageView = foregroundView as? ImageView
-                imageView?.let { GridIconViewBinder.bind(imageView, gridIcon) }
-            }
-        )
-
-    private fun RecyclerView.initGridOptionList(
-        context: Context,
-        adapter: OptionItemAdapter<GridIconViewModel>,
-    ) {
-        apply {
-            this.layoutManager =
-                LinearLayoutManager(
-                    context,
-                    RecyclerView.HORIZONTAL,
-                    false,
-                )
-            addItemDecoration(
-                SingleRowListItemSpacing(
-                    edgeItemSpacePx =
-                        context.resources.getDimensionPixelSize(
-                            com.android.themepicker.R.dimen
-                                .floating_sheet_content_horizontal_padding
-                        ),
-                    itemHorizontalSpacePx =
-                        context.resources.getDimensionPixelSize(
-                            com.android.themepicker.R.dimen
-                                .floating_sheet_list_item_horizontal_space
-                        ),
-                )
-            )
-            this.adapter = adapter
-        }
-    }
-}
diff --git a/src/com/android/wallpaper/customization/ui/binder/ShapeGridFloatingSheetBinder.kt b/src/com/android/wallpaper/customization/ui/binder/ShapeGridFloatingSheetBinder.kt
new file mode 100644
index 0000000..8a59c60
--- /dev/null
+++ b/src/com/android/wallpaper/customization/ui/binder/ShapeGridFloatingSheetBinder.kt
@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.wallpaper.customization.ui.binder
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver.OnGlobalLayoutListener
+import android.widget.ImageView
+import androidx.core.view.isVisible
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.android.customization.picker.common.ui.view.SingleRowListItemSpacing
+import com.android.customization.picker.grid.ui.binder.GridIconViewBinder
+import com.android.customization.picker.grid.ui.viewmodel.GridIconViewModel
+import com.android.customization.picker.grid.ui.viewmodel.ShapeIconViewModel
+import com.android.themepicker.R
+import com.android.wallpaper.customization.ui.util.ThemePickerCustomizationOptionUtil.ThemePickerHomeCustomizationOption.APP_SHAPE_GRID
+import com.android.wallpaper.customization.ui.viewmodel.ShapeGridFloatingSheetHeightsViewModel
+import com.android.wallpaper.customization.ui.viewmodel.ShapeGridPickerViewModel.Tab.GRID
+import com.android.wallpaper.customization.ui.viewmodel.ShapeGridPickerViewModel.Tab.SHAPE
+import com.android.wallpaper.customization.ui.viewmodel.ThemePickerCustomizationOptionsViewModel
+import com.android.wallpaper.picker.customization.ui.view.FloatingToolbar
+import com.android.wallpaper.picker.customization.ui.view.adapter.FloatingToolbarTabAdapter
+import com.android.wallpaper.picker.customization.ui.viewmodel.ColorUpdateViewModel
+import com.android.wallpaper.picker.option.ui.adapter.OptionItemAdapter
+import com.android.wallpaper.picker.option.ui.binder.OptionItemBinder
+import java.lang.ref.WeakReference
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.launch
+
+object ShapeGridFloatingSheetBinder {
+    private const val ANIMATION_DURATION = 200L
+
+    private val _shapeGridFloatingSheetHeights:
+        MutableStateFlow<ShapeGridFloatingSheetHeightsViewModel?> =
+        MutableStateFlow(null)
+    private val shapeGridFloatingSheetHeights: Flow<ShapeGridFloatingSheetHeightsViewModel> =
+        _shapeGridFloatingSheetHeights.asStateFlow().filterNotNull().filter {
+            it.shapeContentHeight != null && it.gridContentHeight != null
+        }
+
+    fun bind(
+        view: View,
+        optionsViewModel: ThemePickerCustomizationOptionsViewModel,
+        colorUpdateViewModel: ColorUpdateViewModel,
+        lifecycleOwner: LifecycleOwner,
+        backgroundDispatcher: CoroutineDispatcher,
+    ) {
+        val floatingSheetContentVerticalPadding =
+            view.resources.getDimensionPixelSize(R.dimen.floating_sheet_content_vertical_padding)
+        val viewModel = optionsViewModel.shapeGridPickerViewModel
+
+        val tabs = view.requireViewById<FloatingToolbar>(R.id.floating_toolbar)
+        val tabAdapter =
+            FloatingToolbarTabAdapter(
+                    colorUpdateViewModel = WeakReference(colorUpdateViewModel),
+                    shouldAnimateColor = { optionsViewModel.selectedOption.value == APP_SHAPE_GRID },
+                )
+                .also { tabs.setAdapter(it) }
+
+        val floatingSheetContainer =
+            view.requireViewById<ViewGroup>(R.id.shape_grid_floating_sheet_content_container)
+
+        val shapeContent = view.requireViewById<View>(R.id.app_shape_container)
+        val shapeOptionListAdapter =
+            createShapeOptionItemAdapter(view.context, lifecycleOwner, backgroundDispatcher)
+        val shapeOptionList =
+            view.requireViewById<RecyclerView>(R.id.shape_options).also {
+                it.initShapeOptionList(view.context, shapeOptionListAdapter)
+            }
+
+        val gridContent = view.requireViewById<View>(R.id.app_grid_container)
+        val gridOptionListAdapter =
+            createGridOptionItemAdapter(view.context, lifecycleOwner, backgroundDispatcher)
+        val gridOptionList =
+            view.requireViewById<RecyclerView>(R.id.grid_options).also {
+                it.initGridOptionList(view.context, gridOptionListAdapter)
+            }
+
+        // Get the shape content height when it is ready
+        shapeContent.viewTreeObserver.addOnGlobalLayoutListener(
+            object : OnGlobalLayoutListener {
+                override fun onGlobalLayout() {
+                    _shapeGridFloatingSheetHeights.value =
+                        _shapeGridFloatingSheetHeights.value?.copy(
+                            shapeContentHeight = shapeContent.height
+                        )
+                            ?: ShapeGridFloatingSheetHeightsViewModel(
+                                shapeContentHeight = shapeContent.height
+                            )
+                    shapeContent.viewTreeObserver.removeOnGlobalLayoutListener(this)
+                }
+            }
+        )
+        // Get the grid content height when it is ready
+        gridContent.viewTreeObserver.addOnGlobalLayoutListener(
+            object : OnGlobalLayoutListener {
+                override fun onGlobalLayout() {
+                    // Make sure the recycler view height is the same as its parent. It's possible
+                    // that the recycler view is shorter than expected.
+                    gridOptionList.layoutParams =
+                        gridOptionList.layoutParams.apply { height = gridContent.height }
+                    _shapeGridFloatingSheetHeights.value =
+                        _shapeGridFloatingSheetHeights.value?.copy(
+                            gridContentHeight = gridContent.height
+                        )
+                            ?: ShapeGridFloatingSheetHeightsViewModel(
+                                gridContentHeight = shapeContent.height
+                            )
+                    shapeContent.viewTreeObserver.removeOnGlobalLayoutListener(this)
+                }
+            }
+        )
+
+        lifecycleOwner.lifecycleScope.launch {
+            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                launch { viewModel.tabs.collect { tabAdapter.submitList(it) } }
+
+                launch {
+                    combine(shapeGridFloatingSheetHeights, viewModel.selectedTab) {
+                            heights,
+                            selectedTab ->
+                            heights to selectedTab
+                        }
+                        .collect { (heights, selectedTab) ->
+                            val (shapeContentHeight, gridContentHeight) = heights
+                            shapeContentHeight ?: return@collect
+                            gridContentHeight ?: return@collect
+                            val targetHeight =
+                                when (selectedTab) {
+                                    SHAPE -> shapeContentHeight
+                                    GRID -> gridContentHeight
+                                } + floatingSheetContentVerticalPadding * 2
+
+                            ValueAnimator.ofInt(floatingSheetContainer.height, targetHeight)
+                                .apply {
+                                    addUpdateListener { valueAnimator ->
+                                        val value = valueAnimator.animatedValue as Int
+                                        floatingSheetContainer.layoutParams =
+                                            floatingSheetContainer.layoutParams.apply {
+                                                height = value
+                                            }
+                                    }
+                                    duration = ANIMATION_DURATION
+                                }
+                                .start()
+
+                            shapeContent.isVisible = selectedTab == SHAPE
+                            gridContent.isVisible = selectedTab == GRID
+                        }
+                }
+
+                launch {
+                    viewModel.gridOptions.collect { options ->
+                        gridOptionListAdapter.setItems(options) {
+                            val indexToFocus =
+                                options.indexOfFirst { it.isSelected.value }.coerceAtLeast(0)
+                            (gridOptionList.layoutManager as LinearLayoutManager).scrollToPosition(
+                                indexToFocus
+                            )
+                        }
+                    }
+                }
+
+                launch {
+                    viewModel.shapeOptions.collect { options ->
+                        shapeOptionListAdapter.setItems(options) {
+                            val indexToFocus =
+                                options.indexOfFirst { it.isSelected.value }.coerceAtLeast(0)
+                            (shapeOptionList.layoutManager as LinearLayoutManager).scrollToPosition(
+                                indexToFocus
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun createShapeOptionItemAdapter(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        backgroundDispatcher: CoroutineDispatcher,
+    ): OptionItemAdapter<ShapeIconViewModel> =
+        OptionItemAdapter(
+            layoutResourceId = R.layout.shape_option,
+            lifecycleOwner = lifecycleOwner,
+            backgroundDispatcher = backgroundDispatcher,
+            foregroundTintSpec =
+                OptionItemBinder.TintSpec(
+                    selectedColor =
+                        context.getColor(com.android.wallpaper.R.color.system_on_surface),
+                    unselectedColor =
+                        context.getColor(com.android.wallpaper.R.color.system_on_surface),
+                ),
+            bindIcon = { foregroundView: View, shapeIcon: ShapeIconViewModel ->
+                val imageView = foregroundView as? ImageView
+                imageView?.let { ShapeIconViewBinder.bind(imageView, shapeIcon) }
+            },
+        )
+
+    private fun RecyclerView.initShapeOptionList(
+        context: Context,
+        adapter: OptionItemAdapter<ShapeIconViewModel>,
+    ) {
+        apply {
+            this.layoutManager = LinearLayoutManager(context, RecyclerView.HORIZONTAL, false)
+            addItemDecoration(
+                SingleRowListItemSpacing(
+                    edgeItemSpacePx =
+                        context.resources.getDimensionPixelSize(
+                            R.dimen.floating_sheet_content_horizontal_padding
+                        ),
+                    itemHorizontalSpacePx =
+                        context.resources.getDimensionPixelSize(
+                            com.android.themepicker.R.dimen
+                                .floating_sheet_list_item_horizontal_space
+                        ),
+                )
+            )
+            this.adapter = adapter
+        }
+    }
+
+    private fun createGridOptionItemAdapter(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        backgroundDispatcher: CoroutineDispatcher,
+    ): OptionItemAdapter<GridIconViewModel> =
+        OptionItemAdapter(
+            layoutResourceId = R.layout.grid_option,
+            lifecycleOwner = lifecycleOwner,
+            backgroundDispatcher = backgroundDispatcher,
+            foregroundTintSpec =
+                OptionItemBinder.TintSpec(
+                    selectedColor =
+                        context.getColor(com.android.wallpaper.R.color.system_on_surface),
+                    unselectedColor =
+                        context.getColor(com.android.wallpaper.R.color.system_on_surface),
+                ),
+            bindIcon = { foregroundView: View, gridIcon: GridIconViewModel ->
+                val imageView = foregroundView as? ImageView
+                imageView?.let { GridIconViewBinder.bind(imageView, gridIcon) }
+            },
+        )
+
+    private fun RecyclerView.initGridOptionList(
+        context: Context,
+        adapter: OptionItemAdapter<GridIconViewModel>,
+    ) {
+        apply {
+            this.layoutManager = LinearLayoutManager(context, RecyclerView.HORIZONTAL, false)
+            addItemDecoration(
+                SingleRowListItemSpacing(
+                    edgeItemSpacePx =
+                        context.resources.getDimensionPixelSize(
+                            R.dimen.floating_sheet_content_horizontal_padding
+                        ),
+                    itemHorizontalSpacePx =
+                        context.resources.getDimensionPixelSize(
+                            com.android.themepicker.R.dimen
+                                .floating_sheet_list_item_horizontal_space
+                        ),
+                )
+            )
+            this.adapter = adapter
+        }
+    }
+}
diff --git a/src/com/android/customization/model/grid/GridOptionsManager2.kt b/src/com/android/wallpaper/customization/ui/binder/ShapeIconViewBinder.kt
similarity index 60%
copy from src/com/android/customization/model/grid/GridOptionsManager2.kt
copy to src/com/android/wallpaper/customization/ui/binder/ShapeIconViewBinder.kt
index ce8500a..550038d 100644
--- a/src/com/android/customization/model/grid/GridOptionsManager2.kt
+++ b/src/com/android/wallpaper/customization/ui/binder/ShapeIconViewBinder.kt
@@ -14,13 +14,14 @@
  * limitations under the License.
  */
 
-package com.android.customization.model.grid
+package com.android.wallpaper.customization.ui.binder
 
-interface GridOptionsManager2 {
+import android.widget.ImageView
+import com.android.customization.picker.grid.ui.viewmodel.ShapeIconViewModel
+import com.android.wallpaper.customization.ui.view.ShapeTileDrawable
 
-    suspend fun isGridOptionAvailable(): Boolean
-
-    suspend fun getGridOptions(): List<GridOptionModel>?
-
-    fun applyGridOption(gridName: String): Int
+object ShapeIconViewBinder {
+    fun bind(view: ImageView, shapeIcon: ShapeIconViewModel) {
+        view.setImageDrawable(ShapeTileDrawable(shapeIcon.path))
+    }
 }
diff --git a/src/com/android/wallpaper/customization/ui/binder/ThemePickerCustomizationOptionBinder.kt b/src/com/android/wallpaper/customization/ui/binder/ThemePickerCustomizationOptionBinder.kt
index 0740158..a92471c 100644
--- a/src/com/android/wallpaper/customization/ui/binder/ThemePickerCustomizationOptionBinder.kt
+++ b/src/com/android/wallpaper/customization/ui/binder/ThemePickerCustomizationOptionBinder.kt
@@ -104,14 +104,14 @@
                 .find { it.first == ThemePickerHomeCustomizationOption.COLORS }
                 ?.second
 
-        val optionShapeAndGrid =
+        val optionShapeGrid =
             homeScreenCustomizationOptionEntries
-                .find { it.first == ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID }
+                .find { it.first == ThemePickerHomeCustomizationOption.APP_SHAPE_GRID }
                 ?.second
-        val optionShapeAndGridDescription =
-            optionShapeAndGrid?.findViewById<TextView>(R.id.option_entry_app_grid_description)
-        val optionShapeAndGridIcon =
-            optionShapeAndGrid?.findViewById<ImageView>(R.id.option_entry_app_grid_icon)
+        val optionShapeGridDescription =
+            optionShapeGrid?.findViewById<TextView>(R.id.option_entry_app_shape_grid_description)
+        val optionShapeGridIcon =
+            optionShapeGrid?.findViewById<ImageView>(R.id.option_entry_app_shape_grid_icon)
 
         val optionsViewModel =
             viewModel.customizationOptionsViewModel as ThemePickerCustomizationOptionsViewModel
@@ -158,23 +158,21 @@
                 }
 
                 launch {
-                    optionsViewModel.onCustomizeShapeAndGridClicked.collect {
-                        optionShapeAndGrid?.setOnClickListener { _ -> it?.invoke() }
+                    optionsViewModel.onCustomizeShapeGridClicked.collect {
+                        optionShapeGrid?.setOnClickListener { _ -> it?.invoke() }
                     }
                 }
 
                 launch {
-                    optionsViewModel.shapeAndGridPickerViewModel.selectedGridOption.collect {
+                    optionsViewModel.shapeGridPickerViewModel.selectedGridOption.collect {
                         gridOption ->
-                        optionShapeAndGridDescription?.let {
-                            TextViewBinder.bind(it, gridOption.text)
-                        }
+                        optionShapeGridDescription?.let { TextViewBinder.bind(it, gridOption.text) }
                         gridOption.payload?.let { gridIconViewModel ->
-                            optionShapeAndGridIcon?.let {
+                            optionShapeGridIcon?.let {
                                 GridIconViewBinder.bind(view = it, viewModel = gridIconViewModel)
                             }
                             // TODO(b/363018910): Use ColorUpdateBinder to update color
-                            optionShapeAndGridIcon?.setColorFilter(
+                            optionShapeGridIcon?.setColorFilter(
                                 ContextCompat.getColor(
                                     view.context,
                                     com.android.wallpaper.R.color.system_on_surface_variant,
@@ -220,11 +218,12 @@
             }
 
         customizationOptionFloatingSheetViewMap
-            ?.get(ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID)
+            ?.get(ThemePickerHomeCustomizationOption.APP_SHAPE_GRID)
             ?.let {
-                ShapeAndGridFloatingSheetBinder.bind(
+                ShapeGridFloatingSheetBinder.bind(
                     it,
-                    optionsViewModel.shapeAndGridPickerViewModel,
+                    optionsViewModel,
+                    colorUpdateViewModel,
                     lifecycleOwner,
                     Dispatchers.IO,
                 )
diff --git a/src/com/android/wallpaper/customization/ui/util/ThemePickerCustomizationOptionUtil.kt b/src/com/android/wallpaper/customization/ui/util/ThemePickerCustomizationOptionUtil.kt
index 6789e2b..6006327 100644
--- a/src/com/android/wallpaper/customization/ui/util/ThemePickerCustomizationOptionUtil.kt
+++ b/src/com/android/wallpaper/customization/ui/util/ThemePickerCustomizationOptionUtil.kt
@@ -49,7 +49,7 @@
 
     enum class ThemePickerHomeCustomizationOption : CustomizationOptionUtil.CustomizationOption {
         COLORS,
-        APP_SHAPE_AND_GRID,
+        APP_SHAPE_GRID,
         THEMED_ICONS,
     }
 
@@ -109,9 +109,9 @@
                             )
                     )
                     add(
-                        ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID to
+                        ThemePickerHomeCustomizationOption.APP_SHAPE_GRID to
                             layoutInflater.inflate(
-                                R.layout.customization_option_entry_app_shape_and_grid,
+                                R.layout.customization_option_entry_app_shape_grid,
                                 optionContainer,
                                 false,
                             )
@@ -164,9 +164,9 @@
                     .also { bottomSheetContainer.addView(it) },
             )
             put(
-                ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID,
+                ThemePickerHomeCustomizationOption.APP_SHAPE_GRID,
                 inflateFloatingSheet(
-                        ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID,
+                        ThemePickerHomeCustomizationOption.APP_SHAPE_GRID,
                         bottomSheetContainer,
                         layoutInflater,
                     )
@@ -193,8 +193,7 @@
             ThemePickerLockCustomizationOption.CLOCK -> R.layout.floating_sheet_clock
             ThemePickerLockCustomizationOption.SHORTCUTS -> R.layout.floating_sheet_shortcut
             ThemePickerHomeCustomizationOption.COLORS -> R.layout.floating_sheet_colors
-            ThemePickerHomeCustomizationOption.APP_SHAPE_AND_GRID ->
-                R.layout.floating_sheet_shape_and_grid
+            ThemePickerHomeCustomizationOption.APP_SHAPE_GRID -> R.layout.floating_sheet_shape_grid
             else ->
                 throw IllegalStateException(
                     "Customization option $option does not have a bottom sheet view"
diff --git a/src/com/android/wallpaper/customization/ui/view/ShapeTileDrawable.kt b/src/com/android/wallpaper/customization/ui/view/ShapeTileDrawable.kt
new file mode 100644
index 0000000..3b492f4
--- /dev/null
+++ b/src/com/android/wallpaper/customization/ui/view/ShapeTileDrawable.kt
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.wallpaper.customization.ui.view
+
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PixelFormat
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+import androidx.core.graphics.PathParser
+
+/**
+ * Drawable that draws a shape tile with a given path.
+ *
+ * @param path Path of the shape assuming drawing on a 100x100 canvas.
+ */
+class ShapeTileDrawable(path: String) : Drawable() {
+
+    private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+    private val path = PathParser.createPathFromPathData(path)
+    // The path scaled with regard to the update of drawable bounds
+    private val scaledPath = Path(this.path)
+    private val scaleMatrix = Matrix()
+
+    override fun onBoundsChange(bounds: Rect) {
+        super.onBoundsChange(bounds)
+        scaleMatrix.setScale(bounds.width() / PATH_SIZE, bounds.height() / PATH_SIZE)
+        path.transform(scaleMatrix, scaledPath)
+    }
+
+    override fun draw(canvas: Canvas) {
+        canvas.drawPath(scaledPath, paint)
+    }
+
+    override fun setAlpha(alpha: Int) {
+        paint.alpha = alpha
+    }
+
+    override fun setColorFilter(colorFilter: ColorFilter?) {
+        paint.setColorFilter(colorFilter)
+    }
+
+    @Deprecated(
+        "getOpacity() is deprecated",
+        ReplaceWith("setAlpha(int)", "android.graphics.drawable.Drawable"),
+    )
+    override fun getOpacity(): Int {
+        return PixelFormat.TRANSLUCENT
+    }
+
+    companion object {
+        const val PATH_SIZE = 100f
+    }
+}
diff --git a/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModel.kt b/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModel.kt
deleted file mode 100644
index f319c04..0000000
--- a/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModel.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (C) 2024 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.wallpaper.customization.ui.viewmodel
-
-import android.content.Context
-import android.content.res.Resources
-import com.android.customization.model.ResourceConstants
-import com.android.customization.model.grid.GridOptionModel
-import com.android.customization.picker.grid.domain.interactor.GridInteractor2
-import com.android.customization.picker.grid.ui.viewmodel.GridIconViewModel
-import com.android.wallpaper.picker.common.text.ui.viewmodel.Text
-import com.android.wallpaper.picker.option.ui.viewmodel.OptionItemViewModel
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.android.scopes.ViewModelScoped
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.shareIn
-import kotlinx.coroutines.flow.stateIn
-
-class ShapeAndGridPickerViewModel
-@AssistedInject
-constructor(
-    @ApplicationContext private val context: Context,
-    interactor: GridInteractor2,
-    @Assisted private val viewModelScope: CoroutineScope,
-) {
-    // The currently-set system grid option
-    val selectedGridOption =
-        interactor.selectedGridOption
-            .filterNotNull()
-            .map { toOptionItemViewModel(it) }
-            .shareIn(scope = viewModelScope, started = SharingStarted.Lazily, replay = 1)
-    private val overridingGridOptionKey = MutableStateFlow<String?>(null)
-    // If the previewing key is null, use the currently-set system grid option
-    val previewingGridOptionKey =
-        combine(overridingGridOptionKey, selectedGridOption) {
-            overridingGridOptionKey,
-            selectedGridOption ->
-            overridingGridOptionKey ?: selectedGridOption.key.value
-        }
-
-    fun resetPreview() {
-        overridingGridOptionKey.value = null
-    }
-
-    val optionItems: Flow<List<OptionItemViewModel<GridIconViewModel>>> =
-        interactor.gridOptions
-            .filterNotNull()
-            .map { gridOptions -> gridOptions.map { toOptionItemViewModel(it) } }
-            .shareIn(scope = viewModelScope, started = SharingStarted.Lazily, replay = 1)
-
-    val onApply: Flow<(suspend () -> Unit)?> =
-        combine(previewingGridOptionKey, selectedGridOption) {
-            previewingGridOptionKey,
-            selectedGridOption ->
-            if (previewingGridOptionKey == selectedGridOption.key.value) {
-                null
-            } else {
-                { interactor.applySelectedOption(previewingGridOptionKey) }
-            }
-        }
-
-    private fun toOptionItemViewModel(
-        option: GridOptionModel
-    ): OptionItemViewModel<GridIconViewModel> {
-        val iconShapePath =
-            context.resources.getString(
-                Resources.getSystem()
-                    .getIdentifier(
-                        ResourceConstants.CONFIG_ICON_MASK,
-                        "string",
-                        ResourceConstants.ANDROID_PACKAGE,
-                    )
-            )
-        val isSelected =
-            previewingGridOptionKey
-                .map { it == option.key }
-                .stateIn(
-                    scope = viewModelScope,
-                    started = SharingStarted.Lazily,
-                    initialValue = false,
-                )
-
-        return OptionItemViewModel(
-            key = MutableStateFlow(option.key),
-            payload =
-                GridIconViewModel(columns = option.cols, rows = option.rows, path = iconShapePath),
-            text = Text.Loaded(option.title),
-            isSelected = isSelected,
-            onClicked =
-                isSelected.map {
-                    if (!it) {
-                        { overridingGridOptionKey.value = option.key }
-                    } else {
-                        null
-                    }
-                },
-        )
-    }
-
-    @ViewModelScoped
-    @AssistedFactory
-    interface Factory {
-        fun create(viewModelScope: CoroutineScope): ShapeAndGridPickerViewModel
-    }
-}
diff --git a/src/com/android/customization/model/grid/GridOptionsManager2.kt b/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridFloatingSheetHeightsViewModel.kt
similarity index 71%
copy from src/com/android/customization/model/grid/GridOptionsManager2.kt
copy to src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridFloatingSheetHeightsViewModel.kt
index ce8500a..237ab36 100644
--- a/src/com/android/customization/model/grid/GridOptionsManager2.kt
+++ b/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridFloatingSheetHeightsViewModel.kt
@@ -14,13 +14,9 @@
  * limitations under the License.
  */
 
-package com.android.customization.model.grid
+package com.android.wallpaper.customization.ui.viewmodel
 
-interface GridOptionsManager2 {
-
-    suspend fun isGridOptionAvailable(): Boolean
-
-    suspend fun getGridOptions(): List<GridOptionModel>?
-
-    fun applyGridOption(gridName: String): Int
-}
+data class ShapeGridFloatingSheetHeightsViewModel(
+    val shapeContentHeight: Int? = null,
+    val gridContentHeight: Int? = null,
+)
diff --git a/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModel.kt b/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModel.kt
new file mode 100644
index 0000000..7be934d
--- /dev/null
+++ b/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModel.kt
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.wallpaper.customization.ui.viewmodel
+
+import android.content.Context
+import android.content.res.Resources
+import com.android.customization.model.ResourceConstants
+import com.android.customization.model.grid.GridOptionModel
+import com.android.customization.picker.grid.domain.interactor.ShapeGridInteractor
+import com.android.customization.picker.grid.ui.viewmodel.GridIconViewModel
+import com.android.customization.picker.grid.ui.viewmodel.ShapeIconViewModel
+import com.android.themepicker.R
+import com.android.wallpaper.picker.common.icon.ui.viewmodel.Icon
+import com.android.wallpaper.picker.common.text.ui.viewmodel.Text
+import com.android.wallpaper.picker.customization.ui.viewmodel.FloatingToolbarTabViewModel
+import com.android.wallpaper.picker.option.ui.viewmodel.OptionItemViewModel
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.scopes.ViewModelScoped
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.flow.stateIn
+
+class ShapeGridPickerViewModel
+@AssistedInject
+constructor(
+    @ApplicationContext private val context: Context,
+    interactor: ShapeGridInteractor,
+    @Assisted private val viewModelScope: CoroutineScope,
+) {
+
+    enum class Tab {
+        SHAPE,
+        GRID,
+    }
+
+    // TODO (b/362237825): Get the shape options from the Launcher
+    val shapePaths =
+        listOf(
+            Pair(
+                "arch",
+                "M100 83.46C100 85.471 100 86.476 99.9 87.321 99.116 93.916 93.916 99.116 87.321 99.9 86.476 100 85.471 100 83.46 100H16.54C14.529 100 13.524 100 12.679 99.9 6.084 99.116.884 93.916.1 87.321 0 86.476 0 85.471 0 83.46L0 50C0 22.386 22.386 0 50 0 77.614 0 100 22.386 100 50V83.46Z",
+            ),
+            Pair(
+                "4-sided-cookie",
+                "M63.605 3C84.733-6.176 106.176 15.268 97 36.395L95.483 39.888C92.681 46.338 92.681 53.662 95.483 60.112L97 63.605C106.176 84.732 84.733 106.176 63.605 97L60.112 95.483C53.662 92.681 46.338 92.681 39.888 95.483L36.395 97C15.267 106.176-6.176 84.732 3 63.605L4.517 60.112C7.319 53.662 7.319 46.338 4.517 39.888L3 36.395C-6.176 15.268 15.267-6.176 36.395 3L39.888 4.517C46.338 7.319 53.662 7.319 60.112 4.517L63.605 3Z",
+            ),
+            Pair(
+                "7-sided-cookie",
+                "M35.209 4.878C36.326 3.895 36.884 3.404 37.397 3.006 44.82-2.742 55.18-2.742 62.603 3.006 63.116 3.404 63.674 3.895 64.791 4.878 65.164 5.207 65.351 5.371 65.539 5.529 68.167 7.734 71.303 9.248 74.663 9.932 74.902 9.981 75.147 10.025 75.637 10.113 77.1 10.375 77.831 10.506 78.461 10.66 87.573 12.893 94.032 21.011 94.176 30.412 94.186 31.062 94.151 31.805 94.08 33.293 94.057 33.791 94.045 34.04 94.039 34.285 93.958 37.72 94.732 41.121 96.293 44.18 96.404 44.399 96.522 44.618 96.759 45.056 97.467 46.366 97.821 47.021 98.093 47.611 102.032 56.143 99.727 66.266 92.484 72.24 91.983 72.653 91.381 73.089 90.177 73.961 89.774 74.254 89.572 74.4 89.377 74.548 86.647 76.626 84.477 79.353 83.063 82.483 82.962 82.707 82.865 82.936 82.671 83.395 82.091 84.766 81.8 85.451 81.51 86.033 77.31 94.44 67.977 98.945 58.801 96.994 58.166 96.859 57.451 96.659 56.019 96.259 55.54 96.125 55.3 96.058 55.063 95.998 51.74 95.154 48.26 95.154 44.937 95.998 44.699 96.058 44.46 96.125 43.981 96.259 42.549 96.659 41.834 96.859 41.199 96.994 32.023 98.945 22.69 94.44 18.49 86.033 18.2 85.451 17.909 84.766 17.329 83.395 17.135 82.936 17.038 82.707 16.937 82.483 15.523 79.353 13.353 76.626 10.623 74.548 10.428 74.4 10.226 74.254 9.823 73.961 8.619 73.089 8.017 72.653 7.516 72.24.273 66.266-2.032 56.143 1.907 47.611 2.179 47.021 2.533 46.366 3.241 45.056 3.478 44.618 3.596 44.399 3.707 44.18 5.268 41.121 6.042 37.72 5.961 34.285 5.955 34.04 5.943 33.791 5.92 33.293 5.849 31.805 5.814 31.062 5.824 30.412 5.968 21.011 12.427 12.893 21.539 10.66 22.169 10.506 22.9 10.375 24.363 10.113 24.853 10.025 25.098 9.981 25.337 9.932 28.697 9.248 31.833 7.734 34.461 5.529 34.649 5.371 34.836 5.207 35.209 4.878Z",
+            ),
+            Pair(
+                "sunny",
+                "M42.846 4.873C46.084-.531 53.916-.531 57.154 4.873L60.796 10.951C62.685 14.103 66.414 15.647 69.978 14.754L76.851 13.032C82.962 11.5 88.5 17.038 86.968 23.149L85.246 30.022C84.353 33.586 85.897 37.315 89.049 39.204L95.127 42.846C100.531 46.084 100.531 53.916 95.127 57.154L89.049 60.796C85.897 62.685 84.353 66.414 85.246 69.978L86.968 76.851C88.5 82.962 82.962 88.5 76.851 86.968L69.978 85.246C66.414 84.353 62.685 85.898 60.796 89.049L57.154 95.127C53.916 100.531 46.084 100.531 42.846 95.127L39.204 89.049C37.315 85.898 33.586 84.353 30.022 85.246L23.149 86.968C17.038 88.5 11.5 82.962 13.032 76.851L14.754 69.978C15.647 66.414 14.103 62.685 10.951 60.796L4.873 57.154C-.531 53.916-.531 46.084 4.873 42.846L10.951 39.204C14.103 37.315 15.647 33.586 14.754 30.022L13.032 23.149C11.5 17.038 17.038 11.5 23.149 13.032L30.022 14.754C33.586 15.647 37.315 14.103 39.204 10.951L42.846 4.873Z",
+            ),
+            Pair(
+                "circle",
+                "M99.18 50C99.18 77.162 77.162 99.18 50 99.18 22.838 99.18.82 77.162.82 50 .82 22.839 22.838.82 50 .82 77.162.82 99.18 22.839 99.18 50Z",
+            ),
+            Pair(
+                "square",
+                "M99.18 53.689C99.18 67.434 99.18 74.306 97.022 79.758 93.897 87.649 87.649 93.897 79.758 97.022 74.306 99.18 67.434 99.18 53.689 99.18H46.311C32.566 99.18 25.694 99.18 20.242 97.022 12.351 93.897 6.103 87.649 2.978 79.758.82 74.306.82 67.434.82 53.689L.82 46.311C.82 32.566.82 25.694 2.978 20.242 6.103 12.351 12.351 6.103 20.242 2.978 25.694.82 32.566.82 46.311.82L53.689.82C67.434.82 74.306.82 79.758 2.978 87.649 6.103 93.897 12.351 97.022 20.242 99.18 25.694 99.18 32.566 99.18 46.311V53.689Z",
+            ),
+        )
+
+    // Tabs
+    private val _selectedTab = MutableStateFlow(Tab.SHAPE)
+    val selectedTab: StateFlow<Tab> = _selectedTab.asStateFlow()
+    val tabs: Flow<List<FloatingToolbarTabViewModel>> =
+        _selectedTab.map {
+            listOf(
+                FloatingToolbarTabViewModel(
+                    Icon.Resource(
+                        res = R.drawable.ic_category_filled_24px,
+                        contentDescription = Text.Resource(R.string.preview_name_shape),
+                    ),
+                    context.getString(R.string.preview_name_shape),
+                    it == Tab.SHAPE,
+                ) {
+                    _selectedTab.value = Tab.SHAPE
+                },
+                FloatingToolbarTabViewModel(
+                    Icon.Resource(
+                        res = R.drawable.ic_apps_filled_24px,
+                        contentDescription = Text.Resource(R.string.grid_layout),
+                    ),
+                    context.getString(R.string.grid_layout),
+                    it == Tab.GRID,
+                ) {
+                    _selectedTab.value = Tab.GRID
+                },
+            )
+        }
+
+    // The currently-set system shape option
+    val selectedShapeKey = flowOf(shapePaths[0].first)
+    private val overridingShapeKey = MutableStateFlow<String?>(null)
+    // If the overriding key is null, use the currently-set system shape option
+    val previewingShapeKey =
+        combine(overridingShapeKey, selectedShapeKey) { overridingShapeOptionKey, selectedShapeKey
+            ->
+            overridingShapeOptionKey ?: selectedShapeKey
+        }
+
+    val shapeOptions: Flow<List<OptionItemViewModel<ShapeIconViewModel>>> =
+        MutableStateFlow(shapePaths.map { toShapeOptionItemViewModel(it.first, it.second) })
+            .shareIn(scope = viewModelScope, started = SharingStarted.Lazily, replay = 1)
+
+    // The currently-set system grid option
+    val selectedGridOption =
+        interactor.selectedGridOption
+            .filterNotNull()
+            .map { toGridOptionItemViewModel(it) }
+            .shareIn(scope = viewModelScope, started = SharingStarted.Lazily, replay = 1)
+    private val overridingGridOptionKey = MutableStateFlow<String?>(null)
+    // If the overriding key is null, use the currently-set system grid option
+    val previewingGridOptionKey =
+        combine(overridingGridOptionKey, selectedGridOption) {
+            overridingGridOptionKey,
+            selectedGridOption ->
+            overridingGridOptionKey ?: selectedGridOption.key.value
+        }
+
+    val gridOptions: Flow<List<OptionItemViewModel<GridIconViewModel>>> =
+        interactor.gridOptions
+            .filterNotNull()
+            .map { gridOptions -> gridOptions.map { toGridOptionItemViewModel(it) } }
+            .shareIn(scope = viewModelScope, started = SharingStarted.Lazily, replay = 1)
+
+    val onApply: Flow<(suspend () -> Unit)?> =
+        combine(previewingGridOptionKey, selectedGridOption) {
+            previewingGridOptionKey,
+            selectedGridOption ->
+            if (previewingGridOptionKey == selectedGridOption.key.value) {
+                null
+            } else {
+                { interactor.applySelectedOption(previewingGridOptionKey) }
+            }
+        }
+
+    fun resetPreview() {
+        overridingShapeKey.value = null
+        overridingGridOptionKey.value = null
+        _selectedTab.value = Tab.SHAPE
+    }
+
+    private fun toShapeOptionItemViewModel(
+        key: String,
+        path: String,
+    ): OptionItemViewModel<ShapeIconViewModel> {
+        val isSelected =
+            previewingShapeKey
+                .map { it == key }
+                .stateIn(
+                    scope = viewModelScope,
+                    started = SharingStarted.Lazily,
+                    initialValue = false,
+                )
+
+        return OptionItemViewModel(
+            key = MutableStateFlow(key),
+            payload = ShapeIconViewModel(key, path),
+            text = Text.Loaded(key),
+            isSelected = isSelected,
+            onClicked =
+                isSelected.map {
+                    if (!it) {
+                        { overridingShapeKey.value = key }
+                    } else {
+                        null
+                    }
+                },
+        )
+    }
+
+    private fun toGridOptionItemViewModel(
+        option: GridOptionModel
+    ): OptionItemViewModel<GridIconViewModel> {
+        val iconShapePath =
+            context.resources.getString(
+                Resources.getSystem()
+                    .getIdentifier(
+                        ResourceConstants.CONFIG_ICON_MASK,
+                        "string",
+                        ResourceConstants.ANDROID_PACKAGE,
+                    )
+            )
+        val isSelected =
+            previewingGridOptionKey
+                .map { it == option.key }
+                .stateIn(
+                    scope = viewModelScope,
+                    started = SharingStarted.Lazily,
+                    initialValue = false,
+                )
+
+        return OptionItemViewModel(
+            key = MutableStateFlow(option.key),
+            payload =
+                GridIconViewModel(columns = option.cols, rows = option.rows, path = iconShapePath),
+            text = Text.Loaded(option.title),
+            isSelected = isSelected,
+            onClicked =
+                isSelected.map {
+                    if (!it) {
+                        { overridingGridOptionKey.value = option.key }
+                    } else {
+                        null
+                    }
+                },
+        )
+    }
+
+    @ViewModelScoped
+    @AssistedFactory
+    interface Factory {
+        fun create(viewModelScope: CoroutineScope): ShapeGridPickerViewModel
+    }
+}
diff --git a/src/com/android/wallpaper/customization/ui/viewmodel/ThemePickerCustomizationOptionsViewModel.kt b/src/com/android/wallpaper/customization/ui/viewmodel/ThemePickerCustomizationOptionsViewModel.kt
index 4707f81..d54fd59 100644
--- a/src/com/android/wallpaper/customization/ui/viewmodel/ThemePickerCustomizationOptionsViewModel.kt
+++ b/src/com/android/wallpaper/customization/ui/viewmodel/ThemePickerCustomizationOptionsViewModel.kt
@@ -43,7 +43,7 @@
     keyguardQuickAffordancePickerViewModel2Factory: KeyguardQuickAffordancePickerViewModel2.Factory,
     colorPickerViewModel2Factory: ColorPickerViewModel2.Factory,
     clockPickerViewModelFactory: ClockPickerViewModel.Factory,
-    shapeAndGridPickerViewModelFactory: ShapeAndGridPickerViewModel.Factory,
+    shapeGridPickerViewModelFactory: ShapeGridPickerViewModel.Factory,
     val darkModeViewModel: DarkModeViewModel,
     @Assisted private val viewModelScope: CoroutineScope,
 ) : CustomizationOptionsViewModel {
@@ -55,14 +55,14 @@
     val keyguardQuickAffordancePickerViewModel2 =
         keyguardQuickAffordancePickerViewModel2Factory.create(viewModelScope = viewModelScope)
     val colorPickerViewModel2 = colorPickerViewModel2Factory.create(viewModelScope = viewModelScope)
-    val shapeAndGridPickerViewModel =
-        shapeAndGridPickerViewModelFactory.create(viewModelScope = viewModelScope)
+    val shapeGridPickerViewModel =
+        shapeGridPickerViewModelFactory.create(viewModelScope = viewModelScope)
 
     override val selectedOption = defaultCustomizationOptionsViewModel.selectedOption
 
     override fun deselectOption(): Boolean {
         keyguardQuickAffordancePickerViewModel2.resetPreview()
-        shapeAndGridPickerViewModel.resetPreview()
+        shapeGridPickerViewModel.resetPreview()
         clockPickerViewModel.resetPreview()
         colorPickerViewModel2.resetPreview()
         darkModeViewModel.resetPreview()
@@ -109,13 +109,13 @@
             }
         }
 
-    val onCustomizeShapeAndGridClicked: Flow<(() -> Unit)?> =
+    val onCustomizeShapeGridClicked: Flow<(() -> Unit)?> =
         selectedOption.map {
             if (it == null) {
                 {
                     defaultCustomizationOptionsViewModel.selectOption(
                         ThemePickerCustomizationOptionUtil.ThemePickerHomeCustomizationOption
-                            .APP_SHAPE_AND_GRID
+                            .APP_SHAPE_GRID
                     )
                 }
             } else {
@@ -133,7 +133,7 @@
                     ThemePickerCustomizationOptionUtil.ThemePickerLockCustomizationOption
                         .SHORTCUTS -> keyguardQuickAffordancePickerViewModel2.onApply
                     ThemePickerCustomizationOptionUtil.ThemePickerHomeCustomizationOption
-                        .APP_SHAPE_AND_GRID -> shapeAndGridPickerViewModel.onApply
+                        .APP_SHAPE_GRID -> shapeGridPickerViewModel.onApply
                     ThemePickerCustomizationOptionUtil.ThemePickerHomeCustomizationOption.COLORS ->
                         combine(colorPickerViewModel2.onApply, darkModeViewModel.onApply) {
                             colorOnApply,
diff --git a/src/com/android/wallpaper/picker/common/preview/ui/binder/ThemePickerWorkspaceCallbackBinder.kt b/src/com/android/wallpaper/picker/common/preview/ui/binder/ThemePickerWorkspaceCallbackBinder.kt
index 225809f..0dc38e8 100644
--- a/src/com/android/wallpaper/picker/common/preview/ui/binder/ThemePickerWorkspaceCallbackBinder.kt
+++ b/src/com/android/wallpaper/picker/common/preview/ui/binder/ThemePickerWorkspaceCallbackBinder.kt
@@ -137,7 +137,7 @@
                 lifecycleOwner.lifecycleScope.launch {
                     lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                         launch {
-                            viewModel.shapeAndGridPickerViewModel.previewingGridOptionKey.collect {
+                            viewModel.shapeGridPickerViewModel.previewingGridOptionKey.collect {
                                 workspaceCallback.sendMessage(
                                     MESSAGE_ID_UPDATE_GRID,
                                     bundleOf(KEY_GRID_NAME to it),
diff --git a/src/com/android/wallpaper/picker/di/modules/ThemePickerSharedAppModule.kt b/src/com/android/wallpaper/picker/di/modules/ThemePickerSharedAppModule.kt
index 22e5fe5..98c881f 100644
--- a/src/com/android/wallpaper/picker/di/modules/ThemePickerSharedAppModule.kt
+++ b/src/com/android/wallpaper/picker/di/modules/ThemePickerSharedAppModule.kt
@@ -16,8 +16,8 @@
 
 package com.android.wallpaper.picker.di.modules
 
-import com.android.customization.model.grid.DefaultGridOptionsManager
-import com.android.customization.model.grid.GridOptionsManager2
+import com.android.customization.model.grid.DefaultShapeGridManager
+import com.android.customization.model.grid.ShapeGridManager
 import com.android.customization.picker.mode.shared.util.DarkModeUtil
 import com.android.customization.picker.mode.shared.util.DarkModeUtilImpl
 import dagger.Binds
@@ -32,7 +32,7 @@
 
     @Binds
     @Singleton
-    abstract fun bindGridOptionsManager2(impl: DefaultGridOptionsManager): GridOptionsManager2
+    abstract fun bindGridOptionsManager2(impl: DefaultShapeGridManager): ShapeGridManager
 
     @Binds @Singleton abstract fun bindDarkModeUtil(impl: DarkModeUtilImpl): DarkModeUtil
 }
diff --git a/tests/common/src/com/android/customization/model/grid/FakeGridOptionsManager.kt b/tests/common/src/com/android/customization/model/grid/FakeShapeGridManager.kt
similarity index 95%
rename from tests/common/src/com/android/customization/model/grid/FakeGridOptionsManager.kt
rename to tests/common/src/com/android/customization/model/grid/FakeShapeGridManager.kt
index cc23981..a5a94c3 100644
--- a/tests/common/src/com/android/customization/model/grid/FakeGridOptionsManager.kt
+++ b/tests/common/src/com/android/customization/model/grid/FakeShapeGridManager.kt
@@ -20,7 +20,7 @@
 import javax.inject.Singleton
 
 @Singleton
-class FakeGridOptionsManager @Inject constructor() : GridOptionsManager2 {
+class FakeShapeGridManager @Inject constructor() : ShapeGridManager {
 
     var isGridOptionAvailable: Boolean = true
 
diff --git a/tests/common/src/com/android/wallpaper/di/modules/ThemePickerSharedAppTestModule.kt b/tests/common/src/com/android/wallpaper/di/modules/ThemePickerSharedAppTestModule.kt
index 3112f75..4969db4 100644
--- a/tests/common/src/com/android/wallpaper/di/modules/ThemePickerSharedAppTestModule.kt
+++ b/tests/common/src/com/android/wallpaper/di/modules/ThemePickerSharedAppTestModule.kt
@@ -16,8 +16,8 @@
 
 package com.android.wallpaper.di.modules
 
-import com.android.customization.model.grid.FakeGridOptionsManager
-import com.android.customization.model.grid.GridOptionsManager2
+import com.android.customization.model.grid.FakeShapeGridManager
+import com.android.customization.model.grid.ShapeGridManager
 import com.android.customization.picker.mode.shared.util.DarkModeUtil
 import com.android.customization.picker.mode.shared.util.FakeDarkModeUtil
 import com.android.wallpaper.picker.di.modules.ThemePickerSharedAppModule
@@ -36,7 +36,7 @@
 
     @Binds
     @Singleton
-    abstract fun bindGridOptionsManager2(impl: FakeGridOptionsManager): GridOptionsManager2
+    abstract fun bindGridOptionsManager2(impl: FakeShapeGridManager): ShapeGridManager
 
     @Binds @Singleton abstract fun bindDarkModeUtil(impl: FakeDarkModeUtil): DarkModeUtil
 }
diff --git a/tests/robotests/src/com/android/customization/picker/grid/data/repository/GridRepository2Test.kt b/tests/robotests/src/com/android/customization/picker/grid/data/repository/ShapeGridRepositoryTest.kt
similarity index 84%
rename from tests/robotests/src/com/android/customization/picker/grid/data/repository/GridRepository2Test.kt
rename to tests/robotests/src/com/android/customization/picker/grid/data/repository/ShapeGridRepositoryTest.kt
index 404f08b..61f8743 100644
--- a/tests/robotests/src/com/android/customization/picker/grid/data/repository/GridRepository2Test.kt
+++ b/tests/robotests/src/com/android/customization/picker/grid/data/repository/ShapeGridRepositoryTest.kt
@@ -17,7 +17,7 @@
 package com.android.customization.picker.grid.data.repository
 
 import androidx.test.filters.SmallTest
-import com.android.customization.model.grid.FakeGridOptionsManager
+import com.android.customization.model.grid.FakeShapeGridManager
 import com.android.wallpaper.picker.di.modules.BackgroundDispatcher
 import com.android.wallpaper.testing.collectLastValue
 import com.google.common.truth.Truth.assertThat
@@ -42,21 +42,21 @@
 @OptIn(ExperimentalCoroutinesApi::class)
 @SmallTest
 @RunWith(RobolectricTestRunner::class)
-class GridRepository2Test {
+class ShapeGridRepositoryTest {
 
     @get:Rule var hiltRule = HiltAndroidRule(this)
-    @Inject lateinit var gridOptionsManager: FakeGridOptionsManager
+    @Inject lateinit var gridOptionsManager: FakeShapeGridManager
     @Inject lateinit var testScope: TestScope
     @BackgroundDispatcher @Inject lateinit var bgScope: CoroutineScope
     @BackgroundDispatcher @Inject lateinit var bgDispatcher: CoroutineDispatcher
 
-    private lateinit var underTest: GridRepository2
+    private lateinit var underTest: ShapeGridRepository
 
     @Before
     fun setUp() {
         hiltRule.inject()
         underTest =
-            GridRepository2(
+            ShapeGridRepository(
                 manager = gridOptionsManager,
                 bgScope = bgScope,
                 bgDispatcher = bgDispatcher,
@@ -86,7 +86,7 @@
     fun gridOptions_default() =
         testScope.runTest {
             val gridOptions = collectLastValue(underTest.gridOptions)
-            assertThat(gridOptions()).isEqualTo(FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST)
+            assertThat(gridOptions()).isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST)
         }
 
     @Test
@@ -94,7 +94,7 @@
         testScope.runTest {
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
             assertThat(selectedGridOption())
-                .isEqualTo(FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST[0])
+                .isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST[0])
         }
 
     @Test
@@ -104,7 +104,7 @@
             underTest.applySelectedOption("practical")
             assertThat(gridOptions())
                 .isEqualTo(
-                    FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST.map {
+                    FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST.map {
                         it.copy(isCurrent = it.key == "practical")
                     }
                 )
@@ -116,8 +116,6 @@
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
             underTest.applySelectedOption("practical")
             assertThat(selectedGridOption())
-                .isEqualTo(
-                    FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST[1].copy(isCurrent = true)
-                )
+                .isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST[1].copy(isCurrent = true))
         }
 }
diff --git a/tests/robotests/src/com/android/customization/picker/grid/domain/interactor/GridInteractor2Test.kt b/tests/robotests/src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractorTest.kt
similarity index 80%
rename from tests/robotests/src/com/android/customization/picker/grid/domain/interactor/GridInteractor2Test.kt
rename to tests/robotests/src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractorTest.kt
index bfbe282..51642cb 100644
--- a/tests/robotests/src/com/android/customization/picker/grid/domain/interactor/GridInteractor2Test.kt
+++ b/tests/robotests/src/com/android/customization/picker/grid/domain/interactor/ShapeGridInteractorTest.kt
@@ -17,8 +17,8 @@
 package com.android.customization.picker.grid.domain.interactor
 
 import androidx.test.filters.SmallTest
-import com.android.customization.model.grid.FakeGridOptionsManager
-import com.android.customization.picker.grid.data.repository.GridRepository2
+import com.android.customization.model.grid.FakeShapeGridManager
+import com.android.customization.picker.grid.data.repository.ShapeGridRepository
 import com.android.wallpaper.testing.collectLastValue
 import com.google.common.truth.Truth.assertThat
 import dagger.hilt.android.testing.HiltAndroidRule
@@ -40,19 +40,19 @@
 @OptIn(ExperimentalCoroutinesApi::class)
 @SmallTest
 @RunWith(RobolectricTestRunner::class)
-class GridInteractor2Test {
+class ShapeGridInteractorTest {
 
     @get:Rule var hiltRule = HiltAndroidRule(this)
-    @Inject lateinit var gridOptionsManager: FakeGridOptionsManager
-    @Inject lateinit var repository: GridRepository2
+    @Inject lateinit var gridOptionsManager: FakeShapeGridManager
+    @Inject lateinit var repository: ShapeGridRepository
     @Inject lateinit var testScope: TestScope
 
-    private lateinit var underTest: GridInteractor2
+    private lateinit var underTest: ShapeGridInteractor
 
     @Before
     fun setUp() {
         hiltRule.inject()
-        underTest = GridInteractor2(repository)
+        underTest = ShapeGridInteractor(repository)
     }
 
     @After
@@ -78,7 +78,7 @@
     fun gridOptions_default() =
         testScope.runTest {
             val gridOptions = collectLastValue(underTest.gridOptions)
-            assertThat(gridOptions()).isEqualTo(FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST)
+            assertThat(gridOptions()).isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST)
         }
 
     @Test
@@ -86,7 +86,7 @@
         testScope.runTest {
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
             assertThat(selectedGridOption())
-                .isEqualTo(FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST[0])
+                .isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST[0])
         }
 
     @Test
@@ -96,7 +96,7 @@
             underTest.applySelectedOption("practical")
             assertThat(gridOptions())
                 .isEqualTo(
-                    FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST.map {
+                    FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST.map {
                         it.copy(isCurrent = it.key == "practical")
                     }
                 )
@@ -108,8 +108,6 @@
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
             underTest.applySelectedOption("practical")
             assertThat(selectedGridOption())
-                .isEqualTo(
-                    FakeGridOptionsManager.DEFAULT_GRID_OPTION_LIST[1].copy(isCurrent = true)
-                )
+                .isEqualTo(FakeShapeGridManager.DEFAULT_GRID_OPTION_LIST[1].copy(isCurrent = true))
         }
 }
diff --git a/tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModelTest.kt b/tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModelTest.kt
similarity index 61%
rename from tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModelTest.kt
rename to tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModelTest.kt
index af9bc4e..dcf658e 100644
--- a/tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeAndGridPickerViewModelTest.kt
+++ b/tests/robotests/src/com/android/wallpaper/customization/ui/viewmodel/ShapeGridPickerViewModelTest.kt
@@ -21,9 +21,10 @@
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.filters.SmallTest
 import com.android.customization.model.ResourceConstants
-import com.android.customization.model.grid.FakeGridOptionsManager
-import com.android.customization.picker.grid.domain.interactor.GridInteractor2
+import com.android.customization.model.grid.FakeShapeGridManager
+import com.android.customization.picker.grid.domain.interactor.ShapeGridInteractor
 import com.android.customization.picker.grid.ui.viewmodel.GridIconViewModel
+import com.android.customization.picker.grid.ui.viewmodel.ShapeIconViewModel
 import com.android.wallpaper.picker.common.text.ui.viewmodel.Text
 import com.android.wallpaper.picker.option.ui.viewmodel.OptionItemViewModel
 import com.android.wallpaper.testing.collectLastValue
@@ -48,12 +49,12 @@
 @OptIn(ExperimentalCoroutinesApi::class)
 @SmallTest
 @RunWith(RobolectricTestRunner::class)
-class ShapeAndGridPickerViewModelTest {
+class ShapeGridPickerViewModelTest {
 
     @get:Rule var hiltRule = HiltAndroidRule(this)
     @Inject lateinit var testScope: TestScope
-    @Inject lateinit var gridOptionsManager: FakeGridOptionsManager
-    @Inject lateinit var interactor: GridInteractor2
+    @Inject lateinit var gridOptionsManager: FakeShapeGridManager
+    @Inject lateinit var interactor: ShapeGridInteractor
     @Inject @ApplicationContext lateinit var appContext: Context
 
     private val iconShapePath =
@@ -68,12 +69,12 @@
                     )
             )
 
-    private lateinit var underTest: ShapeAndGridPickerViewModel
+    private lateinit var underTest: ShapeGridPickerViewModel
 
     @Before
     fun setUp() {
         hiltRule.inject()
-        underTest = ShapeAndGridPickerViewModel(appContext, interactor, testScope.backgroundScope)
+        underTest = ShapeGridPickerViewModel(appContext, interactor, testScope.backgroundScope)
     }
 
     @After
@@ -82,6 +83,75 @@
     }
 
     @Test
+    fun selectedTabUpdates_whenClickOnGridTab() =
+        testScope.runTest {
+            val selectedTab = collectLastValue(underTest.selectedTab)
+            val tabs = collectLastValue(underTest.tabs)
+            val onGridTabClicked = tabs()?.get(1)?.onClick
+
+            assertThat(selectedTab()).isEqualTo(ShapeGridPickerViewModel.Tab.SHAPE)
+
+            onGridTabClicked?.invoke()
+
+            assertThat(selectedTab()).isEqualTo(ShapeGridPickerViewModel.Tab.GRID)
+        }
+
+    @Test
+    fun selectedShapeKey() =
+        testScope.runTest {
+            val selectedShapeKey = collectLastValue(underTest.selectedShapeKey)
+
+            assertThat(selectedShapeKey()).isEqualTo("arch")
+        }
+
+    @Test
+    fun shapeOptions() =
+        testScope.runTest {
+            val shapeOptions = collectLastValue(underTest.shapeOptions)
+
+            for (i in 0 until underTest.shapePaths.size) {
+                val expectedKey = underTest.shapePaths[i].first
+                val expectedPath = underTest.shapePaths[i].second
+                assertShapeItem(
+                    optionItem = shapeOptions()?.get(i),
+                    key = expectedKey,
+                    payload = ShapeIconViewModel(expectedKey, expectedPath),
+                    text = Text.Loaded(expectedKey),
+                    isTextUserVisible = true,
+                    isSelected = expectedKey == "arch",
+                    isEnabled = true,
+                )
+            }
+        }
+
+    @Test
+    fun shapeOptions_whenClickOnCircleOption() =
+        testScope.runTest {
+            val shapeOptions = collectLastValue(underTest.shapeOptions)
+            val previewingShapeKey = collectLastValue(underTest.previewingShapeKey)
+            val onCircleOptionClicked =
+                shapeOptions()?.get(4)?.onClicked?.let { collectLastValue(it) }
+            checkNotNull(onCircleOptionClicked)
+
+            onCircleOptionClicked()?.invoke()
+
+            assertThat(previewingShapeKey()).isEqualTo("circle")
+            for (i in 0 until underTest.shapePaths.size) {
+                val expectedKey = underTest.shapePaths[i].first
+                val expectedPath = underTest.shapePaths[i].second
+                assertShapeItem(
+                    optionItem = shapeOptions()?.get(i),
+                    key = expectedKey,
+                    payload = ShapeIconViewModel(expectedKey, expectedPath),
+                    text = Text.Loaded(expectedKey),
+                    isTextUserVisible = true,
+                    isSelected = expectedKey == "circle",
+                    isEnabled = true,
+                )
+            }
+        }
+
+    @Test
     fun selectedGridOption() =
         testScope.runTest {
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
@@ -101,7 +171,7 @@
     fun selectedGridOption_shouldUpdate_afterOnApply() =
         testScope.runTest {
             val selectedGridOption = collectLastValue(underTest.selectedGridOption)
-            val optionItems = collectLastValue(underTest.optionItems)
+            val optionItems = collectLastValue(underTest.gridOptions)
             val onApply = collectLastValue(underTest.onApply)
             val onPracticalOptionClick =
                 optionItems()?.get(1)?.onClicked?.let { collectLastValue(it) }
@@ -124,7 +194,7 @@
     @Test
     fun optionItems() =
         testScope.runTest {
-            val optionItems = collectLastValue(underTest.optionItems)
+            val optionItems = collectLastValue(underTest.gridOptions)
 
             assertOptionItem(
                 optionItem = optionItems()?.get(0),
@@ -149,7 +219,7 @@
     @Test
     fun optionItems_whenClickOnPracticalOption() =
         testScope.runTest {
-            val optionItems = collectLastValue(underTest.optionItems)
+            val optionItems = collectLastValue(underTest.gridOptions)
             val onPracticalOptionClick =
                 optionItems()?.get(1)?.onClicked?.let { collectLastValue(it) }
             checkNotNull(onPracticalOptionClick)
@@ -176,6 +246,24 @@
             )
         }
 
+    private fun TestScope.assertShapeItem(
+        optionItem: OptionItemViewModel<ShapeIconViewModel>?,
+        key: String,
+        payload: ShapeIconViewModel?,
+        text: Text,
+        isTextUserVisible: Boolean,
+        isSelected: Boolean,
+        isEnabled: Boolean,
+    ) {
+        checkNotNull(optionItem)
+        assertThat(collectLastValue(optionItem.key)()).isEqualTo(key)
+        assertThat(optionItem.text).isEqualTo(text)
+        assertThat(optionItem.payload).isEqualTo(payload)
+        assertThat(optionItem.isTextUserVisible).isEqualTo(isTextUserVisible)
+        assertThat(collectLastValue(optionItem.isSelected)()).isEqualTo(isSelected)
+        assertThat(optionItem.isEnabled).isEqualTo(isEnabled)
+    }
+
     private fun TestScope.assertOptionItem(
         optionItem: OptionItemViewModel<GridIconViewModel>?,
         key: String,
