diff --git a/google/themes/Bl4ckAndYell0/res/values/colors.xml b/google/themes/Bl4ckAndYell0/res/values/colors.xml
index 6e60a95..fa3e992 100644
--- a/google/themes/Bl4ckAndYell0/res/values/colors.xml
+++ b/google/themes/Bl4ckAndYell0/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff29282c</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff29282c</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e629282c</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff05050A</color> <!-- PRIMARY DARK -->
 
 
     <!-- PRIMARY LIGHT -->
@@ -52,7 +53,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/Bl4ckAndYell0/res/values/themes.xml b/google/themes/Bl4ckAndYell0/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/Bl4ckAndYell0/res/values/themes.xml
+++ b/google/themes/Bl4ckAndYell0/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/DarknessMeister/res/values/colors.xml b/google/themes/DarknessMeister/res/values/colors.xml
index abfdaea..5a41fbd 100644
--- a/google/themes/DarknessMeister/res/values/colors.xml
+++ b/google/themes/DarknessMeister/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff383f47</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ffadabff</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e6383f47</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff111519</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -51,7 +52,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/DarknessMeister/res/values/themes.xml b/google/themes/DarknessMeister/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/DarknessMeister/res/values/themes.xml
+++ b/google/themes/DarknessMeister/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/FromHell/res/values/colors.xml b/google/themes/FromHell/res/values/colors.xml
index 545aa44..be10849 100644
--- a/google/themes/FromHell/res/values/colors.xml
+++ b/google/themes/FromHell/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff29282c</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff29282c</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e629282c</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff05050A</color> <!-- PRIMARY DARK -->
 
 
     <!-- PRIMARY LIGHT -->
@@ -52,7 +53,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/FromHell/res/values/themes.xml b/google/themes/FromHell/res/values/themes.xml
index 3163b3f..9670076 100644
--- a/google/themes/FromHell/res/values/themes.xml
+++ b/google/themes/FromHell/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/OmniTheme/res/values/colors.xml b/google/themes/OmniTheme/res/values/colors.xml
index c21f104..ae9dbd0 100644
--- a/google/themes/OmniTheme/res/values/colors.xml
+++ b/google/themes/OmniTheme/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff393939</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff52c729</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e6393939</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff191919</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -51,7 +52,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/OmniTheme/res/values/themes.xml b/google/themes/OmniTheme/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/OmniTheme/res/values/themes.xml
+++ b/google/themes/OmniTheme/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/PrimaryAlmostBlack/res/values/colors.xml b/google/themes/PrimaryAlmostBlack/res/values/colors.xml
index 312db6f..16cadc8 100644
--- a/google/themes/PrimaryAlmostBlack/res/values/colors.xml
+++ b/google/themes/PrimaryAlmostBlack/res/values/colors.xml
@@ -12,6 +12,7 @@
     <color name="omni_color6">#B3FFFDE7</color> <!-- WIFI ICON IN DETAILS -->
     <color name="omni_color7">#ff29282c</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color9">#e629282c</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff05050A</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -39,7 +40,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/PrimaryAlmostBlack/res/values/themes.xml b/google/themes/PrimaryAlmostBlack/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/PrimaryAlmostBlack/res/values/themes.xml
+++ b/google/themes/PrimaryAlmostBlack/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/PrimaryBlack/res/values/colors.xml b/google/themes/PrimaryBlack/res/values/colors.xml
index e2383b4..ca6eec1 100644
--- a/google/themes/PrimaryBlack/res/values/colors.xml
+++ b/google/themes/PrimaryBlack/res/values/colors.xml
@@ -39,7 +39,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/PrimaryDarkBlue/res/values/colors.xml b/google/themes/PrimaryDarkBlue/res/values/colors.xml
index fbe6400..6cca57b 100644
--- a/google/themes/PrimaryDarkBlue/res/values/colors.xml
+++ b/google/themes/PrimaryDarkBlue/res/values/colors.xml
@@ -12,6 +12,7 @@
     <color name="omni_color6">#b3fefefe</color> <!-- WIFI ICON IN DETAILS -->
     <color name="omni_color7">#ff182a33</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color9">#e6182a33</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff0d2029</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -39,7 +40,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/PrimaryDarkBlue/res/values/themes.xml b/google/themes/PrimaryDarkBlue/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/PrimaryDarkBlue/res/values/themes.xml
