gtk_print_operation_run Print Dialog is empty under Julia 1.9.3 on OSX

[chriskmanx]

gtk_print_operation_run with PrintOperationAction_PRINT_DIALOG results in print dialog without any printers and without Print to File option. Corresponding event handlers for on_begin_print and on_draw_page are never invoked. The system is OSX Montery. Julia is 1.9.3. I have verified that corresponding operations in the Gtk3 space and the Gtk4 space from C++ behave as expected on the same system. As the API parameters are the same across both the C++ code and the ccall in Julia I am supposing there may be an issue in the libgtk4 build of the Gtk4 Julia package.

[chriskmanx]

Below is a basic program to illustrate the problem:

using Gtk4

win = GtkWindow("Basic Printer Operation", 400, 200)

b = GtkButton("Click Me")

push!(win,b)

function on_begin_print(o,c) # operation, context

    println("begin print called ")
    # Use print compositor to set number of pages... 

end

function on_draw_page(o,c,n,d) # operation, context, pagenum,data
    println("on draw page ")
    # Use compositor to draw page n using operation o and context c
end

function on_button_clicked(w)
    printer_operation = Gtk4.G_.PrintOperation_new()
    Gtk4.G_.set_allow_async(printer_operation,true)  # both async and sync exhibit the error. 

    signal_connect(on_draw_page,printer_operation,"draw-page")
    signal_connect(on_begin_print,printer_operation,"begin-print")

    Gtk4.G_.run(printer_operation,Gtk4.PrintOperationAction_PRINT_DIALOG,win)  
end

signal_connect(on_button_clicked, b, "clicked")

show(win)

This yields an empty Print dialog. The General Tab is empty. No Printer. No Print to File option.

[chriskmanx]

On the same system, below is a basic C++ program which works.

#include 
#include 

static void
begin_print (GtkPrintOperation *operation, GtkPrintContext *context)
{
  // g_assert (editor->buffer);

  // /* Create a print compositor from the buffer */
  // editor->print_compositor = gtk_source_print_compositor_new (editor->buffer);

  // /* Set some formatting options for pages */
  // gtk_source_print_compositor_set_print_header (editor->print_compositor, TRUE);
  // gtk_source_print_compositor_set_print_footer (editor->print_compositor, TRUE);
  // gtk_source_print_compositor_set_header_format (editor->print_compositor, TRUE, NULL, "%N/%Q", NULL);
  // gtk_source_print_compositor_set_footer_format (editor->print_compositor, TRUE, NULL, PACKAGE_URL, NULL);
  // gtk_source_print_compositor_set_left_margin (editor->print_compositor, 15.0, GTK_UNIT_MM);
  // gtk_source_print_compositor_set_right_margin (editor->print_compositor, 15.0, GTK_UNIT_MM);
  // gtk_source_print_compositor_set_bottom_margin (editor->print_compositor, 15.0, GTK_UNIT_MM);

  // /* Pagination */
  // while (!gtk_source_print_compositor_paginate (editor->print_compositor, context));
  // gtk_print_operation_set_n_pages (operation, gtk_source_print_compositor_get_n_pages (editor->print_compositor));
}

static void
draw_page (GtkPrintOperation *operation, GtkPrintContext *context, gint page_nr)
{
  //  gtk_source_print_compositor_draw_page (editor->print_compositor, context, page_nr);
}

static void activate(GtkApplication *app, gpointer user_data)
{
  GtkWidget *window;
  GtkPrintOperationResult res = GTK_PRINT_OPERATION_RESULT_ERROR;
  GError *error = NULL;
  
  window = gtk_application_window_new(app);
  gtk_window_set_title(GTK_WINDOW(window), "GTK Window : Hello World!");
  gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);

  gtk_widget_show(window);

  GtkPrintOperation *print_operation;
  print_operation = gtk_print_operation_new ();

  g_signal_connect (print_operation, "draw_page", G_CALLBACK (draw_page), NULL);
  g_signal_connect (print_operation, "begin_print", G_CALLBACK (begin_print), NULL);

  res = gtk_print_operation_run(print_operation, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(window), &error);

  
}



