diff --git a/src/rust/service_thing.rs b/src/rust/service_thing.rs
index 9a79ac4..c9e7fbb 100644
--- a/src/rust/service_thing.rs
+++ b/src/rust/service_thing.rs
@@ -1,7 +1,5 @@
 #[cxx_qt::bridge]
 mod service_thing {
-    use cxx_qt_lib::QVariantValue;
-
     unsafe extern "C++" {
         include!("cxx-qt-lib/qstring.h");
         type QString = cxx_qt_lib::QString;
@@ -9,75 +7,73 @@ mod service_thing {
         type QVariant = cxx_qt_lib::QVariant;
     }
 
-    #[derive(Clone)]
-    #[cxx_qt::qobject]
-    pub struct ServiceThing {
-        #[qproperty]
-        name: QString,
-        #[qproperty]
-        kind: QString,
-        #[qproperty]
-        background: QString,
-        #[qproperty]
-        background_type: QString,
-        #[qproperty]
-        text: QString,
-        #[qproperty]
-        audio: QString,
-        #[qproperty]
-        font: QString,
-        #[qproperty]
-        font_size: QString,
-        #[qproperty]
-        active: bool,
-        #[qproperty]
-        selected: bool,
-    }
-
-    impl Default for ServiceThing {
-        fn default() -> Self {
-            Self {
-                name: QString::from(""),
-                kind: QString::from(""),
-                background: QString::from(""),
-                background_type: QString::from(""),
-                text: QString::from(""),
-                audio: QString::from(""),
-                font: QString::from(""),
-                font_size: QString::from(""),
-                active: false,
-                selected: false,
-            }
-        }
-    }
-
-    impl qobject::ServiceThing {
-        #[qinvokable]
-        pub fn activate(self: Pin<&mut Self>) {
-            println!("{}", self.active());
-            let active: bool = *self.active();
-            self.set_active(!active);
-            println!("{}", !active);
-        }
+    unsafe extern "RustQt" {
+        #[qobject]
+        #[qml_element]
+        #[qproperty(QString, name)]
+        #[qproperty(QString, kind)]
+        #[qproperty(QString, background)]
+        #[qproperty(QString, background_type)]
+        #[qproperty(QString, text)]
+        #[qproperty(QString, audio)]
+        #[qproperty(QString, font)]
+        #[qproperty(QString, font_size)]
+        #[qproperty(bool, active)]
+        #[qproperty(bool, selected)]
+        type ServiceThing = super::ServiceThingRust;
 
         #[qinvokable]
-        pub fn check_active(self: Pin<&mut Self>) {
-            println!("Are we active?: {}", self.active());
-        }
+        fn activate(self: Pin<&mut ServiceThing>);
 
-        // #[qinvokable]
-        // pub fn slap_variant_around(self: Pin<&mut Self>, variant: &QVariant) {
-        //     println!("wow!");
-        //     let sname: String;
-        //     match variant.value() {
-        //         QVariantValue::QString(string) => {
-        //             let nstr = string.to_string();
-        //             self.set_name(QString::from(nstr.as_str()));
-        //             sname = nstr;
-        //             println!("New name is: {}", sname);
-        //         }
-        //         _ => println!("Unknown QVariant type"),
-        //     };
-        // }
+        #[qinvokable]
+        fn check_active(self: Pin<&mut ServiceThing>);
+    }
+}
+
+use cxx_qt_lib::QString;
+
+#[derive(Clone)]
+pub struct ServiceThingRust {
+    name: QString,
+    kind: QString,
+    background: QString,
+    background_type: QString,
+    text: QString,
+    audio: QString,
+    font: QString,
+    font_size: QString,
+    active: bool,
+    selected: bool,
+}
+
+impl Default for ServiceThingRust {
+    fn default() -> Self {
+        Self {
+            name: QString::from(""),
+            kind: QString::from(""),
+            background: QString::from(""),
+            background_type: QString::from(""),
+            text: QString::from(""),
+            audio: QString::from(""),
+            font: QString::from(""),
+            font_size: QString::from(""),
+            active: false,
+            selected: false,
+        }
+    }
+}
+
+impl qobject::ServiceThing {
+    #[qinvokable]
+    pub fn activate(self: Pin<&mut Self>) {
+        println!("{}", self.active());
+        let active: bool = *self.active();
+        self.set_active(!active);
+        println!("{}", !active);
+    }
+
+    #[qinvokable]
+    pub fn check_active(self: Pin<&mut Self>) {
+        println!("Are we active?: {}", self.active());
     }
 }
diff --git a/src/rust/settings.rs b/src/rust/settings.rs
index 0b5e0ba..d167a6f 100644
--- a/src/rust/settings.rs
+++ b/src/rust/settings.rs
@@ -1,10 +1,5 @@
 #[cxx_qt::bridge]
 mod settings {
-
-    use configparser::ini::Ini;
-    use dirs;
-    use std::path::PathBuf;
-
     unsafe extern "C++" {
         include!("cxx-qt-lib/qstring.h");
         type QString = cxx_qt_lib::QString;
@@ -12,115 +7,125 @@ mod settings {
         type QUrl = cxx_qt_lib::QUrl;
     }
 
-    // In order for settings to save to the ini file,
-    // I'll need to create my own setting functions I think.
-    #[derive(Clone)]
-    #[cxx_qt::qobject]
-    pub struct Settings {
-        config: Ini,
-
-        #[qproperty]
-        screen: QString,
-        #[qproperty]
-        sound_effect: QString,
-        #[qproperty]
-        last_save_file: QUrl,
-        #[qproperty]
-        loaded_file: QUrl,
+    unsafe extern "RustQt" {
+        #[qobject]
+        #[qml_element]
+        #[qproperty(QString, screen)]
+        #[qproperty(QString, sound_effect)]
+        #[qproperty(QUrl, last_save_file)]
+        #[qproperty(QUrl, loaded_file)]
+        type Settings = super::SettingsRust;
     }
+}
 
-    impl Default for Settings {
-        fn default() -> Self {
-            Self {
-                config: Ini::new(),
-                screen: QString::from(""),
-                sound_effect: QString::from(""),
-                last_save_file: QUrl::from(""),
-                loaded_file: QUrl::from(""),
-            }
+use configparser::ini::Ini;
+use dirs;
+use std::path::PathBuf;
+
+// In order for settings to save to the ini file,
+// I'll need to create my own setting functions I think.
+#[derive(Clone)]
+pub struct SettingsRust {
+    config: Ini,
+
+    #[qproperty]
+    screen: QString,
+    #[qproperty]
+    sound_effect: QString,
+    #[qproperty]
+    last_save_file: QUrl,
+    #[qproperty]
+    loaded_file: QUrl,
+}
+
+impl Default for SettingsRust {
+    fn default() -> Self {
+        Self {
+            config: Ini::new(),
+            screen: QString::from(""),
+            sound_effect: QString::from(""),
+            last_save_file: QUrl::from(""),
+            loaded_file: QUrl::from(""),
         }
     }
+}
 
-    impl qobject::Settings {
-        #[qinvokable]
-        pub fn print_sound(self: Pin<&mut Self>) {
-            let mut config = Ini::new();
-            let _map = config.load("~/.config/lumina/lumina.conf");
+impl qobject::Settings {
+    #[qinvokable]
+    pub fn print_sound(self: Pin<&mut Self>) {
+        let mut config = Ini::new();
+        let _map = config.load("~/.config/lumina/lumina.conf");
 
-            println!("{}", self.sound_effect());
-        }
+        println!("{}", self.sound_effect());
+    }
 
-        #[qinvokable]
-        pub fn setup(mut self: Pin<&mut Self>) {
-            let home = dirs::config_dir();
-            println!("{:?}", home);
-            if let Some(mut conf) = home {
-                conf.push("lumina");
-                conf.push("lumina.conf");
-                match self.as_mut().config_mut().load(conf) {
-                    Ok(map) => {
-                        // println!("{:?}", self.rust().config);
-                        let sf = self
-                            .as_ref()
-                            .config()
-                            .get("General", "lastSaveFile");
-                        println!("{:?}", sf);
-                        if let Some(s) = sf {
-                            self.as_mut()
-                                .set_last_save_file(QUrl::from(&s));
-                            self.as_mut()
-                                .set_loaded_file(QUrl::from(&s));
-                            println!("{s}");
-                        } else {
-                            println!("error loading last save file");
-                        }
-                    }
-                    Err(e) => {
-                        println!("settings_load_error: {:?}", e)
-                    }
-                }
-            } else {
-                println!("Couldn't find home directory");
-            }
-        }
-
-        #[qinvokable]
-        pub fn set_save_file(mut self: Pin<&mut Self>, file: QUrl) {
-            println!("{file}");
-            match self.as_mut().config_mut().set(
-                "General",
-                "lastSaveFile",
-                Some(file.to_string()),
-            ) {
-                Some(s) => {
-                    println!(
-                        "set-save-file: {:?}",
+    #[qinvokable]
+    pub fn setup(mut self: Pin<&mut Self>) {
+        let home = dirs::config_dir();
+        println!("{:?}", home);
+        if let Some(mut conf) = home {
+            conf.push("lumina");
+            conf.push("lumina.conf");
+            match self.as_mut().config_mut().load(conf) {
+                Ok(map) => {
+                    // println!("{:?}", self.rust().config);
+                    let sf = self
+                        .as_ref()
+                        .config()
+                        .get("General", "lastSaveFile");
+                    println!("{:?}", sf);
+                    if let Some(s) = sf {
                         self.as_mut()
-                            .config_mut()
-                            .get("General", "lastSaveFile")
-                    );
-                    if let Err(e) = self.as_mut().write() {
-                        println!("error: {:?}", e)
+                            .set_last_save_file(QUrl::from(&s));
+                        self.as_mut().set_loaded_file(QUrl::from(&s));
+                        println!("{s}");
+                    } else {
+                        println!("error loading last save file");
                     }
-                    self.set_last_save_file(file);
                 }
-                _ => println!("error-setting-save-file"),
-            }
-        }
-
-        pub fn write(
-            mut self: Pin<&mut Self>,
-        ) -> std::io::Result<&str> {
-            let mut file = dirs::config_dir().unwrap();
-            file.push("lumina");
-            file.push("lumina.conf");
-            match self.as_mut().config_mut().write(file) {
-                Ok(_s) => Ok("Saved File"),
                 Err(e) => {
-                    println!("error: {:?}", e);
-                    Err(e)
+                    println!("settings_load_error: {:?}", e)
                 }
             }
+        } else {
+            println!("Couldn't find home directory");
+        }
+    }
+
+    #[qinvokable]
+    pub fn set_save_file(mut self: Pin<&mut Self>, file: QUrl) {
+        println!("{file}");
+        match self.as_mut().config_mut().set(
+            "General",
+            "lastSaveFile",
+            Some(file.to_string()),
+        ) {
+            Some(s) => {
+                println!(
+                    "set-save-file: {:?}",
+                    self.as_mut()
+                        .config_mut()
+                        .get("General", "lastSaveFile")
+                );
+                if let Err(e) = self.as_mut().write() {
+                    println!("error: {:?}", e)
+                }
+                self.set_last_save_file(file);
+            }
+            _ => println!("error-setting-save-file"),
+        }
+    }
+
+    pub fn write(mut self: Pin<&mut Self>) -> std::io::Result<&str> {
+        let mut file = dirs::config_dir().unwrap();
+        file.push("lumina");
+        file.push("lumina.conf");
+        match self.as_mut().config_mut().write(file) {
+            Ok(_s) => Ok("Saved File"),
+            Err(e) => {
+                println!("error: {:?}", e);
+                Err(e)
+            }
         }
     }
 }