The AlertDialog class constructor is missing.

[WillyAguilera1977]

The AlertDialog class constructor is missing.
The code in alert_dialog.d (class AlertDialog ) is missing the constructor this() or this(const(char)* format). Therefore, the AlertDialog class cannot be instantiated.

[dejlek]

AlertDialog from where? Adwaita? This one: https://www.kymorphia.com/gid/adw.alert_dialog.AlertDialog.html ?

[dejlek]

To quote EG from recent Discord conversation:

Those dialogs are just for convenience and the only C constructors use C varargs for printf() style messages, which I avoided in the binding, because they are inherently unsafe. Theoretically a D constructor could be added which just takes a string to allow using std.format or whatever to generate the message. Easiest is probably just to create your own Dialog. Having said all that, those 2 classes aren't very useful in the binding at the moment, so something should probably be done to fix that, such as implementing alternative constructors.

I agree, implementing own Dialog is trivial, and you should either do that, or use Adwaita's AlertDialog if it suits you.

[WillyAguilera1977]

It's the AlertDialog from Gtk4

[dejlek]

You can also just use Dialog as it is. See the below example.

Save the demo app to alert_dialog.d, and then you can run it with: dub run --single alert_dialog.d

/+dub.sdl:
    name "gid-gtk4-alert-dialog"
    dependency "gid:gtk4" version="*"
    targetType "executable"
+/

/// Save this to alert_dialog.d
/// Run: dub run --single alert_dialog.d

/// Proper GTK4 Application with a button to open an alert dialog.
/// Run with: dub run --single src/gid/gtk4/alert_dialog.d

module gid.gtk4.alert_dialog;

import gtk.application;
import gtk.application_window;
import gtk.button;
import gtk.dialog;
import gtk.label;
import gtk.box;
import gtk.types : Orientation;
import gio.types : ApplicationFlags;
import gtk.application : Application;

class AlertWindow : ApplicationWindow {
    this(gtk.application.Application app) {
        super(app);
        setTitle("giD + GTK4 Alert Dialog");
        setDefaultSize(320, 120);

        auto box = new Box(Orientation.Vertical, 0);

        auto button = new Button();
        button.setLabel("Show Alert");
        button.setMarginTop(32);
        button.setMarginBottom(32);
        button.setMarginStart(32);
        button.setMarginEnd(32);

        button.connectClicked((Button btn) {
            auto dialog = new Dialog();
            dialog.setTitle("Alert");
            dialog.setTransientFor(this);

            auto content = new Box(Orientation.Vertical, 12);
            content.setMarginTop(12);
            content.setMarginBottom(12);
            content.setMarginStart(24);
            content.setMarginEnd(24);
            auto label = new Label("Hello from giD + GTK4!");
            content.append(label);
            dialog.setChild(content);
            dialog.addButton("OK", 0);
            dialog.present();
        });

        box.append(button);
        setChild(box);
    }
}

class AlertApplication : gtk.application.Application {
    AlertWindow window;

    this() {
        super("org.example.gid-gtk4-alert-dialog", ApplicationFlags.DefaultFlags);
        connectActivate(&onActivate);
    }

    void onActivate(Application app) {
        if (!window)
            window = new AlertWindow(this);
        window.present();
    }
}

void main(string[] args) {
    auto app = new AlertApplication;
    app.run(args);
}

[elementgreen]

AlertDialog does not have any introspectable constructors in the GIR file (introspectable="0"). So that's why gidgen isn't generating a constructor for it. As mentioned in my quote that @dejlek posted. Having said that though, gidgen could create a default constructor in this case, using g_object_new(). That should allow for the "message" to be set afterward with the property or setMessage method. I thought I added code for creating default constructors, but it could be that it wasn't smart enough to consider the case where there are no introspectable ones. Maybe all objects should have default constructors? I wonder if that would cause any problems.. I can't think of any issues off hand.

It would be nice to semi-automate the creation of bindings for printf() varargs methods, as mentioned in #27, but that's a bit more involved. Seems like just allowing a string to be passed in that case, which can use std.format would be just fine, rather than trying to replicate printf() functionality in the method. That's only a convenience in languages without garbage collectors.