int main(int argc, char **argv)
{
  GtkApplication *app;
  int status;



  app = gtk_application_new("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);


 
  status = g_application_run(G_APPLICATION(app), argc, argv);

  
  g_object_unref(app);

  return status;
}

Running this with

g++ gtkcpp.cpp -o main `pkg-config --cflags --libs gtk4` && ./main

and linking to libgtk4 from Homebrew works and results in a functional Print dialog.

[chriskmanx]

Julia non working Print Dialog:

[chriskmanx]

C++ Working Dialog

[jwahlstrand]

Thanks for posting the example code -- I had not tried the print dialog before. It also doesn't work on Linux. This is probably an issue with the JLL, but maybe there's something we can do here...

[chriskmanx]

Thank you @jwahlstrand. I tried reaching out on Linked-In as well. Anything I can try, please let me know. And yes, I agree it's probably in the JLL. Would it help to post what dynamic libraries are are pulled in by both binaries? I can do a dump in Activity Monitor to show the DDLs/SOs/DYLIBs. Presumably they will be different in that the Julia version will pull in from the artifacts directories.

[chriskmanx]

I am happy to work with you on putting together a sample app for printing.
I'm writing an editor using gtk source view, so that is what I'm looking to print...

[jwahlstrand]

The print backend modules for GTK get installed in "libdir/gtk-4.0/4.0.0/printbackends". On Fedora, I see 2 backends installed in /usr/lib64/gtk-4.0/4.0.0/printbackends: one for "print to file" and one for CUPS. On Linux the GTK4_jll artifact directory contains just the one for "print to file".

As you also saw, "print to file" isn't offered as an option in the print dialog on Linux. So I think the first issue is, how can we make that appear?

Maybe one of the environmental variables here can point GTK to that directory? https://docs.gtk.org/gtk4/running.html

I have not had any success with that yet. It works! I will submit a PR.

As far as CUPS (and whatever it is on OSX, also CUPS?) is concerned, it looks like it isn't in Yggdrasil, which is a prerequisite for enabling it in GTK4_jll. There was an attempt fairly recently, but it stalled due to an issue building one of its dependencies: JuliaPackaging/Yggdrasil#5004

[jwahlstrand]

I am happy to work with you on putting together a sample app for printing. I'm writing an editor using gtk source view, so that is what I'm looking to print...

I recently started trying to use GtkTextView and realized that it was left in a half-broken state. I have been working on a breaking PR to fix it that I will submit very soon, and will then update GtkSourceView.jl once it's merged.

[chriskmanx]

Yes so I started putting together my own CCALL wrappers to steer around that perhaps. I'm using GtkSourceWidget.jl, but in order to get that to fly - in particular your type constraints, I had to wrap a few functions.

[chriskmanx]

# This is the original undo(instance::GtkTextBuffer...) function from gtk4_methods with the GtkTextBuffer type constraint removed in the instance paramater
function undo_gtksourcebuffer(instance)
    ret = ccall(("gtk_text_buffer_undo", Gtk4.libgtk4), Nothing, (Ptr{Gtk4.GObject},), instance)
    nothing
end

# This is the original delete(instance::GtkTextBuffer...) function from gtk4_methods with the GtkTextBuffer type constraint removed in the instance paramater
function delete_gtksourcebuffer(instance, _start::Union{GtkTextIter, Ref{_GtkTextIter}}, _end::Union{GtkTextIter, Ref{_GtkTextIter}})
    @async ret = ccall(("gtk_text_buffer_delete", Gtk4.libgtk4), Nothing, (Ptr{Gtk4.GObject}, Ptr{_GtkTextIter}, Ptr{_GtkTextIter}), instance, _start, _end)
    nothing
end

# This is the original run(GtkPrintOperation...) function from gtk4_methods with the GtkWindow type constraint removed in the GtkWindow parameter
function run_gtk_print_operation(instance::GtkPrintOperation, _action, _parent)
    @async begin
        _parent_maybe = Gtk4.nothing_to_null(_parent)
        err = Gtk4.err_buf()
        ret = ccall(("gtk_print_operation_run", Gtk4.libgtk4), UInt32, (Ptr{Gtk4.GObject}, UInt32, Ptr{Gtk4.GObject}, Ptr{Ptr{Gtk4.GError}}), instance, _action, _parent_maybe, err)
        Gtk4.check_err(err)
        ret2 = PrintOperationResult(ret)
        ret2
    end
end

[chriskmanx]

I don't know if the above helps, but with these few, I managed to the the GtkSourceView to work, albeit only by pulling it into my project directly - which is clearly a hack.

[chriskmanx]

It also meant bypassing quite a bit of the GtkSourceView functionality and reaching through to the underlying text buffers directly. If you have something I could test, I'd be happy to be the Guinea Pig.

[chriskmanx]

I think the reason the type removals on the CCALLs was needed was because of namespace crossovers. Otherwise the type hierarchy should have sorted out the subtypes as valid ISA's. Just a guess, but I could not get things to work without "Python'izing" the code which as a traditional C++ programmer really galls me :)

[jwahlstrand]

The fix of GtkTextView is in #62 . The issue I was talking about is having to pass in _GtkTextIter to a lot of methods..

What error are you seeing with Gtk4's undo and delete and GtkSourceBuffer? I think that should work. And the parent argument for the other method really should be a GtkWindow or nothing, so it makes no sense to me why removing the type helps. Is there a name collision involving Maybe?

It is very possible that we will want to make a lot of changes to GtkSourceWidget. It is brand new and hasn't been tested much at all -- you are definitely the guinea pig. But I have been happy with how painlessly the GI-generated methods work in most cases and I expected GtkSourceWidget to work without too many ccall's.