This package's functionality is very narrowly to add support for the signal connection features of Glade and GtkBuilder objects in Julia.

This package builds on top of the Julia interface to Gtk.

This package can be installed by use of Julia's in-built package manager as the GtkBuilderAid package. As a result Pkg.add is usually sufficient to install this package:

Pkg.add("GtkBuilderAid")

A simple example that matches up with the shown GUI is displayed below.

function_table = @GtkFunctionTable begin

@guarded function click_ok(
    widget, 
    user_info)
  println("OK clicked!")
  return nothing
end

@guarded function close_window(
    widget,
    window)
  destroy(window)
  return nothing
end

end

quickstart(function_table, "com.github.matt5sean", "main_window", "resources/main.ui", nothing)

All of the functions defined in the block starting with function_table = @GtkFunctionTable are compiled into a Dict mapping the function names to the functions themselves. This dictionary can then be used with various methods to make them accessible as handlers for the builder object.

Note how the handler for click_ok is filled out directly as click_ok to match the code above.

The arguments to the macro preceding the filename and code block generally refine how the macro should behave. The most important of these directives are the user data directives of which there are four. However, user data may also be set within glade using the User data field in the Signals tab of the widget properties.

In cases where the user data is set in glade, the user data type will be converted to the proper GObject type. In the code block above this is demonstrated with the close_window function which will receive a GtkWindow type as its user data argument.

User data may also be bound by modifying the function table.

example_app = GtkApplication("com.github.example", 0)

builder = @GtkFunctionTable begin

@guarded function click_ok(
    widget,
    user_info)
  println("OK clicked!")
  return nothing::Void
end

@guarded function close_window(
    widget,
    window)
  destroy(window)
  return nothing::Void
end

end

@guarded function activateApp(widget, userdata)
  app, builder = userdata
  built = GtkBuilder(filename="$(Pkg.dir("*your_package*"))/resources/main.ui")
  builder(built, (app, ))
  win = Gtk.GAccessor.object(built, "main_window")
  push!(app, win)
  showall(win)
  return nothing
end

signal_connect(activateApp, example_app, :activate, Void, (), false, (example_app, builder))

run(example_app)

There are examples available for examination in this package in the examples directory.

There are a few helper functions added to this package to make certain functionalities easier.

This helper function adds a method to Julia's base quit function that takes a GtkApplication object as its first argument and call the C function g_application_quit on it. This is a very useful function for explicitly stopping a running application.

This is similar to calling Gtk.jl's reveal function but rather than causing the entire widget to be updated only a particular piece of the widget is revealed by this function. The first argument is a GtkWidget while the subsequent arguments are the x coordinate, y coordinate, width, and height of the top-left corner of the rectangular area to update. As an example, reveal_area(w, 5, 10, 50, 60) would update a 50 pixel by 60 pixel rectangle at 5 pixels from the left side of the widget and 10 pixels from the top of the widget.

This helper function creates a CairoSurface based on a realized widget with dimensions matching the widget. The first argument must be the widget for which the surface is created. A second optional argument, which is Cairo.CONTENT_COLOR_ALPHA by default, allows choosing the content type of the Cairo surface.

Some macros at the first layer of the block processed by the @GtkFunctionTable macro are manually expanded during analysis of that block. The expansion will be kept and added to the list of signals in the case that the expanded expression is a function definition. Macros that don't result in function definitions will be left to expand as they would have otherwise. This expansion works well enough for simple macros such as the Gtk wrapper library's @guarded macro but has the potential to cause complications in more complex macros.

Only functions defined at the level of the block within the macro will be converted to C functions and be enabled as signals. This is partly to give a means to define functions that won't be used as functions.

Calling other functions that are defined within the signal handler block will result in an error in effectively every case. Any functionality that needs to be reused in multiple signals should instead be defined outside of the signal handler block. This behaviour will not be changed for future versions.