gtk: more manual stuff 4

examples/Cargo.toml

@@ -44,6 +44,10 @@ path = "custom_application/main.rs"
 name = "custom_editable"
 path = "custom_editable/main.rs"
 
+[[bin]]
+name = "custom_entry_buffer"
+path = "custom_entry_buffer/main.rs"
+
 [[bin]]
 name = "custom_layout_manager"
 path = "custom_layout_manager/main.rs"

examples/README.md

@@ -9,6 +9,7 @@ Consists of various examples to get familiar with writing GTK applications using
 - [CSS](./css/)
 - [Custom Application](./custom_application/)
 - [Custom Editable](./custom_editable/)
+- [Custom Entry Buffer](./custom_entry_buffer/)
 - [Custom Layout Manager](./custom_layout_manager/)
 - [Custom Orientable](./custom_orientable/)
 - [Custom Paintable](./custom_paintable/)

examples/custom_entry_buffer/README.md

@@ -0,0 +1,3 @@
+# Custom Entry Buffer
+
+The example shows how to create a custom `gtk::EntryBuffer`. A `gtk::EntryBuffer` can be used to fed a `gtk::Text` for example.

examples/custom_entry_buffer/entry_buffer/imp.rs

@@ -0,0 +1,128 @@
+use glib::{ParamFlags, ParamSpec, Value};
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+use once_cell::sync::Lazy;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+#[derive(Debug)]
+pub struct CustomEntryBuffer {
+    text: Rc<RefCell<String>>,
+    length: Cell<u16>,
+    max_length: Cell<u16>,
+}
+
+impl Default for CustomEntryBuffer {
+    fn default() -> Self {
+        Self {
+            text: Rc::new(RefCell::new(String::new())),
+            length: Cell::new(0),
+            max_length: Cell::new(0),
+        }
+    }
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for CustomEntryBuffer {
+    const NAME: &'static str = "CustomEntryBuffer";
+    type Type = super::CustomEntryBuffer;
+    type ParentType = gtk::EntryBuffer;
+}
+
+impl ObjectImpl for CustomEntryBuffer {
+    fn properties() -> &'static [ParamSpec] {
+        static PROPERTIES: Lazy<Vec<ParamSpec>> = Lazy::new(|| {
+            vec![
+                ParamSpec::new_uint(
+                    "length",
+                    "length",
+                    "Length",
+                    0,
+                    u16::MAX as u32,
+                    0,
+                    ParamFlags::READABLE,
+                ),
+                ParamSpec::new_uint(
+                    "max-length",
+                    "Maximum length",
+                    "Maximum number of characters for this entry",
+                    0,
+                    u16::MAX as u32,
+                    0,
+                    ParamFlags::READWRITE | ParamFlags::EXPLICIT_NOTIFY,
+                ),
+                ParamSpec::new_string(
+                    "text",
+                    "Text",
+                    "The contents of the buffer",
+                    Some(""),
+                    ParamFlags::READWRITE,
+                ),
+            ]
+        });
+        PROPERTIES.as_ref()
+    }
+
+    fn property(&self, _obj: &Self::Type, _id: usize, pspec: &ParamSpec) -> Value {
+        match pspec.name() {
+            "length" => (self.length.get() as u32).to_value(),
+            "max-length" => (self.max_length.get() as u32).to_value(),
+            "text" => self.text.borrow().to_value(),
+            _ => unreachable!(),
+        }
+    }
+
+    fn set_property(&self, _obj: &Self::Type, _id: usize, value: &Value, pspec: &ParamSpec) {
+        match pspec.name() {
+            "length" => {
+                self.length.set(value.get::<u32>().unwrap() as u16);
+            }
+            "max-length" => {
+                self.max_length.set(value.get::<u32>().unwrap() as u16);
+            }
+            "text" => {
+                self.text.replace(value.get().unwrap());
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl EntryBufferImpl for CustomEntryBuffer {
+    fn text(&self, _entry_buffer: &Self::Type) -> glib::GString {
+        self.text.borrow().clone().into()
+    }
+
+    fn length(&self, _entry_buffer: &Self::Type) -> u16 {
+        self.text.borrow().chars().count() as u16
+    }
+
+    fn insert_text(&self, entry_buffer: &Self::Type, _position: u16, chars: &str) -> u16 {
+        self.text.borrow_mut().insert_str(0, chars);
+        let n_chars = chars.chars().count() as u16;
+        let new_length = self.length.get() + n_chars;
+        self.length.set(new_length);
+
+        entry_buffer.notify("text");
+        entry_buffer.notify("length");
+        n_chars
+    }
+
+    fn delete_text(&self, entry_buffer: &Self::Type, position: u16, n_chars: Option<u16>) -> u16 {
+        let deleted_chars = n_chars.unwrap_or(u16::MAX);
+        println!("{}", position);
+        println!("{:#?}", self.text.borrow());
+        let text = self.text.borrow().chars().skip(position as usize).collect();
+        println!("{}", text);
+        self.text.replace(text);
+
+        let length = (self.length.get() - deleted_chars).max(0);
+        self.length.set(length);
+
+        entry_buffer.notify("text");
+        entry_buffer.notify("length");
+
+        deleted_chars
+    }
+}

examples/custom_entry_buffer/entry_buffer/mod.rs

@@ -0,0 +1,19 @@
+mod imp;
+
+use gtk::glib;
+
+glib::wrapper! {
+    pub struct CustomEntryBuffer(ObjectSubclass<imp::CustomEntryBuffer>) @extends gtk::EntryBuffer;
+}
+
+impl Default for CustomEntryBuffer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CustomEntryBuffer {
+    pub fn new() -> Self {
+        glib::Object::new(&[]).expect("Failed to create a CustomEntryBuffer")
+    }
+}

examples/custom_entry_buffer/main.rs

@@ -0,0 +1,41 @@
+mod entry_buffer;
+
+use entry_buffer::CustomEntryBuffer;
+use gtk::prelude::*;
+
+fn main() {
+    let application = gtk::Application::new(
+        Some("com.github.gtk-rs.examples.entry-buffer"),
+        Default::default(),
+    );
+
+    application.connect_activate(build_ui);
+    application.run();
+}
+
+fn build_ui(application: &gtk::Application) {
+    let window = gtk::ApplicationWindow::new(application);
+    window.set_title(Some("Custom Entry Buffer"));
+    window.set_default_size(500, 500);
+
+    let container = gtk::Box::new(gtk::Orientation::Vertical, 12);
+    container.set_valign(gtk::Align::Center);
+    container.set_halign(gtk::Align::Center);
+
+    let buffer = CustomEntryBuffer::new();
+
+    let text1 = gtk::Text::new();
+    text1.set_buffer(&buffer);
+    container.append(&text1);
+
+    let text2 = gtk::Text::new();
+    text2.set_buffer(&buffer);
+    container.append(&text2);
+
+    let entry = gtk::Entry::new();
+    entry.set_buffer(&buffer);
+    container.append(&entry);
+
+    window.set_child(Some(&container));
+    window.show();
+}

gtk4/Gir.toml

@@ -269,7 +269,6 @@ ignore = [
 ]
 
 manual = [
-    # "GObject.ObjectClass",
     # TODO "GLib.Scanner",
     "cairo.Context",
     "cairo.FontOptions",
@@ -961,12 +960,20 @@ manual_traits = ["EntryBufferExtManual"]
     name = "set_text"
     manual = true
     doc_trait_name = "EntryBufferExtManual"
+    [[object.function]]
+    name = "emit_deleted_text"
+    manual = true
+    doc_trait_name = "EntryBufferExtManual"
+    [[object.function]]
+    name = "emit_inserted_text"
+    manual = true
+    doc_trait_name = "EntryBufferExtManual"
     [[object.signal]]
     name = "deleted-text"
-    ignore = true # TODO: implement me
+    ignore = true
     [[object.signal]]
     name = "inserted-text"
-    ignore = true # TODO: implement me
+    ignore = true
 
 [[object]]
 name = "Gtk.EntryCompletion"
@@ -1044,9 +1051,10 @@ final_type = true
 name = "Gtk.FileChooser"
 status = "generate"
 trust_return_value_nullability = false
+manual_traits = ["FileChooserExtManual"]
     [[object.function]]
     name = "add_choice"
-    ignore = true # TODO: strange type of options and option_labels
+    manual = true # handle options_id & options_labels
 
 [[object]]
 name = "Gtk.FileChooserDialog"
@@ -1630,7 +1638,7 @@ trust_return_value_nullability = false
         nullable = false
     [[object.function]]
     name = "set_page_ranges"
-    ignore = true # TODO: implement me
+    manual = true # use &[&PageRange] instead of &[PageRange]
     [[object.function]]
     name = "set_paper_size"
         [[object.function.parameter]]

gtk4/src/auto/entry_buffer.rs

@@ -58,12 +58,6 @@ impl EntryBufferBuilder {
 pub const NONE_ENTRY_BUFFER: Option<&EntryBuffer> = None;
 
 pub trait EntryBufferExt: 'static {
-    #[doc(alias = "gtk_entry_buffer_emit_deleted_text")]
-    fn emit_deleted_text(&self, position: u32, n_chars: u32);
-
-    #[doc(alias = "gtk_entry_buffer_emit_inserted_text")]
-    fn emit_inserted_text(&self, position: u32, chars: &str, n_chars: u32);
-
     #[doc(alias = "length")]
     fn connect_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
 
@@ -75,27 +69,6 @@ pub trait EntryBufferExt: 'static {
 }
 
 impl<O: IsA<EntryBuffer>> EntryBufferExt for O {
-    fn emit_deleted_text(&self, position: u32, n_chars: u32) {
-        unsafe {
-            ffi::gtk_entry_buffer_emit_deleted_text(
-                self.as_ref().to_glib_none().0,
-                position,
-                n_chars,
-            );
-        }
-    }
-
-    fn emit_inserted_text(&self, position: u32, chars: &str, n_chars: u32) {
-        unsafe {
-            ffi::gtk_entry_buffer_emit_inserted_text(
-                self.as_ref().to_glib_none().0,
-                position,
-                chars.to_glib_none().0,
-                n_chars,
-            );
-        }
-    }
-
     #[doc(alias = "length")]
     fn connect_length_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
         unsafe extern "C" fn notify_length_trampoline<P, F: Fn(&P) + 'static>(