+++ b/google/themes/PrimaryDarkBlue/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/PrimaryOmni/res/values/colors.xml b/google/themes/PrimaryOmni/res/values/colors.xml
index f422a1b..3306de7 100644
--- a/google/themes/PrimaryOmni/res/values/colors.xml
+++ b/google/themes/PrimaryOmni/res/values/colors.xml
@@ -12,6 +12,7 @@
     <color name="omni_color6">#b3fefefe</color> <!-- WIFI ICON IN DETAILS -->
     <color name="omni_color7">#ff393939</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color9">#e6393939</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff191919</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -39,7 +40,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/PrimaryOmni/res/values/themes.xml b/google/themes/PrimaryOmni/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/PrimaryOmni/res/values/themes.xml
+++ b/google/themes/PrimaryOmni/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/SluttyPink/res/values/colors.xml b/google/themes/SluttyPink/res/values/colors.xml
index bcf4efb..91019c5 100644
--- a/google/themes/SluttyPink/res/values/colors.xml
+++ b/google/themes/SluttyPink/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff182a33</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff00ffc5</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e6182a33</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff0d2029</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -51,7 +52,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/SluttyPink/res/values/themes.xml b/google/themes/SluttyPink/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/SluttyPink/res/values/themes.xml
+++ b/google/themes/SluttyPink/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/SmokedGreen/res/values/colors.xml b/google/themes/SmokedGreen/res/values/colors.xml
index 91b59fa..285f520 100644
--- a/google/themes/SmokedGreen/res/values/colors.xml
+++ b/google/themes/SmokedGreen/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff474f47</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff4CAF50</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e6474f47</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff141814</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -51,7 +52,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/SmokedGreen/res/values/themes.xml b/google/themes/SmokedGreen/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/SmokedGreen/res/values/themes.xml
+++ b/google/themes/SmokedGreen/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
diff --git a/google/themes/ZeroZero/res/values/colors.xml b/google/themes/ZeroZero/res/values/colors.xml
index 69cea7f..d62e1a1 100644
--- a/google/themes/ZeroZero/res/values/colors.xml
+++ b/google/themes/ZeroZero/res/values/colors.xml
@@ -19,6 +19,7 @@
     <color name="omni_color7">#ff101010</color> <!-- FLOATING DIALOG COLOR ON VERY DARK THEMES MAKE THIS A BIT LIGHTER -->
     <color name="omni_color8">#ff23aaaf</color> <!-- SPECIAL (CHECK WHERE THIS IS ASSIGNED) -->
     <color name="omni_color9">#e6101010</color> <!-- TOAST (NEEDS SOME ALPHA) -->
+    <color name="omni_color900">#ff000000</color> <!-- PRIMARY DARK -->
 
     <!-- PRIMARY LIGHT -->
     <color name="primary_dark_device_default_settings">@*android:color/omni_color2</color> <!-- Main BG settings -->
@@ -51,7 +52,6 @@
 
 
     <!-- qs -->
-    <color name="material_grey_900">@*android:color/omni_color1</color>  <!-- find a better way to do this -->
     <color name="zen_introduction">@*android:color/omni_color1</color>
 
     <!-- Dialogs -->
diff --git a/google/themes/ZeroZero/res/values/themes.xml b/google/themes/ZeroZero/res/values/themes.xml
index 9f1fc15..e6f496b 100644
--- a/google/themes/ZeroZero/res/values/themes.xml
+++ b/google/themes/ZeroZero/res/values/themes.xml
@@ -341,7 +341,7 @@
     </style>
 
     <style name="qs_base" parent="@*android:style/Theme.DeviceDefault">
-        <item name="android:colorBackgroundFloating">@*android:color/omni_color7</item>
+        <item name="android:colorBackgroundFloating">@*android:color/omni_color900</item>
         <!-- Color palette -->
         <item name="android:colorPrimary">@*android:color/omni_color2</item>
         <item name="android:colorPrimaryDark">@*android:color/omni_color1</item>
