docs/reference/gtk/ 0000775 0001750 0001750 00000000000 13640772051 014366 5 ustar mclasen mclasen docs/reference/gtk/version.xml 0000644 0001750 0001750 00000000007 13640771671 016577 0 ustar mclasen mclasen 3.98.2
docs/reference/gtk/getting_started.xml 0000664 0001750 0001750 00000130323 13640771671 020310 0 ustar mclasen mclasen
Getting Started with GTK
GTK is a
widget toolkit . Each user interface created by
GTK consists of widgets. This is implemented in C using
GObject, an object-oriented framework for C.
Widgets are organized in a hierachy. The window widget is the main container.
The user interface is then built by adding buttons, drop-down menus, input
fields, and other widgets to the window.
If you are creating complex user interfaces it is recommended to
use #GtkBuilder and its GTK-specific markup description language, instead of
assembling the interface manually. You can also use a visual user interface
editor, like Glade .
GTK is event-driven. The toolkit listens for events such as
a click on a button, and passes the event to your application.
This chapter contains some tutorial information to get you
started with GTK programming. It assumes that you have GTK, its
dependencies and a C compiler installed and ready to use. If you
need to build GTK itself first, refer to the
Compiling the GTK libraries
section in this reference.
Basics
To begin our introduction to GTK, we'll start with a simple
signal-based Gtk application. This program will create an empty 200 × 200 pixel
window.
Create a new file with the following content named example-0.c.
MISSING XINCLUDE CONTENT
You can compile the program above with GCC using:
gcc `pkg-config --cflags gtk4` -o example-0 example-0.c `pkg-config --libs gtk4`
For more information on how to compile a GTK application, please
refer to the Compiling GTK Applications
section in this reference.
All GTK applications will, of course, include
gtk/gtk.h , which declares functions, types and
macros required by GTK applications.
Even if GTK installs multiple header files, only the
top-level gtk/gtk.h header can be directly included
by third party code. The compiler will abort with an error if any other
header is directly included.
In a GTK application, the purpose of the main() function is to
create a #GtkApplication object and run it. In this example a
#GtkApplication pointer named app is called and then
initialized using gtk_application_new().
When creating a #GtkApplication
you need to pick an application identifier (a name)
and input to gtk_application_new() as parameter.
For this example org.gtk.example is used
but for choosing an identifier for your application see
this guide .
Lastly gtk_application_new() takes a GApplicationFlags as input for your
application, if your application would have special needs.
Next the
activate signal
is connected to the activate() function above the main() functions.
The activate signal will be sent
when your application is launched with
g_application_run() on the line below.
The g_application_run() also takes as arguments the command line arguments counter
and the pointer to string array; this allows GTK to parse specific command line
arguments that control the behavior of GTK itself. The parsed arguments
will be removed from the array, leaving the unrecognized ones for your
application to parse.
Within g_application_run the activate() signal is sent and
we then proceed into the activate () function of the
application. Inside the activate() function we want to construct
our GTK window, so that a window is shown when the application
is launched. The call to gtk_application_window_new() will
create a new #GtkWindow and store it inside the
window pointer. The window will have a frame,
a title bar, and window controls depending on the platform.
A window title is set using gtk_window_set_title(). This function
takes a GtkWindow* pointer and a string as input. As our
window pointer is a GtkWidget pointer, we need to cast it
to GtkWindow*.
But instead of casting window via
(GtkWindow*) ,
window can be cast using the macro
GTK_WINDOW() .
GTK_WINDOW() will check if the
pointer is an instance of the GtkWindow class, before casting, and emit a
warning if the check fails. More information about this convention
can be found
here .
Finally the window size is set using gtk_window_set_default_size and
the window is then shown by GTK via gtk_widget_show().
When you exit the window, by for example pressing the X,
the g_application_run() in the main loop returns with a number
which is saved inside an integer named "status". Afterwards, the
#GtkApplication object is freed from memory with g_object_unref().
Finally the status integer is returned and the GTK application exits.
While the program is running, GTK is receiving
events . These are typically input events caused by
the user interacting with your program, but also things like messages from
the window manager or other applications. GTK processes these and as a
result, signals may be emitted on your widgets.
Connecting handlers for these signals is how you normally make your
program do something in response to user input.
The following example is slightly more complex, and tries to
showcase some of the capabilities of GTK.
In the long tradition of programming languages and libraries,
it is called Hello, World .
Hello World in GTK
Create a new file with the following content named example-1.c.
MISSING XINCLUDE CONTENT
You can compile the program above with GCC using:
gcc `pkg-config --cflags gtk4` -o example-1 example-1.c `pkg-config --libs gtk4`
As seen above, example-1.c builds further upon example-0.c by adding a
button to our window, with the label "Hello World". Two new GtkWidget pointers
are declared to accomplish this, button and
button_box . The button_box variable is created to store a
#GtkBox which is GTK's way of controlling the size and layout of buttons.
The #GtkBox is created and assigned to gtk_box_new() which takes a
#GtkOrientation enum as parameter. The buttons which this box will contain can
either be stored horizontally or vertically but this does not matter in this
particular case as we are dealing with only one button. After initializing
button_box with horizontal orientation, the code adds the button_box widget to the
window widget using gtk_container_add().
Next the button variable is initialized in similar manner.
gtk_button_new_with_label() is called which returns a GtkButton to be stored inside
button . Afterwards button is added to
our button_box .
Using g_signal_connect the button is connected to a function in our app called
print_hello(), so that when the button is clicked, GTK will call this function.
As the print_hello() function does not use any data as input, NULL is passed
to it. print_hello() calls g_print() with the string "Hello World"
which will print Hello World in a terminal if the GTK application was started
from one.
After connecting print_hello(), another signal is connected to the "clicked" state
of the button using g_signal_connect_swapped(). This functions is similar to
a g_signal_connect() with the difference lying in how the callback function is
treated. g_signal_connect_swapped() allow you to specify what the callback
function should take as parameter by letting you pass it as data. In this case
the function being called back is gtk_widget_destroy() and the window
pointer is passed to it. This has the effect that when the button is clicked,
the whole GTK window is destroyed. In contrast if a normal g_signal_connect() were used
to connect the "clicked" signal with gtk_widget_destroy(), then the button
itself would have been destroyed, not the window.
More information about creating buttons can be found
here .
The rest of the code in example-1.c is identical to example-0.c. Next
section will elaborate further on how to add several GtkWidgets to your GTK
application.
Packing
When creating an application, you'll want to put more than one widget
inside a window.
When you want to put more than one widget into a window,
it becomes important to control how each widget is positioned and sized.
This is where packing comes in.
GTK comes with a large variety of layout containers
whose purpose it is to control the layout of the child widgets that are
added to them. See for an overview.
The following example shows how the GtkGrid container lets you
arrange several buttons:
Packing buttons
Create a new file with the following content named example-2.c.
MISSING XINCLUDE CONTENT
You can compile the program above with GCC using:
gcc `pkg-config --cflags gtk4` -o example-2 example-2.c `pkg-config --libs gtk4`
Building user interfaces
When construcing a more complicated user interface, with dozens
or hundreds of widgets, doing all the setup work in C code is
cumbersome, and making changes becomes next to impossible.
Thankfully, GTK supports the separation of user interface
layout from your business logic, by using UI descriptions in an
XML format that can be parsed by the #GtkBuilder class.
Packing buttons with GtkBuilder
Create a new file with the following content named example-3.c.
MISSING XINCLUDE CONTENT
Create a new file with the following content named builder.ui.
MISSING XINCLUDE CONTENT
You can compile the program above with GCC using:
gcc `pkg-config --cflags gtk4` -o example-3 example-3.c `pkg-config --libs gtk4`
Note that GtkBuilder can also be used to construct objects
that are not widgets, such as tree models, adjustments, etc.
That is the reason the method we use here is called
gtk_builder_get_object() and returns a GObject* instead of a
GtkWidget*.
Normally, you would pass a full path to
gtk_builder_add_from_file() to make the execution of your program
independent of the current directory. A common location to install
UI descriptions and similar data is
/usr/share/appname .
It is also possible to embed the UI description in the source
code as a string and use gtk_builder_add_from_string() to load it.
But keeping the UI description in a separate file has several
advantages: It is then possible to make minor adjustments to the UI
without recompiling your program, and, more importantly, graphical
UI editors such as glade
can load the file and allow you to create and modify your UI by
point-and-click.
Building applications
An application consists of a number of files:
The binary
This gets installed in /usr/bin .
A desktop file
The desktop file provides important information about the application to the desktop shell, such as its name, icon, D-Bus name, commandline to launch it, etc. It is installed in /usr/share/applications .
An icon
The icon gets installed in /usr/share/icons/hicolor/48x48/apps , where it will be found regardless of the current theme.
A settings schema
If the application uses GSettings, it will install its schema
in /usr/share/glib-2.0/schemas , so that tools
like dconf-editor can find it.
Other resources
Other files, such as GtkBuilder ui files, are best loaded from
resources stored in the application binary itself. This eliminates the
need for most of the files that would traditionally be installed in
an application-specific location in /usr/share .
GTK includes application support that is built on top of
#GApplication. In this tutorial we'll build a simple application by
starting from scratch, adding more and more pieces over time. Along
the way, we'll learn about #GtkApplication, templates, resources,
application menus, settings, #GtkHeaderBar, #GtkStack, #GtkSearchBar,
#GtkListBox, and more.
The full, buildable sources for these examples can be found
in the examples/ directory of the GTK source distribution, or
online in the GTK git repository.
You can build each example separately by using make with the Makefile.example
file. For more information, see the README included in the
examples directory.
A trivial application
When using #GtkApplication, the main() function can be very
simple. We just call g_application_run() and give it an instance
of our application class.
MISSING XINCLUDE CONTENT
All the application logic is in the application class, which
is a subclass of #GtkApplication. Our example does not yet have any
interesting functionality. All it does is open a window when it is
activated without arguments, and open the files it is given, if it
is started with arguments.
To handle these two cases, we override the activate() vfunc,
which gets called when the application is launched without commandline
arguments, and the open() vfunc, which gets called when the application
is launched with commandline arguments.
To learn more about GApplication entry points, consult the
GIO documentation .
MISSING XINCLUDE CONTENT
Another important class that is part of the application support
in GTK is #GtkApplicationWindow. It is typically subclassed as well.
Our subclass does not do anything yet, so we will just get an empty
window.
MISSING XINCLUDE CONTENT
As part of the initial setup of our application, we also
create an icon and a desktop file.
MISSING XINCLUDE CONTENT
Note that @bindir@ needs to be replaced
with the actual path to the binary before this desktop file can be used.
Here is what we've achieved so far:
This does not look very impressive yet, but our application
is already presenting itself on the session bus, it has single-instance
semantics, and it accepts files as commandline arguments.
Populating the window
In this step, we use a #GtkBuilder template to associate a
#GtkBuilder ui file with our application window class.
Our simple ui file puts a #GtkHeaderBar on top of a #GtkStack
widget. The header bar contains a #GtkStackSwitcher, which is a
standalone widget to show a row of 'tabs' for the pages of a #GtkStack.
MISSING XINCLUDE CONTENT
To make use of this file in our application, we revisit
our #GtkApplicationWindow subclass, and call
gtk_widget_class_set_template_from_resource() from the class init
function to set the ui file as template for this class. We also
add a call to gtk_widget_init_template() in the instance init
function to instantiate the template for each instance of our
class.
(full source )
You may have noticed that we used the _from_resource() variant
of the function that sets a template. Now we need to use GLib's resource functionality
to include the ui file in the binary. This is commonly done by listing
all resources in a .gresource.xml file, such as this:
MISSING XINCLUDE CONTENT
This file has to be converted into a C source file that will be
compiled and linked into the application together with the other source
files. To do so, we use the glib-compile-resources utility:
glib-compile-resources exampleapp.gresource.xml --target=resources.c --generate-source
Our application now looks like this:
Opening files
In this step, we make our application show the content of
all the files that it is given on the commandline.
To this end, we add a member to the struct in application
window subclass and keep a reference to the #GtkStack there.
The first member of the struct should be the parent type from
which the class is derived. Here, ExampleAppWindow is derived
from GtkApplicationWindow.
The gtk_widget_class_bind_template_child() function
arranges things so that after instantiating the template, the
@stack member of the struct will point to the widget of
the same name from the template.
(full source )
Now we revisit the example_app_window_open() function that
is called for each commandline argument, and construct a GtkTextView
that we then add as a page to the stack:
stack), scrolled, basename, basename);
if (g_file_load_contents (file, NULL, &contents, &length, NULL, NULL))
{
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (buffer, contents, length);
g_free (contents);
}
g_free (basename);
}
...
]]>
(full source )
Note that we did not have to touch the stack switcher
at all. It gets all its information from the stack that it
belongs to. Here, we are passing the label to show for each
file as the last argument to the gtk_stack_add_titled()
function.
Our application is beginning to take shape:
An application menu
An application menu is shown by GNOME shell at the top of the
screen. It is meant to collect infrequently used actions that affect
the whole application.
Just like the window template, we specify our application menu
in a ui file, and add it as a resource to our binary.
MISSING XINCLUDE CONTENT
To associate the app menu with the application, we have to call
gtk_application_set_app_menu(). Since app menus work by activating
#GActions, we also have to add a suitable set of actions to our
application.
Both of these tasks are best done in the startup() vfunc,
which is guaranteed to be called once for each primary application
instance:
...
static void
preferences_activated (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
}
static void
quit_activated (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
g_application_quit (G_APPLICATION (app));
}
static GActionEntry app_entries[] =
{
{ "preferences", preferences_activated, NULL, NULL, NULL },
{ "quit", quit_activated, NULL, NULL, NULL }
};
static void
example_app_startup (GApplication *app)
{
GtkBuilder *builder;
GMenuModel *app_menu;
const gchar *quit_accels[2] = { "<Ctrl>Q", NULL };
G_APPLICATION_CLASS (example_app_parent_class)->startup (app);
g_action_map_add_action_entries (G_ACTION_MAP (app),
app_entries, G_N_ELEMENTS (app_entries),
app);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.quit",
quit_accels);
builder = gtk_builder_new_from_resource ("/org/gtk/exampleapp/app-menu.ui");
app_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu"));
gtk_application_set_app_menu (GTK_APPLICATION (app), app_menu);
g_object_unref (builder);
}
static void
example_app_class_init (ExampleAppClass *class)
{
G_APPLICATION_CLASS (class)->startup = example_app_startup;
...
}
...
(full source )
Our preferences menu item does not do anything yet,
but the Quit menu item is fully functional. Note that it
can also be activated by the usual Ctrl-Q shortcut. The
shortcut was added with gtk_application_set_accels_for_action().
The application menu looks like this:
A preference dialog
A typical application will have a some preferences that
should be remembered from one run to the next. Even for our
simple example application, we may want to change the font
that is used for the content.
We are going to use GSettings to store our preferences.
GSettings requires a schema that describes our settings:
MISSING XINCLUDE CONTENT
Before we can make use of this schema in our application,
we need to compile it into the binary form that GSettings
expects. GIO provides macros
to do this in autotools-based projects.
Next, we need to connect our settings to the widgets
that they are supposed to control. One convenient way to do
this is to use GSettings bind functionality to bind settings
keys to object properties, as we do here for the transition
setting.
settings = g_settings_new ("org.gtk.exampleapp");
g_settings_bind (win->settings, "transition",
win->stack, "transition-type",
G_SETTINGS_BIND_DEFAULT);
}
...
]]>
(full source )
The code to connect the font setting is a little more involved,
since there is no simple object property that it corresponds to, so
we are not going to go into that here.
At this point, the application will already react if you
change one of the settings, e.g. using the gsettings commandline
tool. Of course, we expect the application to provide a preference
dialog for these. So lets do that now. Our preference dialog will
be a subclass of GtkDialog, and we'll use the same techniques that
we've already seen: templates, private structs, settings
bindings.
Lets start with the template.
MISSING XINCLUDE CONTENT
Next comes the dialog subclass.
MISSING XINCLUDE CONTENT
Now we revisit the preferences_activated() function in our
application class, and make it open a new preference dialog.
(full source )
After all this work, our application can now show
a preference dialog like this:
Adding a search bar
We continue to flesh out the functionality of our application.
For now, we add search. GTK supports this with #GtkSearchEntry and
#GtkSearchBar. The search bar is a widget that can slide in from the
top to present a search entry.
We add a toggle button to the header bar, which can be used
to slide out the search bar below the header bar.
MISSING XINCLUDE CONTENT
Implementing the search needs quite a few code changes that
we are not going to completely go over here. The central piece of
the search implementation is a signal handler that listens for
text changes in the search entry.
stack));
view = gtk_bin_get_child (GTK_BIN (tab));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
/* Very simple-minded search implementation */
gtk_text_buffer_get_start_iter (buffer, &start);
if (gtk_text_iter_forward_search (&start, text, GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
gtk_text_buffer_select_range (buffer, &match_start, &match_end);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (view), &match_start,
0.0, FALSE, 0.0, 0.0);
}
}
static void
example_app_window_init (ExampleAppWindow *win)
{
...
gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), search_text_changed);
...
}
...
]]>
(full source )
With the search bar, our application now looks like this:
Adding a side bar
As another piece of functionality, we are adding a sidebar,
which demonstrates #GtkMenuButton, #GtkRevealer and #GtkListBox.
MISSING XINCLUDE CONTENT
The code to populate the sidebar with buttons for the words
found in each file is a little too involved to go into here. But we'll
look at the code to add the gears menu.
As expected by now, the gears menu is specified in a GtkBuilder
ui file.
MISSING XINCLUDE CONTENT
To connect the menuitem to the show-words setting, we use
a #GAction corresponding to the given #GSettings key.
gears), menu);
g_object_unref (builder);
action = g_settings_create_action (priv->settings, "show-words");
g_action_map_add_action (G_ACTION_MAP (win), action);
g_object_unref (action);
}
...
]]>
(full source )
What our application looks like now:
Properties
Widgets and other objects have many useful properties.
Here we show some ways to use them in new and flexible ways,
by wrapping them in actions with #GPropertyAction or by binding them
with #GBinding.
To set this up, we add two labels to the header bar in our
window template, named @lines_label and @lines, and bind them to
struct members in the private struct, as we've seen a couple of times
by now.
We add a new "Lines" menu item to the gears menu, which
triggers the show-lines action:
MISSING XINCLUDE CONTENT
To make this menu item do something, we create a property
action for the visible property of the @lines label, and add it to the
actions of the window. The effect of this is that the visibility
of the label gets toggled every time the action is activated.
Since we want both labels to appear and disappear together,
we bind the visible property of the @lines_label widget to the
same property of the @lines widget.
...
static void
example_app_window_init (ExampleAppWindow *win)
{
...
action = (GAction*) g_property_action_new ("show-lines", win->lines, "visible");
g_action_map_add_action (G_ACTION_MAP (win), action);
g_object_unref (action);
g_object_bind_property (win->lines, "visible",
win->lines_label, "visible",
G_BINDING_DEFAULT);
}
...
(full source )
We also need a function that counts the lines of the currently
active tab, and updates the @lines label. See the
full source
if you are interested in the details.
This brings our example application to this appearance:
Header bar
Our application already uses a GtkHeaderBar, but so far it
still gets a 'normal' window titlebar on top of that. This is a
bit redundant, and we will now tell GTK to use the header bar
as replacement for the titlebar. To do so, we move it around to
be a direct child of the window, and set its type to be titlebar.
MISSING XINCLUDE CONTENT
A small extra bonus of using a header bar is that we get
a fallback application menu for free. Here is how the
application now looks, if this fallback is used.
If we set up the window icon for our window, the menu button
will use that instead of the generic placeholder icon you see
here.
Custom Drawing
Many widgets, like buttons, do all their drawing themselves. You
just tell them the label you want to see, and they figure out what font
to use, draw the button outline and focus rectangle, etc. Sometimes, it
is necessary to do some custom drawing. In that case, a #GtkDrawingArea
might be the right widget to use. It offers a canvas on which you can
draw by connecting to the #GtkWidget::draw signal.
The contents of a widget often need to be partially or fully redrawn,
e.g. when another window is moved and uncovers part of the widget, or
when the window containing it is resized. It is also possible to explicitly
cause part or all of the widget to be redrawn, by calling
gtk_widget_queue_draw() or its variants. GTK takes care of most of the
details by providing a ready-to-use cairo context to the ::draw signal
handler.
The following example shows a ::draw signal handler. It is a bit
more complicated than the previous examples, since it also demonstrates
input event handling by means of ::button-press and ::motion-notify
handlers.
Drawing in response to input
Create a new file with the following content named example-4.c.
MISSING XINCLUDE CONTENT
You can compile the program above with GCC using:
gcc `pkg-config --cflags gtk4` -o example-4 example-4.c `pkg-config --libs gtk4`
docs/reference/gtk/gtk4.types 0000664 0001750 0001750 00000013022 13640771671 016332 0 ustar mclasen mclasen #include
#include
gtk_about_dialog_get_type
gtk_accel_label_get_type
gtk_accessible_get_type
gtk_actionable_get_type
gtk_action_bar_get_type
gtk_adjustment_get_type
gtk_app_chooser_get_type
gtk_app_chooser_button_get_type
gtk_app_chooser_dialog_get_type
gtk_app_chooser_widget_get_type
gtk_application_get_type
gtk_application_window_get_type
gtk_aspect_frame_get_type
gtk_assistant_get_type
gtk_assistant_page_get_type
gtk_bin_get_type
gtk_bin_layout_get_type
gtk_box_get_type
gtk_box_layout_get_type
gtk_builder_cscope_get_type
gtk_builder_get_type
gtk_builder_scope_get_type
gtk_buildable_get_type
gtk_button_get_type
gtk_calendar_get_type
gtk_cell_area_get_type
gtk_cell_area_box_get_type
gtk_cell_area_context_get_type
gtk_cell_editable_get_type
gtk_cell_layout_get_type
gtk_cell_renderer_accel_get_type
gtk_cell_renderer_combo_get_type
gtk_cell_renderer_get_type
gtk_cell_renderer_pixbuf_get_type
gtk_cell_renderer_progress_get_type
gtk_cell_renderer_spin_get_type
gtk_cell_renderer_spinner_get_type
gtk_cell_renderer_text_get_type
gtk_cell_renderer_toggle_get_type
gtk_cell_view_get_type
gtk_check_button_get_type
gtk_color_button_get_type
gtk_color_chooser_get_type
gtk_color_chooser_dialog_get_type
gtk_color_chooser_widget_get_type
gtk_combo_box_get_type
gtk_combo_box_text_get_type
gtk_constraint_get_type
gtk_constraint_guide_get_type
gtk_constraint_layout_get_type
gtk_constraint_target_get_type
gtk_container_get_type
gtk_css_provider_get_type
gtk_dialog_get_type
gtk_drag_icon_get_type
gtk_drag_source_get_type
gtk_drawing_area_get_type
gtk_drop_target_get_type
gtk_editable_get_type
gtk_emoji_chooser_get_type
gtk_entry_buffer_get_type
gtk_entry_completion_get_type
gtk_entry_get_type
gtk_event_controller_get_type
gtk_event_controller_key_get_type
gtk_event_controller_focus_get_type
gtk_event_controller_legacy_get_type
gtk_event_controller_motion_get_type
gtk_event_controller_scroll_get_type
gtk_expander_get_type
gtk_file_chooser_button_get_type
gtk_file_chooser_dialog_get_type
gtk_file_chooser_get_type
gtk_file_chooser_widget_get_type
gtk_file_filter_get_type
gtk_filter_list_model_get_type
gtk_fixed_get_type
gtk_fixed_layout_get_type
gtk_flatten_list_model_get_type
gtk_flow_box_get_type
gtk_flow_box_child_get_type
gtk_font_button_get_type
gtk_font_chooser_get_type
gtk_font_chooser_dialog_get_type
gtk_font_chooser_widget_get_type
gtk_frame_get_type
gtk_gesture_get_type
gtk_gesture_click_get_type
gtk_gesture_drag_get_type
gtk_gesture_long_press_get_type
gtk_gesture_pan_get_type
gtk_gesture_rotate_get_type
gtk_gesture_single_get_type
gtk_gesture_stylus_get_type
gtk_gesture_swipe_get_type
gtk_gesture_zoom_get_type
gtk_gl_area_get_type
gtk_grid_get_type
gtk_grid_layout_child_get_type
gtk_grid_layout_get_type
gtk_header_bar_get_type
gtk_icon_theme_get_type
gtk_icon_view_get_type
gtk_image_get_type
gtk_im_context_get_type
gtk_im_context_simple_get_type
gtk_im_multicontext_get_type
gtk_info_bar_get_type
gtk_label_get_type
gtk_layout_child_get_type
gtk_layout_manager_get_type
gtk_link_button_get_type
gtk_list_store_get_type
gtk_list_box_get_type
gtk_list_box_row_get_type
gtk_lock_button_get_type
gtk_map_list_model_get_type
gtk_media_controls_get_type
gtk_media_file_get_type
gtk_media_stream_get_type
gtk_menu_button_get_type
gtk_message_dialog_get_type
gtk_mount_operation_get_type
gtk_native_get_type
gtk_no_selection_get_type
gtk_notebook_get_type
gtk_notebook_page_get_type
gtk_orientable_get_type
gtk_overlay_get_type
gtk_pad_controller_get_type
gtk_page_setup_get_type
gtk_page_setup_unix_dialog_get_type
gtk_paned_get_type
gtk_paper_size_get_type
gtk_password_entry_get_type
gtk_picture_get_type
gtk_popover_get_type
gtk_popover_menu_get_type
gtk_popover_menu_bar_get_type
gtk_printer_get_type
gtk_print_context_get_type
gtk_print_job_get_type
gtk_print_operation_get_type
gtk_print_operation_preview_get_type
gtk_print_settings_get_type
gtk_print_unix_dialog_get_type
gtk_progress_bar_get_type
gtk_radio_button_get_type
gtk_range_get_type
gtk_recent_manager_get_type
gtk_revealer_get_type
gtk_root_get_type
gtk_scale_button_get_type
gtk_scale_get_type
gtk_scrollable_get_type
gtk_scrollbar_get_type
gtk_scrolled_window_get_type
gtk_search_bar_get_type
gtk_search_entry_get_type
gtk_selection_model_get_type
gtk_separator_get_type
gtk_settings_get_type
gtk_shortcut_get_type
gtk_shortcut_controller_get_type
gtk_shortcut_label_get_type
gtk_shortcut_manager_get_type
gtk_shortcuts_window_get_type
gtk_shortcuts_section_get_type
gtk_shortcuts_group_get_type
gtk_shortcuts_shortcut_get_type
gtk_single_selection_get_type
gtk_size_group_get_type
gtk_slice_list_model_get_type
gtk_snapshot_get_type
gtk_sort_list_model_get_type
gtk_spin_button_get_type
gtk_spinner_get_type
gtk_stack_get_type
gtk_stack_page_get_type
gtk_stack_sidebar_get_type
gtk_stack_switcher_get_type
gtk_statusbar_get_type
gtk_switch_get_type
gtk_level_bar_get_type
gtk_style_context_get_type
gtk_style_provider_get_type
gtk_text_buffer_get_type
gtk_text_child_anchor_get_type
gtk_text_get_type
gtk_text_iter_get_type
gtk_text_mark_get_type
gtk_text_tag_get_type
gtk_text_tag_table_get_type
gtk_text_view_get_type
gtk_toggle_button_get_type
gtk_tree_drag_dest_get_type
gtk_tree_drag_source_get_type
gtk_tree_list_model_get_type
gtk_tree_list_row_get_type
gtk_tree_model_filter_get_type
gtk_tree_model_get_type
gtk_tree_model_sort_get_type
gtk_tree_selection_get_type
gtk_tree_sortable_get_type
gtk_tree_store_get_type
gtk_tree_view_column_get_type
gtk_tree_view_get_type
gtk_video_get_type
gtk_viewport_get_type
gtk_volume_button_get_type
gtk_widget_get_type
gtk_window_get_type
gtk_window_group_get_type
docs/reference/gtk/actions.xml 0000664 0001750 0001750 00000033463 13640771677 016576 0 ustar mclasen mclasen
The GTK Action Model
3
GTK Library
The GTK Action Model
How actions are used in GTK
Overview of actions in GTK
This chapter describes in detail how GTK uses actions to connect
activatable UI elements to callbacks. GTK inherits the underlying
architecture of GAction and GMenu for describing abstract actions
and menus from the GIO library.
Basics about actions
A GAction is essentially a way to tell the toolkit about a
piece of functionality in your program, and to give it a name.
Actions are purely functional. They do not contain any
presentational information.
An action has four pieces of information associated with it:
a name as an identifier (usually all-lowercase, untranslated
English string)
an enabled flag indicating if the action can be activated or
not (like the "sensitive" property on widgets)
an optional state value, for stateful actions (like a boolean
for toggles)
an optional parameter type, used when activating the action
An action supports two operations. You can activate it, which
requires passing a parameter of the correct type
And you can request to change the actions state (for stateful
actions) to a new state value of the correct type.
Here are some rules about an action:
the name is immutable (in the sense that it will never
change) and it is never %NULL
the enabled flag can change
the parameter type is immutable
the parameter type is optional: it can be %NULL
if the parameter type is %NULL then action activation must
be done without a parameter (ie: a %NULL GVariant pointer)
if the parameter type is non-%NULL then the parameter must
have this type
the state can change, but it cannot change type
if the action was stateful when it was created, it will
always have a state and it will always have exactly the same
type (such as boolean or string)
if the action was stateless when it was created, it can never
have a state
you can only request state changes on stateful actions and it
is only possible to request that the state change to a value
of the same type as the existing state
An action does not have any sort of presentational information
such as a label, an icon or a way of creating a widget from it.
Action state and parameters
Most actions in your application will be stateless actions with
no parameters. These typically appear as menu items with no
special decoration. An example is "quit".
Stateful actions are used to represent an action which has a
closely-associated state of some kind. A good example is a
"fullscreen" action. For this case, you'd expect to see a
checkmark next to the menu item when the fullscreen option
is active. This is usually called a toggle action, and it has
a boolean state. By convention, toggle actions have no parameter
type for activation: activating the action always toggles the
state.
Another common case is to have an action representing a
enumeration of possible values of a given type (typically
string). This is often called a radio action and is usually
represented in the user interface with radio buttons or radio
menu items, or sometimes a combobox. A good example is
"text-justify" with possible values "left", "center", and
"right". By convention, these types of actions have a parameter
type equal to their state type, and activating them with a
particular parameter value is equivalent to changing their
state to that value.
This approach to handling radio buttons is different than many
other action systems such as GtkAction. With GAction, there is
only one action for "text-justify" and "left", "center" and
"right" are possible states on that action. There are not three
separate "justify-left", "justify-center" and "justify-right"
actions.
The final common type of action is a stateless action with a
parameter. This is typically used for actions like
"open-bookmark" where the parameter to the action would be
the identifier of the bookmark to open.
Because some types of actions cannot be invoked without a
parameter, it is often important to specify a parameter when
referring to the action from a place where it will be invoked
(such as from a radio button that sets the state to a particular
value or from a menu item that opens a specific bookmark). In
these contexts, the value used for the action parameter is
typically called the target of the action.
Even though toggle actions have a state, they do not have a
parameter. Therefore, a target value is not needed when
referring to them — they will always be toggled on activation.
Most APIs that allow using a GAction (such as GMenuModel and
GtkActionable) allow use of detailed action names. This is a
convenient way of specifying an action name and an action target
with a single string.
In the case that the action target is a string with no unusual
characters (ie: only alpha-numeric, plus '-' and '.') then you
can use a detailed action name of the form "justify::left" to
specify the justify action with a target of left.
In the case that the action target is not a string, or contains
unusual characters, you can use the more general format
"action-name(5)", where the "5" here is any valid text-format
GVariant (ie: a string that can be parsed by g_variant_parse()).
Another example is "open-bookmark('http://gnome.org/')".
You can convert between detailed action names and split-out
action names and target values using g_action_parse_detailed_action_name()
and g_action_print_detailed_action_name() but usually you will
not need to. Most APIs will provide both ways of specifying
actions with targets.
Action scopes
Actions are always scoped to a particular object on which they
operate.
In GTK, actions are typically scoped to either an application
or a window, but any widget can have actions associated with it.
Actions scoped to windows should be the actions that
specifically impact that window. These are actions like
"fullscreen" and "close", or in the case that a window contains
a document, "save" and "print".
Actions that impact the application as a whole rather than one
specific window are scoped to the application. These are actions
like "about" and "preferences".
If a particular action is scoped to a window then it is scoped
to a specific window. Another way of saying this: if your
application has a "fullscreen" action that applies to windows
and it has three windows, then it will have three fullscreen
actions: one for each window.
Having a separate action per-window allows for each window to
have a separate state for each instance of the action as well
as being able to control the enabled state of the action on a
per-window basis.
Actions are added to their relevant scope (application,
window or widget) either using the GActionMap interface,
or by using gtk_widget_insert_action_group(). Actions that
will be the same for all instances of a widget class can
be added globally using gtk_widget_class_install_action().
Action groups and action maps
Actions rarely occurs in isolation. It is common to have groups
of related actions, which are represented by instances of the
GActionGroup interface.
Action maps are a variant of action groups that allow to change
the name of the action as it is looked up. In GTK, the convention
is to add a prefix to the action name to indicate the scope of
the actions, such as "app." for the actions with application scope
or "win." for those with window scope.
When referring to actions on a GActionMap only the name of the
action itself is used (ie: "quit", not "app.quit"). The
"app.quit" form is only used when referring to actions from
places like a GMenu or GtkActionable widget where the scope
of the action is not already known.
GtkApplication and GtkApplicationWindow implement the GActionMap
interface, so you can just add actions directly to them. For
other widgets, use gtk_widget_insert_action_group() to add
actions to it.
If you want to insert several actions at the same time, it is
typically faster and easier to use GActionEntry.
Connecting actions to widgets
Any widget that implements the GtkActionable interface can
be connected to an action just by setting the ::action-name
property. If the action has a parameter, you will also need
to set the ::action-target property.
Widgets that implement GtkActionable include GtkSwitch, GtkButton,
and their respective subclasses.
Another way of obtaining widgets that are connected to actions
is to create a menu using a GMenu menu model. GMenu provides an
abstract way to describe typical menus: nested groups of items
where each item can have a label, and icon, and an action.
Typical uses of GMenu inside GTK are to set up an application
menu or menubar with gtk_application_set_app_menu() or
gtk_application_set_menubar(). Another, maybe more common use
is to create a popover for a menubutton, using
gtk_menu_button_set_menu_model().
Unlike traditional menus, those created from menu models don't
have keyboard accelerators associated with menu items. Instead,
GtkApplication offers the gtk_application_set_accels_for_action()
API to associate keyboard shortcuts with actions.
Activation
When a widget with a connected action is activated, GTK finds
the action to activate by walking up the widget hierarchy,
looking for a matching action, ending up at the GtkApplication.
Built-in Actions
GTK uses actions for its own purposes in a number places. These
built-in actions can sometimes be activated by applications, and
you should avoid naming conflicts with them when creating your
own actions.
default.activate
Activates the default widget in a context
(typically a GtkWindow, GtkDialog or GtkPopover)
clipboard.cut, clipboard.copy, clipboard.paste
Clipboard operations on entries, text view
and labels, typically used in the context menu
selection.delete, selection.select-all
Selection operations on entries, text view
and labels
color.select, color.customize
Operations on colors in GtkColorChooserWidget.
These actions are unusual in that they have the non-trivial
parameter type (dddd).
docs/reference/gtk/broadway.xml 0000664 0001750 0001750 00000004140 13640771677 016734 0 ustar mclasen mclasen
Using GTK with Broadway
3
GTK Library
Using GTK with Broadway
HTML-specific aspects of using GTK
Using GTK with Broadway
The GDK Broadway backend provides support for displaying GTK
applications in a web browser, using HTML5 and web sockets. To run
your application in this way, select the Broadway backend by setting
GDK_BACKEND=broadway . Then you can make
your application appear in a web browser by pointing it at
http://127.0.0.1:8080 . Note that you need
to enable web sockets in your web browser.
You can choose a different port from the default 8080 by setting
the BROADWAY_DISPLAY environment variable to the
port that you want to use.
It is also possible to use multiple GTK applications in the same
web browser window, by using the Broadway server,
broadwayd , that ships with GTK.
To use broadwayd, start it like this:
broadwayd :5
Then point your web browser at http://127.0.0.1:8085 .
Start your applications like this:
GDK_BACKEND=broadway BROADWAY_DISPLAY=:5 gtk4-demo
Broadway-specific environment variables
BROADWAY_DISPLAY
Specifies the Broadway display number. The default display is 0.
The display number determines the port to use when connecting
to a Broadway application via the following formula:
port = 8080 + display
docs/reference/gtk/building.xml 0000664 0001750 0001750 00000050157 13640771677 016732 0 ustar mclasen mclasen
Compiling the GTK libraries
3
GTK Library
Compiling the GTK Libraries
How to compile GTK itself
Building GTK
Before we get into the details of how to compile GTK, we should
mention that in many cases, binary packages of GTK prebuilt for
your operating system will be available, either from your
operating system vendor or from independent sources. If such a
set of packages is available, installing it will get you
programming with GTK much faster than building it yourself. In
fact, you may well already have GTK installed on your system
already.
In order to build GTK, you will need meson
installed on your system. On Linux, and other UNIX-like operating
systems, you will also need ninja . This
guide does not cover how to install these two requirements, but you
can refer to the Meson website
for more information. The Ninja
build tool is also usable on various operating systems, so we will
refer to it in the examples.
If you are building GTK from a source distribution or from a Git
clone, you will need to use meson to
configure the project. The most commonly useful argument is the
--prefix one, which determines where the
files will go once installed. To install GTK under a prefix
like /opt/gtk you would run Meson as:
meson --prefix /opt/gtk builddir
Meson will create the builddir directory and
place all the build artefacts there.
You can get a list of all available options for the build by
running meson configure .
After Meson successfully configured the build directory, you then
can run the build, using Ninja:
cd builddir
ninja
ninja install
If you don't have permission to write to the directory you are
installing in, you may have to change to root temporarily before
running ninja install .
Several environment variables are useful to pass to set before
running meson . CPPFLAGS
contains options to pass to the C compiler, and is used to tell
the compiler where to look for include files. The LDFLAGS
variable is used in a similar fashion for the linker. Finally the
PKG_CONFIG_PATH environment variable contains
a search path that pkg-config (see below)
uses when looking for files describing how to compile
programs using different libraries. If you were installing GTK
and it's dependencies into /opt/gtk , you
might want to set these variables as:
CPPFLAGS="-I/opt/gtk/include"
LDFLAGS="-L/opt/gtk/lib"
PKG_CONFIG_PATH="/opt/gtk/lib/pkgconfig"
export CPPFLAGS LDFLAGS PKG_CONFIG_PATH
You may also need to set the LD_LIBRARY_PATH
environment variable so the systems dynamic linker can find
the newly installed libraries, and the PATH
environment program so that utility binaries installed by
the various libraries will be found.
LD_LIBRARY_PATH="/opt/gtk/lib"
PATH="/opt/gtk/bin:$PATH"
export LD_LIBRARY_PATH PATH
Build types
Meson has different build types, exposed by the buildtype
configuration option. GTK enables and disables functionality depending on
the build type used when calling meson to
configure the build.
debug and debugoptimized
GTK will enable debugging code paths in both the
debug and debugoptimized
build types. Builds with buildtype set
to debug will additionally enable
consistency checks on the internal state of the toolkit.
It is recommended to use the debug or
debugoptimized build types when developing
GTK itself. Additionally, debug builds of
GTK are recommended for profiling and debugging GTK applications,
as they include additional validation of the internal state.
The debugoptimized build type is the
default for GTK if no build type is specified when calling
meson
release
The release build type will disable
debugging code paths and additional run time safeties, like
checked casts for object instances.
The plain build type provided by Meson
should only be used when packaging GTK, and it's expected
that packagers will provide their own compiler flags when
building GTK. See the previous section for the list of
environment variables to be used to define compiler and
linker flags.
Dependencies
Before you can compile the GTK widget toolkit, you need to have
various other tools and libraries installed on your
system. Dependencies of GTK have their own build systems, so
you will need to refer to their own installation instructions.
A particular important tool used by GTK to find its dependencies
is pkg-config .
pkg-config
is a tool for tracking the compilation flags needed for
libraries that are used by the GTK libraries. (For each
library, a small .pc text file is installed
in a standard location that contains the compilation flags
needed for that library along with version number information.)
Some of the libraries that GTK depends on are maintained by
by the GTK team: GLib, GdkPixbuf, Pango, ATK and GObject Introspection.
Other libraries are maintained separately.
The GLib library provides core non-graphical functionality
such as high level data types, Unicode manipulation, and
an object and type system to C programs. It is available
from here .
The GdkPixbuf library
provides facilities for loading images in a variety of file formats.
It is available here .
Pango is a library
for internationalized text handling. It is available
here .
ATK is the Accessibility Toolkit. It provides a set of generic
interfaces allowing accessibility technologies such as
screen readers to interact with a graphical user interface.
It is available
here .
Gobject Introspection
is a framework for making introspection data available to
language bindings. It is available
here .
External dependencies
The GNU
libiconv library is needed to build GLib if your
system doesn't have the iconv()
function for doing conversion between character
encodings. Most modern systems should have
iconv() .
The libintl library from the GNU gettext
package is needed if your system doesn't have the
gettext() functionality for handling
message translation databases.
The libraries from the X window system are needed to build
Pango and GTK. You should already have these installed on
your system, but it's possible that you'll need to install
the development environment for these libraries that your
operating system vendor provides.
The fontconfig
library provides Pango with a standard way of locating
fonts and matching them against font names.
Cairo
is a graphics library that supports vector graphics and image
compositing. Both Pango and GTK use Cairo for drawing.
libepoxy
is a library that abstracts the differences between different
OpenGL libraries. GTK uses it for cross-platform GL support
and for its own drawing.
Graphene
is a library that provides vector and matrix types for 2D and
3D transformations. GTK uses it internally for drawing.
The Wayland libraries
are needed to build GTK with the Wayland backend.
The shared-mime-info
package is not a hard dependency of GTK, but it contains definitions
for mime types that are used by GIO and, indirectly, by GTK.
gdk-pixbuf will use GIO for mime type detection if possible. For this
to work, shared-mime-info needs to be installed and
XDG_DATA_DIRS set accordingly at configure time.
Otherwise, gdk-pixbuf falls back to its built-in mime type detection.
Building and testing GTK
First make sure that you have the necessary external
dependencies installed: pkg-config , Meson, Ninja,
the JPEG, PNG, and TIFF libraries, FreeType, and, if necessary,
libiconv and libintl. To get detailed information about building
these packages, see the documentation provided with the
individual packages. On any average Linux system, it's quite likely
you'll have all of these installed already, or they will be easily
accessible through your operating system package repositories.
Then build and install the GTK libraries in the order:
GLib, Cairo, Pango, ATK, then GTK. For each library, follow the
instructions they provide, and make sure to share common settings
between them and the GTK build; if you are using a separate prefix
for GTK, for instance, you will need to use the same prefix for all
its dependencies you build. If you're lucky, this will all go smoothly,
and you'll be ready to start compiling
your own GTK applications. You can test your GTK installation
by running the gtk4-demo program that
GTK installs.
If one of the projects you're configuring or building fails, look
closely at the error messages printed; these will often provide useful
information as to what went wrong. Every build system has its own
log that can help you understand the issue you're encountering. If all
else fails, you can ask for help on the gtk-list mailing list.
See for more information.
docs/reference/gtk/compiling.xml 0000664 0001750 0001750 00000007025 13640771677 017112 0 ustar mclasen mclasen
Compiling GTK Applications
3
GTK Library
Compiling GTK Applications
How to compile your GTK application
Compiling GTK Applications on UNIX
To compile a GTK application, you need to tell the compiler where to
find the GTK header files and libraries. This is done with the
pkg-config utility.
The following interactive shell session demonstrates how
pkg-config is used (the actual output on
your system may be different):
$ pkg-config --cflags gtk4
-pthread -I/usr/include/gtk-4.0 -I/usr/lib64/gtk-4.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pango-1.0 -I/usr/include/glib-2.0 -I/usr/lib64/glib-2.0/include -I/usr/include/pixman-1 -I/usr/include/freetype2 -I/usr/include/libpng12
$ pkg-config --libs gtk4
-pthread -lgtk-4 -lgdk-4 -latk-1.0 -lgio-2.0 -lpangoft2-1.0 -lgdk_pixbuf-2.0 -lpangocairo-1.0 -lcairo -lpango-1.0 -lfreetype -lfontconfig -lgobject-2.0 -lgmodule-2.0 -lgthread-2.0 -lrt -lglib-2.0
The simplest way to compile a program is to use the "backticks"
feature of the shell. If you enclose a command in backticks
(not single quotes ), then its output will be
substituted into the command line before execution. So to compile
a GTK Hello, World, you would type the following:
$ cc `pkg-config --cflags gtk4` hello.c -o hello `pkg-config --libs gtk4`
Deprecated GTK functions are annotated to make the compiler
emit warnings when they are used (e.g. with gcc, you need to use
the -Wdeprecated-declarations option). If these warnings are
problematic, they can be turned off by defining the preprocessor
symbol %GDK_DISABLE_DEPRECATION_WARNINGS by using the commandline
option -DGDK_DISABLE_DEPRECATION_WARNINGS
GTK deprecation annotations are versioned; by defining the
macros %GDK_VERSION_MIN_REQUIRED and %GDK_VERSION_MAX_ALLOWED,
you can specify the range of GTK versions whose API you want
to use. APIs that were deprecated before or introduced after
this range will trigger compiler warnings.
Here is how you would compile hello.c if you want to allow it
to use symbols that were not deprecated in 4.2:
$ cc `pkg-config --cflags gtk4` -DGDK_VERSION_MIN_REQIRED=GDK_VERSION_4_2 hello.c -o hello `pkg-config --libs gtk4`
And here is how you would compile hello.c if you don't want
it to use any symbols that were introduced after 4.2:
$ cc `pkg-config --cflags gtk4` -DGDK_VERSION_MAX_ALLOWED=GDK_VERSION_4_2 hello.c -o hello `pkg-config --libs gtk4`
The older deprecation mechanism of hiding deprecated interfaces
entirely from the compiler by using the preprocessor symbol
GTK_DISABLE_DEPRECATED is still used for deprecated macros,
enumeration values, etc. To detect uses of these in your code,
use the commandline option -DGTK_DISABLE_DEPRECATED .
There are similar symbols GDK_DISABLE_DEPRECATED,
GDK_PIXBUF_DISABLE_DEPRECATED and G_DISABLE_DEPRECATED for GDK, GdkPixbuf and
GLib.
docs/reference/gtk/css-overview.xml 0000664 0001750 0001750 00000077035 13640771677 017575 0 ustar mclasen mclasen
GTK CSS Overview
3
GTK Library
GTK CSS Overview
Overview of CSS in GTK
Overview of CSS in GTK
This chapter describes in detail how GTK uses CSS for styling
and layout.
We loosely follow the CSS
value definition
specification in the formatting of syntax productions.
Nonterminals are enclosed in angle backets (〈〉), all other strings that are not listed here are literals
Juxtaposition means all components must occur, in the given order
A double ampersand (&&) means all components must occur, in any order
A double bar (||) means one or more of the components must occur, in any order
A single bar (|) indicates an alternative; exactly one of the components must occur
Brackets ([]) are used for grouping
A question mark (?) means that the preceding component is optional
An asterisk (*) means zero or more copies of the preceding component
A plus (+) means one or more copies of the preceding component
A number in curly braces ({n}) means that the preceding component occurs exactly n times
Two numbers in curly braces ({m,n}) mean that the preceding component occurs at least m times and at most n times
CSS nodes
GTK applies the style information found in style sheets by matching
the selectors against a tree of nodes. Each node in the tree has a
name, a state and possibly style classes. The children of each node
are linearly ordered.
Every widget has one or more of these CSS nodes, and determines their
name, state, style classes and how they are layed out as children and
siblings in the overall node tree. The documentation for each widget
explains what CSS nodes it has.
The CSS nodes of a GtkScale
Style sheets
The basic structure of the style sheets understood by GTK is
a series of statements, which are either rule sets or “@-rules”,
separated by whitespace.
A rule set consists of a selector and a declaration block, which is
a series of declarations enclosed in curly braces. The declarations
are separated by semicolons. Multiple selectors can share the same
declaration block, by putting all the separators in front of the block,
separated by commas.
A rule set with two selectors
Importing style sheets
GTK supports the CSS @import rule, in order to load another
style sheet in addition to the currently parsed one.
The syntax for @import rules is as follows:
〈import rule〉 = @import [ 〈url〉 | 〈string〉 ]
〈url〉 = url( 〈string〉 )
An example for using the @import rule
To learn more about the @import rule, you can read the
Cascading
module of the CSS specification.
Selectors
Selectors work very similar to the way they do in CSS.
All widgets have one or more CSS nodes with element names and style
classes. When style classes are used in selectors, they have to be prefixed
with a period. Widget names can be used in selectors like IDs. When used
in a selector, widget names must be prefixed with a # character.
In more complicated situations, selectors can be combined in various ways.
To require that a node satisfies several conditions, combine several selectors
into one by concatenating them. To only match a node when it occurs inside some
other node, write the two selectors after each other, separated by whitespace.
To restrict the match to direct children of the parent node, insert a >
character between the two selectors.
Theme labels that are descendants of a window
Theme notebooks, and anything within
Theme combo boxes, and entries that are direct children of a notebook
entry {
color: @fg_color;
background-color: #1209a2;
}
]]>
Theme any widget within a GtkBox
Theme a label named title-label
Theme any widget named main-entry
Theme all widgets with the style class entry
Theme the entry of a GtkSpinButton
It is possible to select CSS nodes depending on their position amongst
their siblings by applying pseudo-classes to the selector, like :first-child,
:last-child or :nth-child(even). When used in selectors, pseudo-classes
must be prefixed with a : character.
Theme labels in the first notebook tab
Another use of pseudo-classes is to match widgets depending on their
state. The available pseudo-classes for widget states are :active, :hover
:disabled, :selected, :focus, :indeterminate, :checked and :backdrop.
In addition, the following pseudo-classes don't have a direct equivalent
as a widget state: :dir(ltr) and :dir(rtl) (for text direction), :link and
:visited (for links) and :drop(active) (for highlighting drop targets).
Widget state pseudo-classes may only apply to the last element in a selector.
Theme pressed buttons
Theme buttons with the mouse pointer over it
Theme insensitive widgets
Theme checkbuttons that are checked
Theme focused labels
Theme indeterminate checkbuttons
To determine the effective style for a widget, all the matching rule
sets are merged. As in CSS, rules apply by specificity, so the rules
whose selectors more closely match a node will take precedence
over the others.
The full syntax for selectors understood by GTK can be found in the
table below. The main difference to CSS is that GTK does not currently
support attribute selectors.
Selector syntax
Pattern Matches Reference Notes
*
any node
CSS
E
any node with name E
CSS
E.class
any E node with the given style class
CSS
E#id
any E node with the given ID
CSS
GTK uses the widget name as ID
E:nth-child(〈nth-child〉)
any E node which is the n-th child of its parent node
CSS
E:nth-last-child(〈nth-child〉)
any E node which is the n-th child of its parent node, counting from the end
CSS
E:first-child
any E node which is the first child of its parent node
CSS
E:last-child
any E node which is the last child of its parent node
CSS
E:only-child
any E node which is the only child of its parent node
CSS
Equivalent to E:first-child:last-child
E:link, E:visited
any E node which represents a hyperlink, not yet visited (:link) or already visited (:visited)
CSS
Corresponds to GTK_STATE_FLAG_LINK and GTK_STATE_FLAGS_VISITED
E:active, E:hover, E:focus
any E node which is part of a widget with the corresponding state
CSS
Correspond to GTK_STATE_FLAG_ACTIVE, GTK_STATE_FLAG_PRELIGHT and GTK_STATE_FLAGS_FOCUSED respectively
E:disabled
any E node which is part of a widget which is disabled
CSS
Corresponds to GTK_STATE_FLAG_INSENSITIVE
E:checked
any E node which is part of a widget (e.g. radio- or checkbuttons) which is checked
CSS
Corresponds to GTK_STATE_FLAG_CHECKED
E:indeterminate
any E node which is part of a widget (e.g. radio- or checkbuttons) which is in an indeterminate state
CSS3 ,
CSS4
Corresponds to GTK_STATE_FLAG_INCONSISTENT
E:backdrop, E:selected
any E node which is part of a widget with the corresponding state
Corresponds to GTK_STATE_FLAG_BACKDROP, GTK_STATE_FLAG_SELECTED
E:not(〈selector〉)
any E node which does not match the simple selector 〈selector〉
CSS
E:dir(ltr), E:dir(rtl)
any E node that has the corresponding text direction
CSS4
E:drop(active)
any E node that is an active drop target for a current DND operation
CSS4
E F
any F node which is a descendent of an E node
CSS
E > F
any F node which is a child of an E node
CSS
E ~ F
any F node which is preceded by an E node
CSS
E + F
any F node which is immediately preceded by an E node
CSS
〈nth-child〉 = even | odd | 〈integer〉 | 〈integer〉n | 〈integer〉n [ + | - ] 〈integer〉
To learn more about selectors in CSS, read the
Selectors
module of the CSS specification.
Colors
CSS allows to specify colors in various ways, using numeric
values or names from a predefined list of colors.
〈color〉 = currentColor | transparent | 〈color name〉 | 〈rgb color〉 | 〈rgba color〉 | 〈hex color〉 | 〈gtk color〉
〈rgb color〉 = rgb( 〈number〉, 〈number〉, 〈number〉 ) | rgb( 〈percentage〉, 〈percentage〉, 〈percentage〉 )
〈rgba color〉 = rgba( 〈number〉, 〈number〉, 〈number〉, 〈alpha value〉 ) | rgba( 〈percentage〉, 〈percentage〉, 〈percentage〉, 〈alpha value〉 )
〈hex color〉 = #〈hex digits〉
〈alpha value〉 = 〈number〉
, clamped to values between 0 and 1
The keyword currentColor resolves to the current value of the
color property when used in another property, and to the inherited value
of the color property when used in the color property itself.
The keyword transparent can be considered a shorthand for rgba(0,0,0,0).
For a list of valid color names and for more background on colors in
CSS, see the Color
module of the CSS specification.
Specifying colors in various ways
GTK adds several additional ways to specify colors.
〈gtk color〉 = 〈symbolic color〉 | 〈color expression〉
The first is a reference to a color defined via a @define-color rule.
The syntax for @define-color rules is as follows:
〈define color rule〉 = @define-color 〈name〉 〈color〉
To refer to the color defined by a @define-color rule,
use the name from the rule, prefixed with @.
〈symbolic color〉 = @〈name〉
An example for defining colors
GTK also supports color expressions, which allow colors to be transformed
to new ones and can be nested, providing a rich language to define colors.
Color expressions resemble functions, taking 1 or more colors and in some
cases a number as arguments.
shade() leaves the color unchanged when the number is 1 and transforms it
to black or white as the number approaches 0 or 2 respectively. For mix(),
0 or 1 return the unaltered 1st or 2nd color respectively; numbers between
0 and 1 return blends of the two; and numbers below 0 or above 1 intensify
the RGB components of the 1st or 2nd color respectively. alpha() takes a
number from 0 to 1 and applies that as the opacity of the supplied color.
〈color expression〉 = lighter( 〈color〉 ) | darker( 〈color〉 ) | shade( 〈color〉, 〈number〉 ) |
alpha( 〈color〉, 〈number〉 ) | mix( 〈color〉, 〈color〉, 〈number〉 )
Images
CSS allows to specify images in various ways, for backgrounds
and borders.
〈image〉 = 〈url〉 | 〈crossfade〉 | 〈alternatives〉 | 〈gradient〉 | 〈gtk image〉
〈crossfade〉 = cross-fade( 〈percentage〉, 〈image〉, 〈image〉 )
〈alternatives〉 = image([ 〈image〉, ]* [ 〈image〉 | 〈color〉 ] )
〈gradient〉 = 〈linear gradient〉 | 〈radial gradient〉
〈linear gradient〉 = [ linear-gradient | repeating-linear-gradient ] (
[ [ 〈angle〉 | to 〈side or corner〉 ] , ]?
〈color stops〉 )
〈radial gradient〉 = [ radial-gradient | repeating-radial-gradient ] (
[ [ 〈shape〉 || 〈size〉 ] [ at 〈position〉 ]? , | at 〈position〉, ]?
〈color stops〉 )
〈side or corner〉 = [ left | right ] || [ top | bottom ]
〈color stops〉 = 〈color stop〉 [ , 〈color stop〉 ]+
〈color stop〉 = 〈color〉 [ 〈percentage〉 | 〈length〉 ]?
〈shape〉 = circle | ellipse
〈size〉 = 〈extent keyword〉 | 〈length〉 | [ 〈length〉 | 〈percentage〉 ]{1,2}
〈extent keyword〉 = closest-size | farthest-side | closest-corner | farthest-corner
The simplest way to specify an image in CSS is to load an image
file from a URL. CSS does not specify anything about supported file
formats; within GTK, you can expect at least PNG, JPEG and SVG to
work. The full list of supported image formats is determined by the
available gdk-pixbuf image loaders and may vary between systems.
Loading an image file
A crossfade lets you specify an image as an intermediate between two
images. Crossfades are specified in the draft of the level 4
Image
module of the CSS specification.
Crossfading two images
The image() syntax provides a way to specify fallbacks in case an image
format may not be supported. Multiple fallback images can be specified,
and will be tried in turn until one can be loaded successfully. The
last fallback may be a color, which will be rendered as a solid color
image.
Image fallback
Gradients are images that smoothly fades from one color to another. CSS
provides ways to specify repeating and non-repeating linear and radial
gradients. Radial gradients can be circular, or axis-aligned ellipses.
A linear gradient is created by specifying a gradient line and then several
colors placed along that line. The gradient line may be specified using
an angle, or by using direction keywords.
Linear gradients
A radial gradient is created by specifying a center point and one or two
radii. The radii may be given explicitly as lengths or percentages or
indirectly, by keywords that specify how the end circle or ellipsis
should be positioned relative to the area it is derawn in.
Radial gradients
To learn more about gradients in CSS, including details of how color stops
are placed on the gradient line and keywords for specifying radial sizes,
you can read the
Image
module of the CSS specification.
GTK extends the CSS syntax for images and also uses it for specifying icons.
〈gtk image〉 = 〈themed icon〉 | 〈scaled image〉 | 〈recolored image〉
GTK has extensive support for loading icons from icon themes. It is
accessible from CSS with the -gtk-icontheme syntax.
〈themed icon〉 = -gtk-icontheme( 〈icon name〉 )
The specified icon name is used to look up a themed icon, while taking
into account the values of the -gtk-icon-theme and -gtk-icon-palette
properties. This kind of image is mainly used as value of the
-gtk-icon-source property.
Using themed icons in CSS
GTK supports scaled rendering on hi-resolution displays. This works
best if images can specify normal and hi-resolution variants. From
CSS, this can be done with the -gtk-scaled syntax.
〈scaled image〉 = -gtk-scaled( 〈image〉[ , 〈image〉 ]* )
While -gtk-scaled accepts multiple higher-resolution variants, in
practice, it will mostly be used to specify a regular image and one
variant for scale 2.
Scaled images in CSS
〈recolored image〉 = -gtk-recolor( 〈url〉 [ , 〈color palette〉 ] )
Symbolic icons from the icon theme are recolored according to the
-gtk-icon-palette property. The recoloring is sometimes needed for images
that are not part of an icon theme, and the -gtk-recolor syntax makes
this available. -gtk-recolor requires a url as first argument. The
remaining arguments specify the color palette to use. If the palette
is not explicitly specified, the current value of the -gtk-icon-palette
property is used.
Recoloring an image
Transitions
CSS defines a mechanism by which changes in CSS property values can
be made to take effect gradually, instead of all at once. GTK supports
these transitions as well.
To enable a transition for a property when a rule set takes effect, it
needs to be listed in the transition-property property in that rule set.
Only animatable properties can be listed in the transition-property.
The details of a transition can modified with the transition-duration,
transition-timing-function and transition-delay properties.
To learn more about transitions, you can read the
Transitions
module of the CSS specification.
Animations
In addition to transitions, which are triggered by changes of the underlying
node tree, CSS also supports defined animations. While transitions specify how
property values change from one value to a new value, animations explicitly
define intermediate property values in keyframes.
Keyframes are defined with an @-rule which contains one or more of rule sets
with special selectors. Property declarations for nonanimatable properties
are ignored in these rule sets (with the exception of animation properties).
〈keyframe rule〉 = @keyframes 〈name〉 { 〈animation rule〉 }
〈animation rule〉 = 〈animation selector〉 { 〈declaration〉* }
〈animation selector〉 = 〈single animation selector〉 [ , 〈single animation selector〉 ]*
〈single animation selector〉 = from | to | 〈percentage〉
To enable an animation, the name of the keyframes must be set as the value
of the animation-name property. The details of the animation can modified
with the animation-duration, animation-timing-function, animation-iteration-count
and other animation properties.
A CSS animation
To learn more about animations, you can read the
Animations
module of the CSS specification.
docs/reference/gtk/css-properties.xml 0000664 0001750 0001750 00000221130 13640771677 020106 0 ustar mclasen mclasen
GTK CSS Properties
3
GTK Library
GTK CSS Properties
CSS Properties in GTK
Supported CSS Properties
GTK supports CSS properties and shorthands as far as they can be applied
in the context of widgets, and adds its own properties only when needed.
All GTK-specific properties have a -gtk prefix.
All properties support the following keywords: inherit, initial, unset, with
the same meaning as in CSS .
The following basic datatypes are used throughout:
〈length〉 = 〈number〉 [ px | pt | em | ex |rem | pc | in | cm | mm ] | 〈calc expression〉
〈percentage〉 = 〈number〉 % | 〈calc expression〉
〈angle〉 = 〈number〉 [ deg | grad | turn ] | 〈calc expression〉
〈time〉 = 〈number〉 [ s | ms ] | 〈calc expression〉
Length values with the em or ex units are resolved using the font
size value, unless they occur in setting the font-size itself, in
which case they are resolved using the inherited font size value.
The rem unit is resolved using the initial font size value, which is
not quite the same as the CSS definition of rem.
〈calc expression〉 = calc( 〈calc sum〉 )
〈calc sum〉 = 〈calc product〉 [ [ + | - ] 〈calc product〉 ]*
〈calc product〉 = 〈calc value〉 [ * 〈calc value〉 | / 〈number〉 ]*
〈calc value〉 = 〈number〉 | 〈length〉 | 〈percentage〉 | 〈angle〉 | 〈time〉 | ( 〈calc sum〉 )
The calc() notation adds considerable expressive power. There are limits
on what types can be combined in such an expression (e.g. it does not make
sense to add a number and a time). For the full details, see the
CSS3 Values and
Units spec.
A common pattern among shorthand properties (called 'four sides') is one
where one to four values can be specified, to determine a value for each
side of an area. In this case, the specified values are interpreted as
follows:
4 values: top right bottom left
3 values: top horizontal bottom
2 values: vertical horizontal
1 value: all
Color and Filter Properties
Name Value Initial Inh. Ani. Reference Notes
color
〈color〉
rgba(1,1,1,1)
✓
✓
CSS2 ,
CSS3
opacity
〈alpha value〉
1
✓
CSS3
filter
none | 〈filter-function-list〉
none
✓
CSS3
〈filter-function-list〉 = [ 〈filter〉]+
〈filter〉 = brightness( 〈number〉 ) |
contrast( 〈number〉 ) |
grayscale( 〈number〉 ) |
hue-rotate( 〈number〉 ) |
invert( 〈number〉 ) |
opacity( 〈number〉 ) |
saturate( 〈number〉 ) |
sepia( 〈number〉 )
The color property specifies the color to use for text, icons and other
foreground rendering. The opacity property specifies the opacity that is
used to composite the widget onto its parent widget. The filter property
specifies filters to be applied to the rendering.
Font Properties
Name Value Initial Inh. Ani. Reference Notes
font-family
〈family name〉 [ , 〈family name〉 ]*
gtk-font-name setting
✓
CSS2 ,
CSS3
font-size
〈absolute size〉 | 〈relative size〉 | 〈length〉 | 〈percentage〉
gtk-font-name setting
✓
✓
CSS2 ,
CSS3
font-style
normal | oblique | italic
normal
✓
CSS2 ,
CSS3
font-variant
normal | small-caps
normal
✓
CSS2 ,
CSS3
only CSS2 values supported
font-weight
normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
normal
✓
✓
CSS2 ,
CSS3
normal is synonymous with 400, bold with 700
font-stretch
ultra-condensed | extra-condensed | condensed | semi-condensed | normal | semi-expanded | expanded | extra-expanded | ultra-expanded
normal
✓
CSS3
-gtk-dpi
〈number〉
screen resolution
✓
✓
font-kerning
auto | normal | none
auto
✓
CSS3
font-variant-ligatures
normal | none | [ 〈common-lig-values〉|| 〈discretionary-lig-values〉|| 〈historical-lig-values〉|| 〈contextual-alt-values〉]
normal
✓
CSS3
font-variant-position
normal | sub | super
normal
✓
CSS3
font-variant-caps
normal | small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps
normal
✓
CSS3
font-variant-numeric
normal | [ 〈numeric-figure-values〉|| 〈numeric-spacing-values〉|| 〈numeric-fraction-values〉|| ordinal || slashed-zero ]
normal
✓
CSS3
font-variant-alternates
normal | [ stylistic(〈feature-value-name〉) || historical-forms || styleset(〈feature-value-name〉#) || character-variant(〈feature-value-name〉#) || swash(〈feature-value-name〉) || ornaments(〈feature-value-name〉) || annotation(〈feature-value-name〉) ]
normal
✓
CSS3
font-variant-east-asian
normal | [ 〈east-asian-variant-values〉 || 〈east-asian-width-values〉 || ruby ]
normal
✓
CSS3
font-feature-settings
normal | 〈feature-tag-value〉#
normal
✓
>
CSS3
font-variation-settings
normal | [ 〈string〉〈number〉]#
normal
✓
✓
CSS4
Shorthand Value Initial Reference Notes
font
[ 〈font-style〉 || 〈font-variant〉 || 〈font-weight〉 || 〈font-stretch〉 ]? 〈font-size〉 〈font-family〉
see individual properties
CSS2 ,
CSS3
CSS allows line-height, etc
font-variant
normal | none | [ 〈common-lig-values〉 || 〈discretionary-lig-values〉 || 〈historical-lig-values〉 || 〈contextual-alt-values〉 || stylistic(>〈feature-value-name〉) || historical-forms || styleset(〈feature-value-name〉 #) || character-variant(〈feature-value-name〉 #) || swash(〈feature-value-name〉) || ornaments(〈feature-value-name〉) || annotation(〈feature-value-name〉) || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || 〈numeric-figure-values〉 || 〈numeric-spacing-values〉 || 〈numeric-fraction-values〉 || ordinal || slashed-zero || 〈east-asian-variant-values〉 || 〈east-asian-width-values〉 || ruby ]
see individual properties
CSS3
〈absolute size〉 = xx-small | x-small | small | medium | large | x-large | xx-large
〈relative size〉 = larger | smaller
〈common-lig-values〉 = [ common-ligatures| no-common-ligatures ]
〈discretionary-lig-values〉 = [ discretionary-ligatures | no-discretionary-ligatures ]
〈historical-lig-values〉 = [ historical-ligatures | no-historical-ligatures ]
〈contextual-alt-values〉 = [ contextual | no-contextual ]
〈numeric-figure-values〉 = [ lining-nums | oldstyle-nums ]
〈numeric-spacing-values〉 = [ proportional-nums | tabular-nums ]
〈numeric-fraction-values〉 = [ diagonal-fractions | stacked-fractions ]
〈east-asian-variant-values〉 = [ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]
〈east-asian-width-values〉 = [ full-width | proportional-width ]
〈feature-tag-value〉 = 〈string〉[ 〈integer〉| on | off ]?
The font properties determine the font to use for rendering text. Relative
font sizes and weights are resolved relative to the inherited value for
these properties.
Text caret properties
Name Value Initial Inh. Ani. Reference Notes
caret-color
〈color〉
currentColor
✓
✓
CSS3
CSS allows an auto value
-gtk-secondary-caret-color
〈color〉
currentColor
✓
✓
Used for the secondary caret in bidirectional text
The caret properties provide a way to change the appearance of the insertion
caret in editable text.
Text decoration properties
Name Value Initial Inh. Ani. Reference Notes
letter-spacing
〈length〉
0px
✓
✓
CSS3
text-decoration-line
none | underline | line-through
none
CSS2 ,
CSS3
CSS allows overline
text-decoration-color
〈color〉
currentColor
✓
CSS3
text-decoration-style
solid | double | wavy
solid
CSS3
CSS allows dashed and dotted
text-shadow
none | 〈shadow〉
none
✓
✓
CSS3
Shorthand Value Initial Reference Notes
text-decoration
〈text-decoration-line〉 || 〈text-decoration-style〉 || 〈text-decoration-color〉
see individual properties
CSS3
〈shadow〉 = 〈length〉 〈length〉 〈color〉?
The text decoration properties determine whether to apply extra decorations
when rendering text.
Icon Properties
Name Value Initial Inh. Ani. Reference Notes
-gtk-icon-source
builtin | 〈image〉 | none
builtin
✓
-gtk-icon-transform
none | 〈transform〉+
none
✓
-gtk-icon-style
requested | regular | symbolic
requested
✓
Determines the preferred style for application-loaded icons
-gtk-icon-theme
〈name〉
current icon theme
✓
The icon theme to use with -gtk-icontheme(). Since 3.20
-gtk-icon-palette
〈color palette〉
default
✓
✓
Used to recolor symbolic icons (both application-loaded and from -gtk-icontheme()). Since 3.20
-gtk-icon-shadow
none | 〈shadow〉
none
✓
✓
-gtk-icon-filter
none | 〈filter-function-list〉
none
✓
CSS3
-gtk-icon-size
〈length〉
none
✓
Determines the size at which icons are displayed. See GtkIconSize
〈transform〉 = matrix( 〈number〉 [ , 〈number〉 ]{5} ) |
matrix3d( 〈number〉 [ , 〈number〉 ]{15} ) |
translate( 〈length〉, 〈length〉 ) | translate3d( 〈length〉, 〈length〉, 〈length〉 ) |
translateX( 〈length〉 ) | translateY( 〈length〉 ) | translateZ( 〈length〉 ) |
scale( 〈number〉 [ , 〈number〉 ]? ) | scale3d( 〈number〉, 〈number〉, 〈number〉 ) |
scaleX( 〈number〉 ) | scaleY( 〈number〉 ) | scaleZ( 〈number〉 ) |
rotate( 〈angle〉 ) | rotate3d( 〈number〉, 〈number〉, 〈number〉, 〈angle〉 ) |
rotateX( 〈angle〉 ) | rotateY( 〈angle〉 ) | rotateZ( 〈angle〉 ) |
skew( 〈angle〉 [ , 〈angle〉 ]? ) | skewX( 〈angle〉 ) | skewY( 〈angle〉 )
〈color palette〉 = default | 〈name〉 〈color〉 [ , 〈name〉 〈color〉 ]*
The -gtk-icon-source property is used by widgets that are rendering 'built-in'
icons, such as arrows, expanders, spinners, checks or radios.
The -gtk-icon-style property determines the preferred style for
application-provided icons.
The -gtk-icon-transform and -gtk-icon-shadow properties affect the rendering
of both built-in and application-provided icons.
-gtk-icon-palette defines a color palette for recoloring symbolic
icons. The recognized names for colors in symbolic icons are error,
warning and success. The default palette maps these three names to
symbolic colors with the names @error_color, @warning_color and
@success_color respectively.
Box properties
Name Value Initial Inh. Ani. Reference Notes
transform
none | 〈transform〉+
none
✓
CSS3 ,
3D
min-width
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
min-height
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
margin-top
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages or auto
margin-right
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages or auto
margin-bottom
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages or auto
margin-left
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages or auto
padding-top
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
padding-right
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
padding-bottom
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
padding-left
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows percentages
Shorthand Value Initial Reference Notes
margin
〈length〉{1,4}
see individual properties
CSS2 ,
CSS3
a 'four sides' shorthand
padding
〈length〉{1,4}
see individual properties
CSS2 ,
CSS3
a 'four sides' shorthand
Border properties
Name Value Initial Inh. Ani. Reference Notes
border-top-width
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows other values
border-right-width
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows other values
border-bottom-width
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows other values
border-left-width
〈length〉
0px
✓
CSS2 ,
CSS3
CSS allows other values
border-top-style
〈border style〉
none
CSS2 ,
CSS3
border-right-style
〈border style〉
none
CSS2 ,
CSS3
border-bottom-style
〈border style〉
none
CSS2 ,
CSS3
border-left-style
〈border style〉
none
CSS2 ,
CSS3
border-top-right-radius
〈corner radius〉
0
✓
CSS2 ,
CSS3
border-bottom-right-radius
〈corner radius〉
0
✓
CSS2 ,
CSS3
border-bottom-left-radius
〈corner radius〉
0
✓
CSS2 ,
CSS3
border-top-left-radius
〈corner radius〉
0
✓
CSS2 ,
CSS3
border-top-color
〈color〉
currentColor
✓
CSS2 ,
CSS3
border-right-color
〈color〉
currentColor
✓
CSS2 ,
CSS3
border-bottom-color
〈color〉
currentColor
✓
CSS2 ,
CSS3
border-left-color
〈color〉
currentColor
✓
CSS2 ,
CSS3
border-image-source
〈image〉 | none
none
✓
CSS3
border-image-repeat
〈border repeat〉{1,2}
stretch
CSS3
border-image-slice
[ 〈number〉 | 〈percentage〉 ]{1,4} && fill?
100%
CSS3
a 'four sides' shorthand
border-image-width
[ 〈length〉 | 〈number〉 | 〈percentage〉 | auto ]{1,4}
1
CSS3
a 'four sides' shorthand
Shorthand Value Initial Reference Notes
border-width
〈length〉{1,4}
see individual properties
CSS2 ,
CSS3
a 'four sides' shorthand
border-style
〈border style〉{1,4}
see individual properties
CSS2 ,
CSS3
a 'four sides' shorthand
border-color
〈color〉{1,4}
see individual properties
CSS3
a 'four sides' shorthand
border-top
〈length〉 || 〈border style〉 || 〈color〉
see individual properties
CSS2 ,
CSS3
border-right
〈length〉 || 〈border style〉 || 〈color〉
see individual properties
CSS2 ,
CSS3
border-bottom
〈length〉 || 〈border style〉 || 〈color〉
see individual properties
CSS2 ,
CSS3
border-left
〈length〉 || 〈border style〉 || 〈color〉
see individual properties
CSS2 ,
CSS3
border
〈length〉 || 〈border style〉 || 〈color〉
see individual properties
CSS2 ,
CSS3
border-radius
[ 〈length〉 | 〈percentage〉 ]{1,4} [ / [ 〈length〉 | 〈percentage〉 ]{1,4} ]?
see individual properties
CSS3
border-image
〈border-image-source〉 || 〈border-image-slice〉 [ / 〈border-image-width〉 | / 〈border-image-width〉? / 〈border-image-outset〉 ]? || 〈border-image-repeat〉
see individual properties
CSS3
〈border style〉 = none | solid | inset | outset | hidden | dotted | dashed | double | groove | ridge
〈corner radius〉 = [ 〈length〉 | 〈percentage〉 ]{1,2}
Outline properties
Name Value Initial Inh. Ani. Reference Notes
outline-style
none | solid | inset | outset | hidden | dotted | dashed | double | groove | ridge
none
CSS2 ,
CSS3
outline-width
〈length〉
0px
✓
CSS2 ,
CSS3
outline-color
〈color〉
currentColor
✓
CSS2 ,
CSS3
outline-offset
〈length〉
0px
CSS3
Shorthand Value Initial Reference Notes
outline
〈outline-color〉 || 〈outline-style〉 || 〈outline-width〉
see individual properties
CSS2 ,
CSS3
GTK uses the CSS outline properties to render the 'focus rectangle'.
Background properties
Name Value Initial Inh. Ani. Reference Notes
background-color
〈color〉
rgba(0,0,0,0)
✓
CSS2 ,
CSS3
background-clip
〈box〉 [ , 〈box〉 ]*
border-box
CSS3
background-origin
〈box〉 [ , 〈box〉 ]*
padding-box
CSS3
background-size
〈bg-size〉 [ , 〈bg-size〉 ]*
auto
✓
CSS3
background-position
〈position〉 [ , 〈position〉 ]*
0
✓
CSS2 ,
CSS3
background-repeat
〈bg-repeat〉 [ , 〈bg-repeat〉 ]*
repeat
CSS2 ,
CSS3
background-image
〈bg-image〉 [ , 〈bg-image〉 ]*
none
✓
CSS2 ,
CSS3
not supported: urls without quotes, colors in crossfades
background-blend-mode
〈blend-mode〉 [ , 〈blend-mode〉 ]*
normal
only affects multiple backgrounds
box-shadow
none | 〈box shadow〉 [ , 〈box shadow〉 ]*
none
✓
CSS3
Shorthand Value Initial Reference Notes
background
[ 〈bg-layer〉 , ]* 〈final-bg-layer〉
see individual properties
CSS2 ,
CSS3
〈box〉 = border-box | padding-box | content-box
〈bg-size〉 = [ 〈length〉 | 〈percentage〉 | auto ]{1,2} | cover | contain
〈position〉 = [ left | right | center | top | bottom | 〈percentage〉 | 〈length〉 ]{1,2,3,4}
〈bg-repeat〉 = repeat-x | repeat-y | [ no-repeat | repeat | round | space ]{1,2}
〈bg-image〉 = 〈image〉 | none
〈bg-layer〉 = 〈bg-image〉 || 〈position〉 [ / 〈bg-size〉 ]? || 〈bg-repeat〉 || 〈box〉 || 〈box〉
〈final-bg-layer〉 = 〈bg-image〉 || 〈position〉 [ / 〈bg-size〉 ]? || 〈bg-repeat〉 || 〈box〉 || 〈box〉 || 〈color〉
〈blend-mode〉 = color || color-burn || color-dodge || darken || difference || exclusion ||
hard-light || hue || lighten || luminosity || multiply || normal || overlay ||
saturate || screen || soft-light
〈box shadow〉 = inset? && 〈length〉{2,4}? && 〈color〉?
As in CSS, the background color is rendered underneath all the background image layers, so it will only be visible if
background images are absent or have transparency.
Alternatively, multiple backgrounds can be blended using the background-blend-mode
property.
Transition properties
Name Value Initial Inh. Ani. Reference Notes
transition-property
none | all | 〈property name〉 [ , 〈property name〉 ]*
all
CSS3
transition-duration
〈time〉 [ , 〈time〉 ]*
0s
CSS3
transition-timing-function
〈single-timing-function〉 [ , 〈single-timing-function〉 ]*
ease
CSS3
transition-delay
〈time〉 [ , 〈time〉 ]*
0s
CSS3
Shorthand Value Initial Reference Notes
transition
〈single-transition〉 [ , 〈single-transition〉 ]*
see individual properties
CSS3
〈single-timing-function〉 = ease | linear | ease-in | ease-out | ease-in-out |
step-start | step-end | steps( 〈integer〉 [ , [ start | end ] ]? ) |
cubic-bezier( 〈number〉, 〈number〉, 〈number〉, 〈number〉 )
〈single-transition〉 = [ none | 〈property name〉 ] || 〈time〉 || 〈single-transition-timing-function〉 || 〈time〉
Animation properties
Name Value Initial Inh. Ani. Reference Notes
animation-name
〈single-animation-name〉 [ , 〈single-animation-name〉 ]*
none
CSS3
animation-duration
〈time〉 [ , 〈time〉 ]*
0s
CSS3
animation-timing-function
〈single-timing-function〉 [ , 〈single-timing-function〉 ]*
ease
CSS3
animation-iteration-count
〈single-animation-iteration-count〉 [ , 〈single-animation-iteration-count〉 ]*
1
CSS3
animation-direction
〈single-animation-direction〉 [ , 〈single-animation-direction〉 ]*
normal
CSS3
animation-play-state
〈single-animation-play-state〉 [ , 〈single-animation-play-state〉 ]*
running
CSS3
animation-delay
〈time〉 [ , 〈time〉 ]*
0s
CSS3
animation-fill-mode
〈single-animation-fill-mode〉 [ , 〈single-animation-fill-mode〉 ]*
none
CSS3
Shorthand Value Initial Reference Notes
animation
〈single-animation〉 [ , 〈single-animation〉 ]*
see individual properties
CSS3
〈single-animation-name〉 = none | 〈property name〉
〈single-animation-iteration-count〉 = infinite | 〈number〉
〈single-animation-direction〉 = normal | reverse | alternate | alternate-reverse
〈single-animation-play-state〉 = running | paused
〈single-animation-fill-mode〉 = none | forwards | backwards | both
〈single-animation〉 = 〈single-animation-name〉 || 〈time〉 || 〈single-timing-function〉 || 〈time〉 ||
〈single-animation-iteration-count〉 || 〈single-animation-direction〉 ||
〈single-animation-play-state〉 || 〈single-animation-fill-mode〉
Table-related properties
Name Value Initial Inh. Ani. Reference Notes
border-spacing
〈length〉{1,2}
0
✓
✓
CSS2 ,
CSS3
The border-spacing property is respected by GtkBox and GtkGrid, and by box gadgets that
are used internally in complex widgets.
docs/reference/gtk/drawing-model.xml 0000664 0001750 0001750 00000023073 13640771677 017663 0 ustar mclasen mclasen
The GTK Drawing Model
3
GTK Library
The GTK Drawing Model
How widgets draw
Overview of the drawing model
This chapter describes the GTK drawing model in detail. If you
are interested in the procedure which GTK follows to draw its
widgets and windows, you should read this chapter; this will be
useful to know if you decide to implement your own widgets. This
chapter will also clarify the reasons behind the ways certain
things are done in GTK.
Windows and events
Applications that use a windowing system generally create
rectangular regions in the screen called surfaces
(GTK is following the Wayland terminology, other windowing systems
such as X11 may call these windows ).
Traditional windowing systems do not automatically save the
graphical content of surfaces, and instead ask applications to
provide new content whenever it is needed.
For example, if a window that is stacked below other
windows gets raised to the top, then the application has to
repaint it, so the previously obscured area can be shown.
When the windowing system asks an application to redraw
a window, it sends a frame event
(expose event in X11 terminology)
for that window.
Each GTK toplevel window or dialog is associated with a
windowing system surface. Child widgets such as buttons or
entries don't have their own surface; they use the surface
of their toplevel.
Generally, the drawing cycle begins when GTK receives
a frame event from the underlying windowing system: if the
user drags a window over another one, the windowing system will
tell the underlying surface that it needs to repaint itself. The
drawing cycle can also be initiated when a widget itself decides
that it needs to update its display. For example, when the user
types a character in an entry widget, the entry asks GTK to queue
a redraw operation for itself.
The windowing system generates frame events for surfaces. The GDK
interface to the windowing system translates such events into
emissions of the ::render signal on the affected surfaces.
The GTK toplevel window connects to that signal, and reacts appropriately.
The following sections describe how GTK decides which widgets
need to be repainted in response to such events, and how widgets
work internally in terms of the resources they use from the
windowing system.
The frame clock
All GTK applications are mainloop-driven, which means that most
of the time the app is idle inside a loop that just waits for
something to happen and then calls out to the right place when
it does. On top of this GTK has a frame clock that gives a
“pulse” to the application. This clock beats at a steady rate,
which is tied to the framerate of the output (this is synced to
the monitor via the window manager/compositor). A typical
refresh rate is 60 frames per second, so a new “pulse” happens
roughly every 16 milliseconds.
The clock has several phases:
Events
Update
Layout
Paint
The phases happens in this order and we will always run each
phase through before going back to the start.
The Events phase is a stretch of time between each redraw where
GTK processes input events from the user and other events
(like e.g. network I/O). Some events, like mouse motion are
compressed so that only a single mouse motion event per clock
cycle needs to be handled.
Once the Events phase is over, external events are paused and
the redraw loop is run. First is the Update phase, where all
animations are run to calculate the new state based on the
estimated time the next frame will be visible (available via
the frame clock). This often involves geometry changes which
drive the next phase, Layout. If there are any changes in
widget size requirements the new layout is calculated for the
widget hierarchy (i.e. sizes and positions for all widgets are
determined). Then comes the Paint phase, where we redraw the
regions of the window that need redrawing.
If nothing requires the Update/Layout/Paint phases we will
stay in the Events phase forever, as we don’t want to redraw
if nothing changes. Each phase can request further processing
in the following phases (e.g. the Update phase will cause there
to be layout work, and layout changes cause repaints).
There are multiple ways to drive the clock, at the lowest level
you can request a particular phase with
gdk_frame_clock_request_phase() which will schedule a clock beat
as needed so that it eventually reaches the requested phase.
However, in practice most things happen at higher levels:
If you are doing an animation, you can use
gtk_widget_add_tick_callback() which will cause a regular
beating of the clock with a callback in the Update phase
until you stop the tick.
If some state changes that causes the size of your widget
to change you call gtk_widget_queue_resize() which will
request a Layout phase and mark your widget as needing
relayout.
If some state changes so you need to redraw some area of
your widget you use the normal gtk_widget_queue_draw()
set of functions. These will request a Paint phase and
mark the region as needing redraw.
There are also a lot of implicit triggers of these from the
CSS layer (which does animations, resizes and repaints as needed).
The scene graph
The first step in “drawing” a window is that GTK creates
render nodes for all the widgets
in the window. The render nodes are combined into a tree
that you can think of as a scene graph
describing your window contents.
Render nodes belong to the GSK layer, and there are various kinds
of them, for the various kinds of drawing primitives you are likely
to need when translating widget content and CSS styling. Typical
examples are text nodes, gradient nodes, texture nodes or clip nodes.
In the past, all drawing in GTK happened via cairo. It is still possible
to use cairo for drawing your custom widget contents, by using a cairo
render node.
A GSK renderer takes these render nodes, transforms
them into rendering commands for the drawing API it targets, and arranges
for the resulting drawing to be associated with the right surface. GSK has
renderers for OpenGL, Vulkan and cairo.
Hierarchical drawing
During the Paint phase GTK receives a single ::render signal on the toplevel
window. The signal handler will create a snapshot object (which is a
helper for creating a scene graph) and emit a GtkWidget::snapshot() signal,
which will propagate down the widget hierarchy. This lets each widget
snapshot its content at the right place and time, correctly handling things
like partial transparencies and overlapping widgets.
To avoid excessive work when generating scene graphs, GTK caches render nodes.
Each widget keeps a reference to its render node (which in turn, will refer to
the render nodes of children, and grandchildren, and so on), and will reuse
that node during the Paint phase. Invalidating a widget (by calling
gtk_widget_queue_draw()) discards the cached render node, forcing the widget
to regenerate it the next time it needs to handle a ::snapshot.
docs/reference/gtk/glossary.xml 0000664 0001750 0001750 00000030270 13640771677 016772 0 ustar mclasen mclasen
Glossary
allocation
The final size of a widget within its parent . For example, a widget
may request a minimum size of 20×20 pixels, but its
parent may decide to allocate 50×20 pixels for it
instead.
requisition
bin
A container that
can hold at most one child widget. The base class for bins is
#GtkBin.
container
child
A container's child
is a widget contained
inside it.
column
GTK contains several widgets which display data in columns,
e.g. the #GtkTreeView.
These view columns in
the tree view are represented by #GtkTreeViewColumn
objects inside GTK. They should not be confused with
model columns which
are used to organize the data in tree models.
model-view widget
container
A widget that contains
other widgets; in that case, the container is the
parent of the child
widgets. Some containers don't draw anything on their own,
but rather just organize their children's geometry ; for example, #GtkVBox lays out
its children vertically without painting anything on its own. Other
containers include decorative elements; for example, #GtkFrame contains
the frame's child and a label in addition to the shaded frame it draws.
The base class for containers is #GtkContainer.
widget
geometry
display
GDK inherited the concept of display from the X window system,
which considers a display to be the combination
of a keyboard, a pointing device and one or more
screens .
Applications open a display to show windows and interact with the user.
In GDK, a display is represented by a #GdkDisplay.
Ellipsization is the process of replacing some part
of a text by an ellipsis (usually "...") to make the
text fit in a smaller space. Pango can ellipsize text
at the beginning, at the end or in the middle.
event
Events are the way in which GDK informs GTK about external events
like pointer motion, button clicks, key presses, etc.
geometry
A widget's position
and size. Within its parent, this is called the widget's
allocation .
mapping
This is the step in a widget's life cycle where it
actually shows the GdkSurfaces it created when it was
realized . When a
widget is mapped, it must turn on its
%GTK_MAPPED flag.
Note that due to the asynchronous nature of the X window
system, a widget's window may not appear on the screen
immediatly after one calls gdk_surface_show():
you must wait for the corresponding map event to be received. You can do
this with the GtkWidget::map-event
signal.
model column
A column in a tree model, holding data of a certain type.
The types which can be stored in the columns of a model
have to be specified when the model is constructed, see
e.g. gtk_list_store_new().
view column
model-view widget
These widgets follow the well-known model-view pattern, which separates
the data (the model) to be displayed from the component which does the
actual visualization (the view). Examples of this pattern in GTK are
the #GtkTreeView/#GtkTreeModel and #GtkTextView/#GtkTextBuffer
One important advantage of this pattern is that it is possible to
display the same model in multiple views; another one that the
separation of the model allows a great deal of flexibility, as
demonstrated by e.g. #GtkTreeModelSort or #GtkTreeModelFilter.
no-window widget
A widget that does not have a GdkSurface of its own on which to
draw its contents, but rather shares its parent's . This can be tested with
the gtk_widget_get_has_surface() function.
parent
A widget's parent is
the container
inside which it resides.
realization
This is the step in a widget's life cycle where it
creates its own GdkSurface, or otherwise associates itself with
its parent's
GdkSurface. If the widget has its own window, then it must
also attach a style to
it. A widget becomes unrealized by destroying its associated
GdkSurface. When a widget is realized, it must turn on its
%GTK_REALIZED flag.
Widgets that don't own the GdkSurface on which they draw are
called no-window widgets .
This can be tested with the gtk_widget_get_has_surface() function. Normally,
these widgets draw on their parent's GdkSurface.
Note that when a #GtkWidget creates a window in its #GtkWidget::realize
handler, it does not actually show the window. That is, the
window's structure is just created in memory. The widget
actually shows the window when it gets mapped .
requisition
The size requisition of a widget is the minimum amount of
space it requests from its parent . Once the parent computes
the widget's final size, it gives it its size allocation .
allocation
screen
GDK inherited the concept of screen from the X window system,
which considers a screen to be a rectangular area, on which
applications may place their windows. Screens under X may have
quite dissimilar visuals .
Each screen can stretch across multiple physical monitors.
In GDK, screens are represented by #GdkScreen objects.
style
A style encapsulates what GTK needs to know in order to draw
a widget. Styles can be modified with
resource files.
toplevel
A widget that does not
require a parent container.
The only toplevel widgets in GTK are #GtkWindow and widgets derived from it.
container
unmap
mapping
unrealize
realization
view column
A displayed column in a tree view, represented by a
#GtkTreeViewColumn object.
model column
visual
A visual describes how color information is stored in pixels.
A screen may support
multiple visuals. On modern hardware, the most common visuals
are truecolor visuals, which store a fixed number of bits
(typically 8) for the red, green and blue components of a color.
On ancient hardware, one may still meet indexed visuals, which
store color information as an index into a color map, or even
monochrome visuals.
widget
A control in a graphical user interface. Widgets can draw
themselves and process events from the mouse and keyboard.
Widget types include buttons, menus, text entry lines, and
lists. Widgets can be arranged into containers , and these take
care of assigning the geometry of the widgets: every
widget thus has a parent except those widgets which are
toplevels . The base
class for widgets is #GtkWidget.
container
docs/reference/gtk/gtk4-broadwayd.xml 0000664 0001750 0001750 00000005150 13640771677 017751 0 ustar mclasen mclasen
gtk4-broadwayd
GTK
Developer
Alexander
Larsson
gtk4-broadwayd
1
User Commands
gtk4-broadwayd
Broadway display server
gtk4-broadwayd
--port PORT
--address ADDRESS
--unixsocket ADDRESS
:DISPLAY
Description
gtk4-broadwayd is a display server for the Broadway
GDK backend. It allows multiple GTK applications to display their
windows in the same web browser, by connecting to gtk4-broadwayd.
When using gtk4-broadwayd, specify the display number to use, prefixed
with a colon, similar to X. The default display number is 0.
gtk4-broadwayd :5
Then point your web browser at http://127.0.0.1:8085 .
Start your applications like this:
GDK_BACKEND=broadway BROADWAY_DISPLAY=:5 gtk4-demo
Options
--port
Use PORT as the HTTP
port, instead of the default 8080 + (DISPLAY - 1).
--address
Use ADDRESS as the HTTP
address, instead of the default http://127.0.0.1:PORT .
--unixsocket
Use ADDRESS as the unix domain socket
address. This option overrides --address and --port .
It is available only on Unix-like systems.
docs/reference/gtk/gtk4-builder-tool.xml 0000664 0001750 0001750 00000006663 13640771677 020410 0 ustar mclasen mclasen
gtk4-builder-tool
GTK
Developer
Matthias
Clasen
gtk4-builder-tool
1
User Commands
gtk4-builder-tool
GtkBuilder file utility
gtk4-builder-tool
COMMAND
OPTION
FILE
Description
gtk4-builder-tool can perform various operations
on GtkBuilder .ui files.
You should always test the modified .ui files produced by gtk4-builder-tool
before using them in production.
Commands
The following commands are understood:
validate
Validates the .ui file and report errors to stderr.
simplify
Simplifies the .ui file by removing properties that
are set to their default values and write the resulting XML to stdout,
or back to the input file.
enumerate
Lists all the named objects that are created in the .ui file.
preview
Preview the .ui file. This command accepts options
to specify the ID of an object and a .css file to use.
Simplify Options
The simplify command accepts the following options:
--replace
Write the content back to the .ui file instead of stdout.
--3to4
Transform a GTK 3 ui file to GTK 4
Preview Options
The preview command accepts the following options:
--id=ID
The ID of the object to preview. If not specified,
gtk4-builder-tool will choose a suitable object on its own.
--css=FILE
Load style information from the given .css file.
docs/reference/gtk/gtk4-demo-application.xml 0000664 0001750 0001750 00000002073 13640771677 021223 0 ustar mclasen mclasen
gtk4-demo-application
GTK
Developer
Matthias
Clasen
gtk4-demo-application
1
User Commands
gtk4-demo-application
Demonstrate GtkApplication
gtk4-demo-application
Description
gtk4-demo-application is an example application
used by gtk4-demo . There is no need to call it
manually.
docs/reference/gtk/gtk4-demo.xml 0000664 0001750 0001750 00000004304 13640771677 016721 0 ustar mclasen mclasen
gtk4-demo
GTK
Developer
Matthias
Clasen
gtk4-demo
1
User Commands
gtk4-demo
Demonstrate GTK widgets
gtk4-demo
--help
--list
--run EXAMPLE
--autoquit
Description
gtk4-demo is a collection of examples.
Its purpose is to demonstrate many GTK widgets in a form
that is useful to application developers.
The application shows the source code for each example, as well as
other used resources, such as ui files and icons.
Options
The following options are understood:
-h , --help
Show help options
--list
List available examples.
-run EXAMPLE
Run the named example. Use --list to
see the available examples.
--autoquit
Quit after a short timeout. This is intended for use
with --run , e.g. when profiling.
docs/reference/gtk/gtk4-encode-symbolic-svg.xml 0000664 0001750 0001750 00000004036 13640771677 021650 0 ustar mclasen mclasen
gtk4-encode-symbolic-svg
GTK
Developer
Alexander
Larsson
gtk4-encode-symbolic-svg
1
User Commands
gtk4-encode-symbolic-svg
Symbolic icon conversion utility
gtk4-encode-symbolic-svg
OPTION...
PATH
WIDTH xHEIGHT
Description
gtk4-encode-symbolic-svg converts symbolic svg icons into
specially prepared png files. GTK can load and recolor these pngs, just like
original svgs, but loading them is much faster.
PATH is the name of a symbolic svg file,
WIDTH xHEIGHT are the
desired dimensions for the generated png file.
To distinguish them from ordinary pngs, the generated files have the extension
.symbolic.png .
Options
-o DIRECTORY
--output DIRECTORY
Write png files to DIRECTORY
instead of the current working directory.
docs/reference/gtk/gtk4-icon-browser.xml 0000664 0001750 0001750 00000002665 13640771677 020416 0 ustar mclasen mclasen
gtk4-icon-browser
GTK
Developer
Matthias
Clasen
gtk4-icon-browser
1
User Commands
gtk4-icon-browser
List themed icons
gtk4-icon-browser
--help
Description
gtk4-icon-browser is a utility to explore the icons
in the current icon theme. It shows icons in various sizes, their symbolic
variants where available, as well as a description of the icon and its context.
Options
The following options are understood:
-h , --help
Show help options
docs/reference/gtk/gtk4-launch.xml 0000664 0001750 0001750 00000004175 13640771677 017255 0 ustar mclasen mclasen
gtk4-launch
GTK
Developer
Tomáš
Bžatek
tbzatek@redhat.com
gtk4-launch
1
User Commands
gtk4-launch
Launch an application
gtk4-launch
OPTION
APPLICATION
URI
Description
gtk4-launch launches an application using the given name.
The application is started with proper startup notification on a default
display, unless specified otherwise.
gtk4-launch takes at least one argument, the name of
the application to launch. The name should match application desktop file name,
as residing in /usr/share/application, with or without the '.desktop' suffix.
If called with more than one argument, the rest of them besides the application
name are considered URI locations and are passed as arguments to the launched
application.
Options
The following options are understood:
-? , --help
Prints a short help text and exits.
--version
Prints the program version and exits.
docs/reference/gtk/gtk4-query-settings.xml 0000664 0001750 0001750 00000002307 13640771677 021001 0 ustar mclasen mclasen
gtk4-query-settings
GTK
Developer
Timm
Bäder
gtk4-query-settings
1
User Commands
gtk4-query-settings
Utility to print name and value of all GtkSettings properties
gtk4-query-settings
PATTERN
Description
gtk4-query-settings prints both name and value of all properties
available in the GtkSettings class. Optionally, you can filter which properties
to list by specifying a PATTERN.
docs/reference/gtk/gtk4-update-icon-cache.xml 0000664 0001750 0001750 00000007161 13640771677 021252 0 ustar mclasen mclasen
gtk4-update-icon-cache
GTK
Developer
Matthias
Clasen
gtk4-update-icon-cache
1
User Commands
gtk4-update-icon-cache
Icon theme caching utility
gtk4-update-icon-cache
--force
--ignore-theme-index
--index-only
--include-image-data
--source NAME
--quiet
--validate
PATH
Description
gtk4-update-icon-cache creates mmapable cache
files for icon themes.
It expects to be given the PATH to an icon theme
directory containing an index.theme , e.g.
/usr/share/icons/hicolor , and writes a
icon-theme.cache containing cached information about
the icons in the directory tree below the given directory.
GTK can use the cache files created by gtk4-update-icon-cache
to avoid a lot of system call and disk seek overhead when the application
starts. Since the format of the cache files allows them to be mmaped
shared between multiple applications, the overall memory consumption is
reduced as well.
Options
--force
-f
Overwrite an existing cache file even if it appears to be
uptodate.
--ignore-theme-index
-t
Don't check for the existence of index.theme
in the icon theme directory. Without this option, gtk4-update-icon-cache
refuses to create an icon cache in a directory which does not appear to
be the toplevel directory of an icon theme.
--index-only
-i
Don't include image data in the cache.
--include-image-data
Include image data in the cache.
--source
-c
Output a C header file declaring a constant
NAME with the contents of the icon
cache.
--quiet
-q
Turn off verbose output.
--validate
-v
Validate existing icon cache.
docs/reference/gtk/gtk4-widget-factory.xml 0000664 0001750 0001750 00000002744 13640771677 020733 0 ustar mclasen mclasen
gtk4-widget-factory
GTK
Developer
Matthias
Clasen
gtk4-widget-factory
1
User Commands
gtk4-widget-factory
Demonstrate GTK widgets
gtk4-widget-factory
--help
Description
gtk4-widget-factory is a collection of examples.
Its purpose is to demonstrate many GTK widgets in a form
that is useful to GTK theme developers.
The application shows widgets in different, typical combinations
and states.
Options
The following options are understood:
-h , --help
Show help options
docs/reference/gtk/input-handling.xml 0000664 0001750 0001750 00000033467 13640771677 020063 0 ustar mclasen mclasen
The GTK Input Model
3
GTK Library
The GTK Input Model
input and event handling in detail
Overview of GTK input and event handling
This chapter describes in detail how GTK handles input. If you are interested
in what happens to translate a key press or mouse motion of the users into a
change of a GTK widget, you should read this chapter. This knowledge will also
be useful if you decide to implement your own widgets.
Devices and events
The most basic input devices that every computer user has interacted with are
keyboards and mice; beyond these, GTK supports touchpads, touchscreens and
more exotic input devices such as graphics tablets. Inside GTK, every such
input device is represented by a #GdkDevice object.
To simplify dealing with the variability between these input devices, GTK
has a concept of master and slave devices. The concrete physical devices that
have many different characteristics (mice may have 2 or 3 or 8 buttons,
keyboards have different layouts and may or may not have a separate number
block, etc) are represented as slave devices. Each slave device is
associated with a virtual master device. Master devices always come in
pointer/keyboard pairs - you can think of such a pair as a 'seat'.
GTK widgets generally deal with the master devices, and thus can be used
with any pointing device or keyboard.
When a user interacts with an input device (e.g. moves a mouse or presses
a key on the keyboard), GTK receives events from the windowing system.
These are typically directed at a specific surface - for pointer events,
the surface under the pointer (grabs complicate this), for keyboard events,
the surface with the keyboard focus.
GDK translates these raw windowing system events into #GdkEvents.
Typical input events are:
button clicks
pointer motion
key presses
focus changes
touch events
These are all represented as #GdkEvents, but you can differentiate
between different events by looking at their type, using
gdk_event_get_event_type().
When GTK creates a GdkSurface, it connects to the #GdkSurface::event
signal on it, which receives all of these input events. Surfaces have
have signals and properties, e.g. to deal with window management
related events.
Event propagation
The function which initially receives input events on the GTK
side is responsible for a number of tasks.
Find the widget which got the event.
Generate crossing (i.e. enter and leave) events when the focus or hover
location change from one widget to another.
Then the event is pushed onto a stack so you can query the currently
handled event with gtk_get_current_event().
The event is sent to a widget. If a grab is active all events for widgets
that are not in the contained in the grab widget are sent to the latter
with a few exceptions:
Deletion and destruction events are still sent to the event widget for
obvious reasons.
Events which directly relate to the visual representation of the event
widget.
Leave events are delivered to the event widget if there was an enter
event delivered to it before without the paired leave event.
Drag events are not redirected because it is unclear what the semantics
of that would be.
After finishing the delivery the event is popped from the event stack.
An event is propagated down and up the widget hierarchy in three phases
(see #GtkPropagationPhase) towards a target widget.
For key events, the top-level window gets a first shot at activating
mnemonics and accelerators. If that does not consume the events,
the target widget for event propagation is window's current focus
widget (see gtk_window_get_focus()).
For pointer events, the target widget is determined by picking
the widget at the events coordinates (see gtk_window_pick()).
In the first phase (the “capture” phase) the event is
delivered to each widget from the top-most (the top-level
#GtkWindow or grab widget) down to the target #GtkWidget.
Event
controllers that are attached with %GTK_PHASE_CAPTURE
get a chance to react to the event.
After the “capture” phase, the widget that was intended to be the
destination of the event will run event controllers attached to
it with %GTK_PHASE_TARGET. This is known as the “target” phase,
and only happens on that widget.
In the last phase (the “bubble” phase), the event is delivered
to each widget from the target to the top-most, and event
controllers attached with %GTK_PHASE_BUBBLE are run.
Events are not delivered to a widget which is insensitive or
unmapped.
Any time during the propagation phase, a controller may indicate
that a received event was consumed and propagation should
therefore be stopped. If gestures are used, this may happen
when the gesture claims the event touch sequence (or the
pointer events) for its own. See the “gesture states” section
below to learn more about gestures and sequences.
Touch events
Touch events are emitted as events of type %GDK_TOUCH_BEGIN,
%GDK_TOUCH_UPDATE or %GDK_TOUCH_END, those events contain an
“event sequence” that univocally identifies the physical touch
until it is lifted from the device.
Keyboard input
Every #GtkWindow maintains a single focus location (in the
#GtkWindow:focus-widget property). The focus widget is the target
widget for key events sent to the window. Only widgets which have
#GtkWidget:can-focus set to %TRUE can become the focus. Typically
these are input controls such as entries or text fields, but e.g.
buttons can take the focus too.
Input widgets can be given the focus by clicking on them, but focus
can also be moved around with certain key events (this is known as
“keyboard navigation”). GTK reserves the Tab key to move the focus
to the next location, and Shift-Tab to move it back to the previous
one. In addition many containers allow “directional navigation” with
the arrow keys.
Many widgets can be “activated” to trigger and action. E.g., you can
activate a button or switch by clicking on them, but you can also
activate them with the keyboard, by using the Enter or Space keys.
Apart from keyboard navigation, activation and directly typing into
entries or text views, GTK widgets can use key events for activating
“shortcuts”. Shortcuts generally act as a quick way to move the focus
around or to activate a widget that does not currently have the focus.
GTK has traditionally supported different kinds of shortcuts:
Mnmemonics
Mnemonics are usually triggered using Alt as a modifier for a letter.
They are used in places where a label is associated with a control,
and are indicated by underlining the letter in the label. As a special
case, inside menus (i.e. inside #GtkPopoverMenu), mnemonics can be
trigered without the modifier.
Key bindings
Key bindings are specific to individual widgets, such as Ctrl-C or
Ctrl-V in an entry copy to or paste from the clipboard. They are only
triggered when the widget has focus.
Accelerators
Accelerators are any other shortcuts that can be activated regardless
of where the focus is, and typically trigger global actions, such as
Ctrl-Q to quit an application.
Under the hood, all shortcuts are represented as instances of #GtkShortcut,
and they are managed by #GtkShortcutController.
Event controllers and gestures
Event controllers are standalone objects that can perform
specific actions upon received #GdkEvents. These are tied
to a #GtkWidget, and can be told of the event propagation
phase at which they will manage the events.
Gestures are a set of specific controllers that are prepared
to handle pointer and/or touch events, each gesture
implementation attempts to recognize specific actions out the
received events, notifying of the state/progress accordingly to
let the widget react to those. On multi-touch gestures, every
interacting touch sequence will be tracked independently.
Since gestures are “simple” units, it is not uncommon to tie
several together to perform higher level actions, grouped
gestures handle the same event sequences simultaneously, and
those sequences share a same state across all grouped
gestures. Some examples of grouping may be:
A “drag” and a “swipe” gestures may want grouping.
The former will report events as the dragging happens,
the latter will tell the swipe X/Y velocities only after
recognition has finished.
Grouping a “drag” gesture with a “pan” gesture will only
effectively allow dragging in the panning orientation, as
both gestures share state.
If “press” and “long press” are wanted simultaneously,
those would need grouping.
Shortcuts are handled by #GtkShortcutController, which is
a complex event handler that can either activate shortcuts
itself, or propagate them to another controller, depending
on its #GtkShortcutController:scope.
Gesture states
Gestures have a notion of “state” for each individual touch
sequence. When events from a touch sequence are first received,
the touch sequence will have “none” state, this means the touch
sequence is being handled by the gesture to possibly trigger
actions, but the event propagation will not be stopped.
When the gesture enters recognition, or at a later point in time,
the widget may choose to claim the touch sequences (individually
or as a group), hence stopping event propagation after the event
is run through every gesture in that widget and propagation phase.
Anytime this happens, the touch sequences are cancelled downwards
the propagation chain, to let these know that no further events
will be sent.
Alternatively, or at a later point in time, the widget may choose
to deny the touch sequences, thus letting those go through again
in event propagation. When this happens in the capture phase, and
if there are no other claiming gestures in the widget,
a %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS event will be emulated and
propagated downwards, in order to preserve consistency.
Grouped gestures always share the same state for a given touch
sequence, so setting the state on one does transfer the state to
the others. They also are mutually exclusive, within a widget
there may be only one gesture group claiming a given sequence.
If another gesture group claims later that same sequence, the
first group will deny the sequence.
docs/reference/gtk/migrating-2to4.xml 0000664 0001750 0001750 00000001232 13640771677 017672 0 ustar mclasen mclasen
]>
Migrating from GTK 2.x to GTK 4
If your application is still using GTK 2, you should first convert it to
GTK 3, by following the migration guide in the GTK 3
documentation, and then follow .
docs/reference/gtk/migrating-3to4.xml 0000664 0001750 0001750 00000120161 13640771677 017676 0 ustar mclasen mclasen
]>
Migrating from GTK 3.x to GTK 4
GTK 4 is a major new version of GTK that breaks both API and ABI
compared to GTK 3.x. Thankfully, most of the changes are not hard
to adapt to and there are a number of steps that you can take to
prepare your GTK 3.x application for the switch to GTK 4. After
that, there's a number of adjustments that you may have to do
when you actually switch your application to build against GTK 4.
Preparation in GTK 3.x
The steps outlined in the following sections assume that your
application is working with GTK 3.24, which is the final stable
release of GTK 3.x. It includes all the necessary APIs and tools
to help you port your application to GTK 4. If you are using
an older version of GTK 3.x, you should first get your application
to build and work with the latest minor release in the 3.24 series.
Do not use deprecated symbols
Over the years, a number of functions, and in some cases, entire
widgets have been deprecated. These deprecations are clearly spelled
out in the API reference, with hints about the recommended replacements.
The API reference for GTK 3 also includes an
index of all deprecated symbols.
To verify that your program does not use any deprecated symbols,
you can use defines to remove deprecated symbols from the header files,
as follows:
make CFLAGS+="-DGDK_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED"
Note that some parts of our API, such as enumeration values, are
not well covered by the deprecation warnings. In most cases, using
them will require you to also use deprecated functions, which will
trigger warnings.
Enable diagnostic warnings
Deprecations of properties and signals cannot be caught at compile
time, as both properties and signals are installed and used after
types have been instantiated. In order to catch deprecations and
changes in the run time components, you should use the
G_ENABLE_DIAGNOSTIC environment variable when
running your application, e.g.:
G_ENABLE_DIAGNOSTIC=1 ./your-app
Do not use widget style properties
Style properties do not exist in GTK 4. You should stop using them in
your custom CSS and in your code.
Review your window creation flags
GTK 4 removes the GDK_WA_CURSOR flag. Instead, just use
gdk_window_set_cursor() to set a cursor on the window after
creating it.
GTK 4 also removes the GDK_WA_VISUAL flag, and always uses
an RGBA visual for windows. To prepare your code for this, use
gdk_window_set_visual (gdk_screen_get_rgba_visual ())
after creating your window.
GTK 4 also removes the GDK_WA_WMCLASS flag. If you need this
X11-specific functionality, use XSetClassHint() directly.
Stop using non-RGBA visuals
GTK 4 always uses RGBA visuals for its windows; you should make
sure that your code works with that.
At the same time, you should stop using GdkVisual APIs, this object
not longer exist in GTK 4. Most of its APIs are deprecated already
and not useful when dealing with RGBA visuals.
Stop using GtkBox:padding, GtkBox:fill and GtkBox:expand
GTK 4 removes these #GtkBox child properties, so you should not use them.
You can replace GtkBox:padding using the #GtkWidget:margin properties
on your #GtkBox child widgets.
The fill child property can be replaced by setting appropriate values
for the #GtkWidget:halign and #GtkWidget:valign properties of the child
widgets. If you previously set the fill child property to %TRUE, you can
achieve the same effect by setting the halign or valign properties to
%GTK_ALIGN_FILL, depending on the parent box -- halign for a horizontal
box, valign for a vertical one.
#GtkBox also uses the expand child property. It can be replaced by setting
#GtkWidget:hexpand or #GtkWidget:vexpand on the child widgets. To match the
old behavior of the #GtkBox's expand child property, you need to set
#GtkWidget:hexpand on the child widgets of a horizontal #GtkBox and
#GtkWidget:vexpand on the child widgets of a vertical #GtkBox.
Note that there's a subtle but important difference between #GtkBox's
expand and fill child properties and the ones in #GtkWidget: setting
#GtkWidget:hexpand or #GtkWidget:vexpand to %TRUE will propagate up
the widget hierarchy, so a pixel-perfect port might require you to reset
the expansion flags to %FALSE in a parent widget higher up the hierarchy.
Stop using the state argument of GtkStyleContext getters
The getters in the GtkStyleContext API, such as
gtk_style_context_get_property(), gtk_style_context_get(),
or gtk_style_context_get_color() only accept the context's current
state for their state argument. You should update all callers to pass
the current state.
Stop using gdk_pixbuf_get_from_window() and gdk_cairo_set_source_surface()
These functions are not supported in GTK 4. Instead, either use backend-specific
APIs, or render your widgets using gtk_widget_render().
Stop using GtkButton's image-related API
The functions and properties related to automatically add a GtkImage
to a GtkButton, and using a GtkSetting to control its visibility, are
not supported in GTK 4. Instead, you can just pack a GtkImage inside
a GtkButton, and control its visibility like you would for any other
widget. If you only want to add a named icon to a GtkButton, you can
use gtk_button_set_icon_name().
Stop using GtkWidget event signals
Event controllers and #GtkGestures replace event signals in GTK 4.
They have been backported to GTK 3.x so you can prepare for this change.
Set a proper application ID
In GTK 4 we want the application's #GApplication
'application-id' (and therefore the D-Bus name), the desktop
file basename and Wayland's xdg-shell app_id to match. In
order to achieve this with GTK 3.x call g_set_prgname() with the same
application ID you passed to #GtkApplication. Rename your
desktop files to match the application ID if needed.
The call to g_set_prgname() can be removed once you fully migrated
to GTK 4.
You should be aware that changing the application ID makes your
application appear as a new, different app to application installers.
You should consult the appstream documentation for best practices
around renaming applications.
Stop using gtk_main() and related APIs
GTK4 removes the gtk_main_ family of APIs. The recommended replacement
is GtkApplication, but you can also iterate the GLib mainloop directly,
using GMainContext APIs.
The replacement for gtk_events_pending() is g_main_context_pending(),
the replacement for gtk_main_iteration() is g_main_context_iteration().
Changes that need to be done at the time of the switch
This section outlines porting tasks that you need to tackle when
you get to the point that you actually build your application against
GTK 4. Making it possible to prepare for these in GTK 3 would
have been either impossible or impractical.
Convert your ui files
A number of the changes outlined below affect .ui files. The
gtk4-builder-tool simplify command can perform many of the
necessary changes automatically, when called with the --3to4
option. You should always review the resulting changes.
Stop using GdkScreen
The GdkScreen object has been removed in GTK 4. Most of its APIs already
had replacements in GTK 3 and were deprecated, a few remaining replacements
have been added to GdkDisplay.
Stop using the root window
The root window is an X11-centric concept that is no longer exposed in the
backend-neutral GDK API. gdk_surface_get_parent() will return %NULL for toplevel
windows. If you need to interact with the X11 root window, you can use
gdk_x11_display_get_xrootwindow() to get its XID.
Stop using GdkVisual
This object is not useful with current GTK drawing APIs and has been removed
without replacement.
Stop using GdkDeviceManager
The GdkDeviceManager object has been removed in GTK 4. Most of its APIs already
had replacements in GTK 3 and were deprecated in favor of GdkSeat.
Adapt to GdkWindow API changes
GdkWindow has been renamed to GdkSurface.
The gdk_window_new() function has been replaced by a number of more
specialized constructors: gdk_surface_new_toplevel(), gdk_surface_new_popup(),
gdk_surface_new_temp(), gdk_wayland_surface_new_subsurface().
Use the appropriate ones to create your windows.
Native and foreign subwindows are no longer supported. These concepts were
complicating the code and could not be supported across backends.
gdk_window_reparent() is no longer available.
Adapt to GdkEvent API changes
Direct access to GdkEvent structs is no longer possible in
GTK 4. Some frequently-used fields already had accessors
in GTK 3, and the remaining fields have gained accessors
in GTK 4.
GdkEvent is now a strictly read-only boxed type, and you
can no longer change any of its fields.
Stop using gdk_surface_set_event_compression
Event compression is now always enabled. If you need to see the uncoalesced
motion history, use gdk_event_get_motion_history().
Stop using gdk_pointer_warp()
Warping the pointer is disorienting and unfriendly to users.
GTK 4 does not support it. In special circumstances (such as when
implementing remote connection UIs) it can be necessary to
warp the pointer; in this case, use platform APIs such as XWarpPointer
directly.
Stop using grabs
GTK 4 no longer provides the gdk_device_grab() or gdk_seat_grab() apis.
If you need to dismiss a popup when the user clicks outside (the most common
use for grabs), you can use the GdkSurface #GdkSurface:autohide property instead.
GtkPopover also has a #GtkPopover:autohide property.
If you need to prevent the user from interacting with a window
while a dialog is open, use #GtkDialog::modal.
Adapt to surface API changes
In GTK 4, the two roles of a standalone toplevel window
and of a popup that is placed relative to a parent window
have been separated out into two interfaces, #GdkToplevel
and #GtkPopup.
Surfaces implementing these interfaces are created with
gdk_surface_new_toplevel() and gdk_surface_new_popup(),
respectively, and they are presented on screen using
gtk_toplevel_present() and gdk_popup_present(). The
present() functions take parameters in the form of an
auxiliary layout struct, #GdkPopupLayout or
#GdkToplevelLayout.
If your code is dealing directly with surfaces, you may
have to change it to call the API in these interfaces,
depending on whether the surface you are dealing with
is a toplevel or a popup.
As part of this reorganization, X11-only concepts such
as sticky or keep-below have been removed. If you need
to use them on your X11 windows, you will have to set
the corresponding X11 properties (as specified in the
EWMH) yourself.
A number of minor API cleanups have happened in GdkSurface
as well. For example, gdk_surface_input_shape_combine_region()
has been renamed to gdk_surface_set_input_region().
Adapt to coordinate API changes
A number of coordinate APIs in GTK 3 had _double variants:
gdk_device_get_position(), gdk_device_get_surface_at_position(),
gdk_surface_get_device_position(). These have been changed to use
doubles, and the _double variants have been removed. Update your
code accordingly.
Any APIs that deal with global (or root) coordinates have been
removed in GTK4, since not all backends support them. You should
replace your use of such APIs with surface-relative equivalents.
Examples of this are gdk_surfae_get_origin(), gdk_surface_move()
or gdk_event_get_root_coords().
Adapt to GdkKeymap API changes
The way to get a keymap has changed slightly. gdk_keymap_get_for_display() has
been renamed to gdk_display_get_keymap().
Adapt to event controller API changes
A few changes to the event controller and #GtkGesture APIs
did not make it back to GTK3, and have to be taken into account
when moving to GTK4. One is that the
#GtkEventControllerMotion::enter,
#GtkEventControllerMotion::leave,
#GtkEventControllerKey::focus-in and
#GtkEventControllerKey::focus-out signals
have gained new arguments. Another is that #GtkGestureMultiPress
has been renamed to #GtkGestureClick.
Stop using GtkEventBox
GtkEventBox is no longer needed and has been removed.
All widgets receive all events.
Stop using GtkButtonBox
GtkButtonBox has been removed. Use a GtkBox instead.
Adapt to GtkBox API changes
GtkBox no longer has pack-start and -end. Pack your widgets in the
correct order, or reorder them as necessary.
Adapt to GtkHeaderBar and GtkActionBar API changes
The gtk_header_bar_set_show_close_button() function has been renamed to
the more accurate name gtk_header_bar_set_show_title_buttons(). The corresponding
getter and the property itself have also been renamed.
The ::pack-type child properties of GtkHeaderBar and GtkActionBar have
been removed. If you need to programmatically place children, use the
pack_start() and pack_end() APIs. In ui files, use the type attribute
on the child element.
gtk4-builder-tool can help with this conversion, with the --3to4 option
of the simplify command.
Adapt to GtkStack, GtkAssistant and GtkNotebook API changes
The child properties of GtkStack, GtkAssistant and GtkNotebook have been
converted into child meta objects.
Instead of gtk_container_child_set (stack, child, …), you can now use
g_object_set (gtk_stack_get_page (stack, child), …). In .ui files, the
GtkStackPage objects must be created explicitly, and take the child widget
as property. GtkNotebook and GtkAssistant are similar.
gtk4-builder-tool can help with this conversion, with the --3to4 option
of the simplify command.
Adapt to GtkStyleContext API changes
The getters in the GtkStyleContext API, such as
gtk_style_context_get_property(), gtk_style_context_get(),
or gtk_style_context_get_color() have lost their state argument,
and always use the context's current state. Update all callers
to omit the state argument.
Adapt to GtkCssProvider API changes
In GTK 4, the various #GtkCssProvider load functions have lost
their #GError argument. If you want to handle CSS loading errors,
use the #GtkCssProvider::parsing-error signal instead.
gtk_css_provider_get_named() has been replaced by
gtk_css_provider_load_named().
Stop using GtkContainer::border-width
GTK 4 has removed the #GtkContainer::border-width property.
Use other means to influence the spacing of your containers,
such as the CSS margin and padding properties on child widgets.
Adapt to GtkWidget's size request changes
GTK 3 used five different virtual functions in GtkWidget to
implement size requisition, namely the gtk_widget_get_preferred_width()
family of functions. To simplify widget implementations, GTK 4 uses
only one virtual function, GtkWidgetClass::measure() that widgets
have to implement.
Adapt to GtkWidget's size allocation changes
The #GtkWidget::size-allocate signal now takes the baseline as an
argument, so you no longer need to call gtk_widget_get_allocated_baseline()
to get it.
Switch to GtkWidget's children APIs
Instead of the GtkContainer subclass, in GTK 4, any widget can
have children, and there is new API to navigate the widget tree:
gtk_widget_get_first_child(), gtk_widget_get_last_child(),
gtk_widget_get_next_sibling(), gtk_widget_get_prev_sibling().
The GtkContainer API still works, but if you are implementing
your own widgets, you should consider using the new APIs.
Don't use -gtk-gradient in your CSS
GTK now supports standard CSS syntax for both linear and radial
gradients, just use those.
Don't use -gtk-icon-effect in your CSS
GTK now supports a more versatile -gtk-icon-filter instead. Replace
-gtk-icon-effect: dim; with -gtk-icon-filter: opacity(0.5); and
-gtk-icon-effect: hilight; with -gtk-icon-filter: brightness(1.2);.
Don't use -gtk-outline-...-radius in your CSS
These non-standard properties have been removed from GTK
CSS. Just use regular border radius.
Use gtk_widget_measure
gtk_widget_measure() replaces the various gtk_widget_get_preferred_ functions
for querying sizes.
Adapt to drawing model changes
This area has seen the most radical changes in the transition from GTK 3
to GTK 4. Widgets no longer use a draw() function to render their contents
to a cairo surface. Instead, they have a snapshot() function that creates
one or more GskRenderNodes to represent their content. Third-party widgets
that use a draw() function or a #GtkWidget::draw signal handler for custom
drawing will need to be converted to use gtk_snapshot_append_cairo().
The auxiliary #GtkSnapshot object has APIs to help with creating render
nodes.
If you are using a #GtkDrawingArea for custom drawing, you need to switch
to using gtk_drawing_area_set_draw_func() to set a draw function instead
of connnecting a handler to the #GtkWidget::draw signal.
Stop using APIs to query GdkSurfaces
A number of APIs for querying special-purpose windows have been removed,
since these windows are no longer publically available:
gtk_tree_view_get_bin_window(), gtk_viewport_get_bin_window(),
gtk_viewport_get_view_window().
Widgets are now visible by default
The default value of #GtkWidget::visible in GTK 4 is %TRUE, so you no
longer need to explicitly show all your widgets. On the flip side, you
need to hide widgets that are not meant to be visible from the start.
A convenient way to remove unnecessary property assignments like this
from ui files it run the command gtk4-builder-tool simplify --replace
on them.
The function gtk_widget_show_all(), the #GtkWidget::no-show-all property
and its getter and setter have been removed in GTK 4, so you should stop using them.
Adapt to changes in animated hiding and showing of widgets
Widgets that appear and disappear with an animation, such as GtkPopover,
GtkInfoBar, GtkRevealer no longer use gtk_widget_show() and gtk_widget_hide()
for this, but have gained dedicated APIs for this purpose that you should
use.
Stop passing commandline arguments to gtk_init
The gtk_init() and gtk_init_check() functions no longer accept commandline
arguments. Just call them without arguments. Other initialization functions
that were purely related to commandline argument handling, such as
gtk_parse_args() and gtk_get_option_group(), are gone. The APIs to
initialize GDK separately are also gone, but it is very unlikely
that you are affected by that.
GdkPixbuf is deemphasized
A number of #GdkPixbuf-based APIs have been removed. The available replacements
are either using #GIcon, or the newly introduced #GdkTexture or #GdkPaintable
classes instead.
If you are dealing with pixbufs, you can use gdk_texture_new_for_pixbuf()
to convert them to texture objects where needed.
GtkWidget event signals are removed
Event controllers and #GtkGestures have already been introduced in GTK 3 to handle
input for many cases. In GTK 4, the traditional widget signals for handling input,
such as #GtkWidget::motion-event or #GtkWidget::event have been removed.
Invalidation handling has changed
Only gtk_widget_queue_draw() is left to mark a widget as needing redraw.
Variations like gtk_widget_queue_draw_rectangle() or gtk_widget_queue_draw_region()
are no longer available.
Stop using GtkWidget::draw
The #GtkWidget::draw signal has been removed. Widgets need to implement the
#GtkWidget::snapshot function now. Connecting draw signal handlers is no longer possible.
Window content observation has changed
Observing widget contents and widget size is now done by using the
#GtkWidgetPaintable object instead of connecting to widget signals.
The gtk_window_fullscreen_on_monitor API has changed
Instead of a monitor number, gtk_window_fullscreen_on_monitor() now takes a
#GdkMonitor argument.
Adapt to cursor API changes
Use the new gtk_widget_set_cursor() function to set cursors, instead of
setting the cursor on the underlying window directly. This is necessary
because most widgets don't have their own window anymore, turning any
such calls into global cursor changes.
For creating standard cursors, gdk_cursor_new_for_display() has been removed,
you have to use cursor names instead of GdkCursorType. For creating custom cursors,
use gdk_cursor_new_from_texture(). The ability to get cursor images has been removed.
Adapt to icon size API changes
Instead of the existing extensible set of symbolic icon sizes, GTK now only
supports normal and large icons with the #GtkIconSize enumeration. The actual sizes
can be defined by themes via the CSS property -gtk-icon-size.
GtkImage setters like gtk_image_set_from_icon_name() no longer take a #GtkIconSize
argument. You can use the separate gtk_image_set_icon_size() setter if you need
to override the icon size.
The ::stock-size property of GtkCellRendererPixbuf has been renamed to
#GtkCellRendererPixbuf:icon-size.
Convert .ui files
The simplify command of gtk4-builder-tool has gained a --3to4 option, which
can help with some of the required changes in .ui files, such as converting
child properties to child meta objects.
Adapt to changes in the GtkAssistant API
The ::has-padding property is gone, and GtkAssistant no longer adds padding
to pages. You can easily do that yourself.
Adapt to changes in the API of GtkEntry, GtkSearchEntry and GtkSpinButton
The GtkEditable interface has been made more useful, and the core functionality of
GtkEntry has been broken out as a GtkText widget. GtkEntry, GtkSearchEntry,
GtkSpinButton and the new GtkPasswordEntry now use a GtkText widget internally
and implement GtkEditable. In particular, this means that it is no longer
possible to use GtkEntry API such as gtk_entry_grab_focus_without_selecting()
on a search entry.
Use GtkEditable API for editable functionality, and widget-specific APIs for
things that go beyond the common interface. For password entries, use
GtkPasswordEntry. As an example, gtk_spin_button_set_max_width_chars()
has been removed in favor of gtk_editable_set_max_width_chars().
Adapt to changes in GtkOverlay API
The GtkOverlay::pass-through child property has been replaced by the
GtkWidget::can-target property. Note that they have the opposite sense:
pass-through == !can-target.
Use GtkFixed instead of GtkLayout
Since GtkScrolledWindow can deal with widgets that do not implement
the GtkScrollable interface by automatically wrapping them into a
GtkViewport, GtkLayout is redundant, and has been removed in favor
of the existing GtkFixed container widget.
Adapt to search entry changes
The way search entries are connected to global events has changed;
gtk_search_entry_handle_event() has been dropped and replaced by
gtk_search_entry_set_key_capture_widget() and
gtk_event_controller_key_forward().
Stop using child properties
GtkContainer no longer provides facilities for defining and using
child properties. If you have custom widgets using child properties,
they will have to be converted either to layout properties provided
by a layout manager (if they are layout-related), or handled in
some other way. One possibility is to use child meta objects,
as seen with GtkAssistantPage, GtkStackPage and the like.
Stop using tabular menus
Tabular menus were rarely used and complicated the menu code,
so they have been removed. If you need complex layout in menu-like
popups, consider using a #GtkPopover instead.
Stop using gtk_menu_set_display()
This function has been removed. Menus should always be
attached to a widget and get their display that way.
Stop using gtk_window_activate_default()
The handling of default widgets has been changed, and activating
the default now works by calling gtk_widget_activate_default()
on the widget that caused the activation.
If you have a custom widget that wants to override the default
handling, you can provide an implementation of the default.activate
action in your widgets' action groups.
Stop setting ::has-default and ::has-focus in .ui files
The special handling for the ::has-default and ::has-focus properties
has been removed. If you want to define the initial focus or the
the default widget in a .ui file, set the ::default-widget or
::focus-widget properties of the toplevel window.
Stop using the GtkWidget::display-changed signal
To track the current display, use the GtkWidget::root property
instead.
GtkPopover::modal has been renamed to autohide
The modal property has been renamed to autohide.
gtk-builder-tool can assist with the rename in ui files.
gtk_widget_get_surface has been removed
gtk_widget_get_surface() has been removed.
Use gtk_native_get_surface() in combination with
gtk_widget_get_native() instead.
gtk_widget_is_toplevel has been removed
gtk_widget_is_toplevel() has been removed.
Use GTK_IS_ROOT, GTK_IS_NATIVE or GTK_IS_WINDOW
instead, as appropriate.
gtk_widget_get_toplevel has been removed
gtk_widget_get_toplevel() has been removed.
Use gtk_widget_get_root() or gtk_widget_get_native()
instead, as appropriate.
GtkEntryBuffer ::deleted-text has changed
To allow signal handlers to access the deleted text before it
has been deleted #GtkEntryBuffer::deleted-text has changed from
%G_SIGNAL_RUN_FIRST to %G_SIGNAL_RUN_LAST. The default handler
removes the text from the #GtkEntryBuffer.
To adapt existing code, use g_signal_connect_after() or
%G_CONNECT_AFTER when using g_signal_connect_data() or
g_signal_connect_object().
The "iconified" window state has been renamed to "minimized"
The GDK_SURFACE_STATE_ICONIFIED value of the
#GdkSurfaceState enumeration is now %GDK_SURFACE_STATE_MINIMIZED.
The #GdkSurface functions gdk_surface_iconify()
and gdk_surface_deiconify() have been renamed to
gdk_surface_minimize() and gdk_surface_unminimize(), respectively.
The corresponding #GtkWindow functions gtk_window_iconify()
and gtk_window_deiconify() have been renamed
to gtk_window_minimize() and gtk_window_unminimize(), respectively.
The behavior of the minimization and unminimization operations have
not been changed, and they still require support from the underlying
windowing system.
GtkMenu, GtkMenuBar and GtkMenuItem are gone
These widgets were heavily relying on X11-centric concepts such as
override-redirect windows and grabs, and were hard to adjust to other
windowing systems.
Menus can already be replaced using GtkPopoverMenu in GTK 3. Additionally,
GTK 4 introduces GtkPopoverMenuBar to replace menubars. These new widgets
can only be constructed from menu models, so the porting effort involves
switching to menu models and actions.
Since menus are gone, GtkMenuButton also lost its ability to show menus,
and needs to be used with popovers in GTK 4.
GtkToolbar has been removed
Toolbars were using outdated concepts such as requiring special toolitem
widgets.
Toolbars should be replaced by using a GtkBox with regular widgets instead.
Stop using custom tooltip windows
Tooltips no longer use GtkWindows in GTK 4, and it is no longer
possible to provide a custom window for tooltips. Replacing the content
of the tooltip with a custom widget is still possible, with
gtk_tooltip_set_custom().
Switch to the new DND api
The source-side DND apis in GTK 4 have been changed to use an event controller, #GtkDragSource.
Instead of calling gtk_drag_source_set() and connecting to #GtkWidget signals, you create
a #GtkDragSource object, attach it to the widget with gtk_widget_add_controller(), and connect
to #GtkDragSource signals. Instead of calling gtk_drag_begin() on a widget to start a drag
manually, call gdk_drag_begin().
The ::drag-data-get signal has been replaced by the #GtkDragSource::prepare signal, which
returns a #GdkContentProvider for the drag operation.
The destination-side DND apis in GTK 4 have also been changed to use and event controller,
#GTkDropTarget.
Instead of calling gtk_drag_dest_set() and connecting to #GtkWidget signals, you create
a #GtkDropTarget object, attach it to the widget with gtk_widget_add_controller(), and
connect to #GtkDropTarget signals.
The ::drag-motion signal has been renamed to #GtkDragSource::accept, and instead of
::drag-data-received, you need to use async read methods on the #GdkDrop object, such
as gdk_drop_read_value_async() or gdk_drop_read_text_async().
Adapt to GtkIconTheme API changes
gtk_icon_theme_lookup_icon() returns a #GtkIconPaintable
object now, instead of a #GtkIconInfo. It always returns
a paintable in the requested size, and never fails.
A number of no-longer-relevant lookup flags and API
variants have been removed.
Update to GtkFileChooser API changes
GtkFileChooser moved to a GFile-based API. If you need to convert a
path or a URI, use g_file_new_for_path(), g_file_new_for_commandline_arg(),
or g_file_new_for_uri(); similarly, if you need to get a path or a URI
from a GFile, use g_file_get_path(), or g_file_get_uri(). With the
removal or path and URI-based functions, the "local-only" property has
been removed; GFile can be used to access non-local as well as local
resources.
The GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER action has been removed. Use
%GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, instead. If a new folder is needed,
the user can create one.
The "confirm-overwrite" signal, and the "do-overwrite-confirmation"
property have been removed from GtkFileChooser. The file chooser widgets
will automatically handle the confirmation of overwriting a file when
using GTK_FILE_CHOOSER_ACTION_SAVE.
GtkFileChooser does not support a custom extra widget any more. If you
need to add extra widgets, use gtk_file_chooser_add_choice() instead.
GtkFileChooser does not support a custom preview widget any more. If
you need to show a custom preview, you can create your own GtkDialog
with a GtkFileChooserWidget and your own preview widget that you
update whenever the #GtkFileChooser::selection-changed signal is
emitted.
docs/reference/gtk/osx.xml 0000664 0001750 0001750 00000001653 13640771677 015743 0 ustar mclasen mclasen
Using GTK on Apple macOS
3
GTK Library
Using GTK on Apple macOS
MacOS-specific aspects of using GTK
Using GTK on Apple macOS
The Apple macOS port of GTK is an implementation of GDK (and therefore GTK)
on top of the Quartz API.
Currently, the macOS port does not use any additional commandline options
or environment variables.
For up-to-date information about the current status of this port, see the
project page .
docs/reference/gtk/other_software.xml 0000664 0001750 0001750 00000013767 13640771677 020176 0 ustar mclasen mclasen
Mixing GTK with other software
3
Mixing GTK with other software
Mixing GTK with other software
How to combine GTK with other code and event loops
Overview
Often people want to use GTK in combination with another library or existing
body of code that is not GTK-aware. The general problem people encounter
is that the control flow of the other code does not return to GTK, so
widgets do not repaint, mouse and keyboard events are ignored, and so forth.
This section describes some approaches to solving this problem. The most
suitable approach depends on the code that's involved, the platforms you're
targetting, and your own familiarity with each approach.
Periodically yield to GTK main loop
This is the simplest method, but requires you to modify the non-GTK code.
Say you have a function that does some kind of lengthy task:
void
do_lengthy_task (void)
{
int i;
for (i = 0; i < BIG_NUMBER; ++i)
{
do_small_part_of_task ();
}
}
You simply insert code into this function that processes pending main loop tasks, if any:
void
do_lengthy_task (void)
{
int i;
for (i = 0; i < BIG_NUMBER; ++i)
{
do_small_part_of_task ();
/* allow main loop to process pending events; NULL
* means the default context.
*/
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
}
}
The primary disadvantage of this approach is that you have to trade off UI
responsiveness and the performance of the task. That is, if
do_small_part_of_task() does very little of the task, you'll spend lots of CPU
time on g_main_context_iteration(). While if
do_small_part_of_task() does a lot of work, the GUI will seem noticeably
"chunky" to the user.
Another disadvantage to this approach is that you can't have more than one
lengthy task at the same time, unless you manually integrate them.
The big advantage of this approach is that it's simple and straightforward, and
works fine for simple applications such as tossing up a progress bar during the
lengthy task.
Run the other code as a slave of the GTK main loop
As a slightly cleaner solution, you can ask the main loop to run a small part of your
task whenever it isn't busy — that is, when it's idle .
GLib provides a function g_idle_add() that's useful
for this. An "idle handler" added with g_idle_add()
will be run continuously as long as it returns TRUE . However,
the main loop gives higher priority to GUI-related tasks, so will run those instead
when appropriate.
Here's a simple example:
gboolean
my_idle_handler (gpointer user_data)
{
do_small_part_of_task ();
if (task_complete)
return G_SOURCE_REMOVE; /* removes the idle handler */
else
return G_SOURCE_CONTINUE; /* runs the idle handler again */
}
g_idle_add (my_idle_handler, NULL);
If your task involves reading data from the network, you should instead use
g_input_add(); this will allow the
main loop to sleep until data is available on a file descriptor, then
wake up to read that data.
g_idle_add() returns a main loop source ID you can
use to remove the idle handler with g_source_remove().
This is useful for cancelling a task, for example. Another approach is to keep a flag
variable and have the idle handler itself return FALSE when appropriate.
Use multiple processes
If you can't break a task into small chunks — the
"do_small_part_of_task()" function in the above examples — you'll have to
separate your program into two parts, by spawning a child thread or process.
A process does not share the same address space (variables and data) with its parent.
A thread does share the same address space, so a change made to a variable in
one thread will be visible to other threads as well.
This manual can't go into full detail on processes, threads, and other UNIX
programming topics. You may wish to get a book or two — two I'm familiar
with are Beginning Linux Programming (WROX Press) and Advanced Programming in
the UNIX Environment (by Richard Stevens.
Those books also cover the central issue you'll need to address in order to have
a multi-process application: how to communicate between the processes. The
simplest solution is to use pipes; g_input_add() in combination with g_spawn_async_with_pipes() should make
this reasonably convenient. There are other possibilities, of course, such as
sockets, shared memory, and X Window System client message events, depending on
your needs.
Use multiple threads
Integrate the GTK main loop with another main loop
Things that won't work
signals
docs/reference/gtk/overview.xml 0000664 0001750 0001750 00000006762 13640771677 017006 0 ustar mclasen mclasen
GTK is a library for creating graphical user interfaces. It
works on many UNIX-like platforms, Windows, and OS X.
GTK is released under the GNU Library General Public License
(GNU LGPL), which allows for flexible licensing of client
applications. GTK has a C-based object-oriented architecture that
allows for maximum flexibility. Bindings for many other languages have
been written, including C++, Objective-C, Guile/Scheme, Perl, Python,
TOM, Ada95, Free Pascal, and Eiffel. The GTK library itself contains
widgets , that is, GUI components such as GtkButton
or GtkTextView.
GTK depends on the following libraries:
GLib
A general-purpose utility library, not specific to graphical user interfaces.
GLib provides many useful data types, macros, type conversions,
string utilities, file utilities, a main loop abstraction, and so on.
GObject
A library that provides a type system, a collection of
fundamental types including an object type, a signal system.
GIO
A modern, easy-to-use VFS API including abstractions for
files, drives, volumes, stream IO, as well as network programming and
DBus communication.
cairo
Cairo is a 2D graphics library with support for multiple
output devices.
Pango
Pango is a library for internationalized text handling. It centers
around the PangoLayout object, representing a paragraph of text.
Pango provides the engine for GtkTextView, GtkLabel, GtkEntry, and
other widgets that display text.
ATK
ATK is the Accessibility Toolkit. It provides a set of generic
interfaces allowing accessibility technologies to interact with a
graphical user interface. For example, a screen reader uses ATK to
discover the text in an interface and read it to blind users. GTK
widgets have built-in support for accessibility using the ATK
framework.
GdkPixbuf
This is a small library which allows you to create GdkPixbuf
("pixel buffer") objects from image data or image files.
Use a GdkPixbuf in combination with GtkImage to display images.
graphene
This is a small library which provides vector and matrix datatypes
and operations. graphene provides optimized implementations using
various SIMD instruction sets such as SSE.
GDK
GDK is the abstraction layer that allows GTK to support multiple
windowing systems. GDK provides window system facilities on Wayland,
X11, Windows, and OS X.
GSK
GSK is a library for creating a scene graph from render nodes,
and rendering it using different rendering APIs. GSK provides renderers
for OpenGL, Vulkan and cairo.
docs/reference/gtk/question_index.xml 0000664 0001750 0001750 00000067016 13640771677 020175 0 ustar mclasen mclasen
Common Questions
3
Common Questions
Common Questions
Find answers to common questions in the GTK manual
Questions and Answers
This is an "index" of the reference manual organized by common "How do
I..." questions. If you aren't sure which documentation to read for
the question you have, this list is a good place to start.
General
How do I get started with GTK?
The GTK website offers some
tutorials and other
documentation (most of it about GTK 2.x, but mostly still applicable).
More documentation ranging from whitepapers to online books can be found at
the GNOME developer's site .
After studying these materials you should be well prepared to come back to
this reference manual for details.
Where can I get help with GTK, submit a bug report, or make a feature request?
See the documentation on this topic.
How do I port from one GTK version to another?
See .
You may also find useful information in the documentation for
specific widgets and functions.
If you have a question not covered in the manual, feel free to
ask on the mailing lists and please file a bug report
against the documentation.
How does memory management work in GTK? Should I free data returned from functions?
See the documentation for #GObject and #GInitiallyUnowned. For #GObject note
specifically g_object_ref() and g_object_unref(). #GInitiallyUnowned is a
subclass of #GObject so the same points apply, except that it has a "floating"
state (explained in its documentation).
For strings returned from functions, they will be declared "const"
if they should not be freed. Non-const strings should be
freed with g_free(). Arrays follow the same rule. If you find an
undocumented exception to the rules, please
file a bug report .
Why does my program leak memory, if I destroy a widget immediately
after creating it ?
If GtkFoo isn't a toplevel window, then
foo = gtk_foo_new ();
gtk_widget_destroy (foo);
is a memory leak, because no one assumed the initial floating
reference. If you are using a widget and you aren't immediately
packing it into a container, then you probably want standard
reference counting, not floating reference counting.
To get this, you must acquire a reference to the widget and drop the
floating reference (ref and sink
in GTK parlance) after
creating it:
foo = gtk_foo_new ();
g_object_ref_sink (foo);
When you want to get rid of the widget, you must call gtk_widget_destroy()
to break any external connections to the widget before dropping your
reference:
gtk_widget_destroy (foo);
g_object_unref (foo);
When you immediately add a widget to a container, it takes care of
assuming the initial floating reference and you don't have to worry
about reference counting at all ... just call gtk_widget_destroy()
to get rid of the widget.
How do I use GTK with threads?
This is covered in the GDK threads
documentation. See also the GThread
documentation for portable threading primitives.
How do I internationalize a GTK program?
Most people use GNU
gettext , already required in order to install GLib. On a UNIX
or Linux system with gettext installed, type info gettext
to read the documentation.
The short checklist on how to use gettext is: call bindtextdomain() so
gettext can find the files containing your translations, call textdomain()
to set the default translation domain, call bind_textdomain_codeset() to
request that all translated strings are returned in UTF-8, then call
gettext() to look up each string to be translated in the default domain.
gi18n.h provides the following shorthand macros for
convenience.
Conventionally, people define macros as follows for convenience:
#define _(x) gettext (x)
#define N_(x) x
#define C_(ctx,x) pgettext (ctx, x)
You use N_() (N stands for no-op) to mark a string for translation in
a location where a function call to gettext() is not allowed, such as
in an array initializer.
You eventually have to call gettext() on the string to actually fetch
the translation. _() both marks the string for translation and actually
translates it.
The C_() macro (C stands for context) adds an additional context to
the string that is marked for translation, which can help to disambiguate
short strings that might need different translations in different
parts of your program.
Code using these macros ends up looking like this:
#include <gi18n.h>
static const char *global_variable = N_("Translate this string");
static void
make_widgets (void)
{
GtkWidget *label1;
GtkWidget *label2;
label1 = gtk_label_new (_("Another string to translate"));
label2 = gtk_label_new (_(global_variable));
...
Libraries using gettext should use dgettext() instead of gettext(), which
allows them to specify the translation domain each time they ask for a
translation. Libraries should also avoid calling textdomain(), since
they will be specifying the domain instead of using the default.
With the convention that the macro GETTEXT_PACKAGE is
defined to hold your libraries translation domain,
gi18n-lib.h can be included to provide
the following convenience:
#define _(x) dgettext (GETTEXT_PACKAGE, x)
How do I use non-ASCII characters in GTK programs ?
GTK uses Unicode (more exactly
UTF-8) for all text. UTF-8 encodes each Unicode codepoint as a sequence of
one to six bytes and has a number of nice properties which make it a good
choice for working with Unicode text in C programs:
ASCII characters are encoded by their familiar ASCII codepoints.
ASCII characters never appear as part of any other character.
The zero byte doesn't occur as part of a character, so that UTF-8 strings
can be manipulated with the usual C library functions for handling
zero-terminated strings.
More information about Unicode and UTF-8 can be found in the
UTF-8 and Unicode
FAQ for Unix/Linux .
GLib provides functions for converting strings between UTF-8 and other
encodings, see g_locale_to_utf8() and g_convert().
Text coming from external sources (e.g. files or user input), has to be
converted to UTF-8 before being handed over to GTK. The following example
writes the content of a IS0-8859-1 encoded text file to
stdout :
gchar *text, *utf8_text;
gsize length;
GError *error = NULL;
if (g_file_get_contents (filename, &text, &length, NULL))
{
utf8_text = g_convert (text, length, "UTF-8", "ISO-8859-1",
NULL, NULL, &error);
if (error != NULL)
{
fprintf ("Couldn't convert file %s to UTF-8\n", filename);
g_error_free (error);
}
else
g_print (utf8_text);
}
else
fprintf (stderr, "Unable to read file %s\n", filename);
For string literals in the source code, there are several alternatives for
handling non-ASCII content:
direct UTF-8
If your editor and compiler are capable of handling UTF-8 encoded sources,
it is very convenient to simply use UTF-8 for string literals, since it
allows you to edit the strings in "wysiwyg". Note that choosing this option
may reduce the portability of your code.
escaped UTF-8
Even if your toolchain can't handle UTF-8 directly, you can still encode
string literals in UTF-8 by using octal or hexadecimal escapes like
\212 or \xa8 to encode each byte.
This is portable, but modifying the escaped strings is not very convenient.
Be careful when mixing hexadecimal escapes with ordinary text;
"\xa8abcd" is a string of length 1 !
runtime conversion
If the string literals can be represented in an encoding which your
toolchain can handle (e.g. IS0-8859-1), you can write your source files
in that encoding and use g_convert() to convert the strings to UTF-8 at
runtime. Note that this has some runtime overhead, so you may want to move
the conversion out of inner loops.
Here is an example showing the three approaches using the copyright sign
© which has Unicode and ISO-8859-1 codepoint 169 and is represented
in UTF-8 by the two bytes 194, 169, or "\302\251" as
a string literal:
g_print ("direct UTF-8: ©");
g_print ("escaped UTF-8: \302\251");
text = g_convert ("runtime conversion: ©", -1, "ISO-8859-1", "UTF-8", NULL, NULL, NULL);
g_print(text);
g_free (text);
If you are using gettext() to localize your application, you need to
call bind_textdomain_codeset() to ensure that translated strings are
returned in UTF-8 encoding.
How do I use GTK with C++?
There are two ways to approach this. The GTK header files use the subset
of C that's also valid C++, so you can simply use the normal GTK API
in a C++ program. Alternatively, you can use a "C++ binding"
such as gtkmm
which provides a native C++ API.
When using GTK directly, keep in mind that only functions can be
connected to signals, not methods. So you will need to use global
functions or "static" class functions for signal connections.
Another common issue when using GTK directly is that
C++ will not implicitly convert an integer to an enumeration.
This comes up when using bitfields; in C you can write the following
code:
gdk_surface_set_events (gdk_surface,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
while in C++ you must write:
gdk_surface_set_events (gdk_surface,
(GdkEventMask) GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
There are very few functions that require this cast, however.
How do I use GTK with other non-C languages?
See the list of language
bindings on https://www.gtk.org .
How do I load an image or animation from a file?
To load an image file straight into a display widget, use
gtk_image_new_from_file() If the file load fails,
gtk_image_new_from_file() will display no image graphic — to detect
a failed load yourself, use gdk_pixbuf_new_from_file() directly, then
gtk_image_new_from_pixbuf(). .
To load an image for another purpose, use gdk_pixbuf_new_from_file(). To
load an animation, use gdk_pixbuf_animation_new_from_file().
gdk_pixbuf_animation_new_from_file() can also load non-animated images, so
use it in combination with gdk_pixbuf_animation_is_static_image() to load a
file of unknown type.
To load an image or animation file asynchronously (without blocking), use
#GdkPixbufLoader.
How do I draw text ?
To draw a piece of text, use a Pango layout and pango_cairo_show_layout().
layout = gtk_widget_create_pango_layout (widget, text);
fontdesc = pango_font_description_from_string ("Luxi Mono 12");
pango_layout_set_font_description (layout, fontdesc);
pango_cairo_show_layout (cr, layout);
pango_font_description_free (fontdesc);
g_object_unref (layout);
See also the
Cairo Rendering
section of Pango manual .
How do I measure the size of a piece of text ?
To obtain the size of a piece of text, use a Pango layout and
pango_layout_get_pixel_size(), using code like the following:
layout = gtk_widget_create_pango_layout (widget, text);
fontdesc = pango_font_description_from_string ("Luxi Mono 12");
pango_layout_set_font_description (layout, fontdesc);
pango_layout_get_pixel_size (layout, &width, &height);
pango_font_description_free (fontdesc);
g_object_unref (layout);
See also the
Layout Objects
section of Pango manual .
Why are types not registered if I use their GTK_TYPE_BLAH
macro ?
The GTK_TYPE_BLAH macros are defined as calls to
gtk_blah_get_type() , and the _get_type()
functions are declared as %G_GNUC_CONST which allows the compiler to optimize
the call away if it appears that the value is not being used.
GLib provides the g_type_ensure() function to work around this problem.
g_type_ensure (GTK_TYPE_BLAH);
How do I create a transparent toplevel window ?
Any toplevel window can be transparent.
It is just a matter of setting a transparent background
in the CSS style for it.
Which widget should I use...
...for lists and trees?
This question has different answers, depending on the size of the dataset
and the required formatting flexibility.
If you want to display a large amount of data in a uniform way, your
best option is a #GtkTreeView widget. See tree
widget overview. A list is just a tree with no branches, so the treeview
widget is used for lists as well.
If you want to display a small amount of items, but need flexible formatting
and widgetry inside the list, then you probably want to use a #GtkListBox,
which uses regular widgets for display.
...for multi-line text display or editing?
See text widget overview — you
should use the #GtkTextView widget.
If you only have a small amount of text, #GtkLabel may also be appropriate
of course. It can be made selectable with gtk_label_set_selectable(). For a
single-line text entry, see #GtkEntry.
...to display an image or animation?
GTK has two widgets that are dedicated to displaying images. #GtkImage, for
small, fixed-size icons and #GtkPicture for content images.
Both can display images in just about any format GTK understands.
You can also use #GtkDrawingArea if you need to do something more complex,
such as draw text or graphics over the top of the image.
...for presenting a set of mutually-exclusive choices, where Windows
would use a combo box?
With GTK, a #GtkComboBox is the recommended widget to use for this use case.
This widget looks like either a combo box or the current option menu, depending
on the current theme. If you need an editable text entry, use the
#GtkComboBox:has-entry property.
GtkWidget
How do I change the color of a widget?
The background color of a widget is determined by the CSS style that applies
to it. To change that, you can set style classes on the widget, and provide
custom CSS to change the appearance. Such CSS can be loaded with
gtk_css_provider_load_from_file() and its variants. See gtk_style_context_add_provider().
How do I change the font of a widget?
If you want to make the text of a label larger, you can use
gtk_label_set_markup():
gtk_label_set_markup (label, "<big>big text</big>");
This is preferred for many apps because it's a relative size to the
user's chosen font size. See g_markup_escape_text() if you are
constructing such strings on the fly.
You can also change the font of a widget by putting
.my-widget-class {
font: Sans 30;
}
in a CSS file, loading it with gtk_css_provider_load_from_file(), and
adding the provider with gtk_style_context_add_provider_for_display().
To associate this style information with your widget, set a style class
on its #GtkStyleContext using gtk_style_context_add_class().
The advantage of this approach is that users can then override the font
you have chosen. See the #GtkStyleContext documentation for more discussion.
How do I disable/ghost/desensitize a widget?
In GTK a disabled widget is termed "insensitive."
See gtk_widget_set_sensitive().
GtkTextView
How do I get the contents of the entire text widget as a string?
See gtk_text_buffer_get_bounds() and gtk_text_buffer_get_text()
or gtk_text_iter_get_text().
GtkTextIter start, end;
GtkTextBuffer *buffer;
char *text;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_bounds (buffer, &start, &end);
text = gtk_text_iter_get_text (&start, &end);
/* use text */
g_free (text);
How do I make a text widget display its complete contents in a specific font?
If you use gtk_text_buffer_insert_with_tags() with appropriate tags to
select the font, the inserted text will have the desired appearance, but
text typed in by the user before or after the tagged block will appear in
the default style.
To ensure that all text has the desired appearance, use
gtk_widget_override_font() to change the default font for the widget.
How do I make a text view scroll to the end of the buffer automatically ?
A good way to keep a text buffer scrolled to the end is to place a
mark at the end of the buffer, and
give it right gravity. The gravity has the effect that text inserted
at the mark gets inserted before , keeping the mark
at the end.
To ensure that the end of the buffer remains visible, use
gtk_text_view_scroll_to_mark() to scroll to the mark after
inserting new text.
The gtk-demo application contains an example of this technique.
#GtkTreeView
How do I associate some data with a row in the tree?
Remember that the #GtkTreeModel columns don't necessarily have to be
displayed. So you can put non-user-visible data in your model just
like any other data, and retrieve it with gtk_tree_model_get().
See the tree widget overview.
How do I put an image and some text in the same column?
You can pack more than one #GtkCellRenderer into a single #GtkTreeViewColumn
using gtk_tree_view_column_pack_start() or gtk_tree_view_column_pack_end().
So pack both a #GtkCellRendererPixbuf and a #GtkCellRendererText into the
column.
I can set data easily on my #GtkTreeStore/#GtkListStore models using
gtk_list_store_set() and gtk_tree_store_set(), but can't read it back?
Both the #GtkTreeStore and the #GtkListStore implement the #GtkTreeModel
interface. Consequentially, you can use any function this interface
implements. The easiest way to read a set of data back is to use
gtk_tree_model_get().
How do I change the way that numbers are formatted by #GtkTreeView?
Use gtk_tree_view_insert_column_with_data_func()
or gtk_tree_view_column_set_cell_data_func() and do the conversion
from number to string yourself (with, say, g_strdup_printf()).
The following example demonstrates this:
enum
{
DOUBLE_COLUMN,
N_COLUMNS
};
GtkListStore *mycolumns;
GtkTreeView *treeview;
void
my_cell_double_to_text (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GtkCellRendererText *cell_text = (GtkCellRendererText *)cell;
gdouble d;
gchar *text;
/* Get the double value from the model. */
gtk_tree_model_get (tree_model, iter, (gint)data, &d, -1);
/* Now we can format the value ourselves. */
text = g_strdup_printf ("%.2f", d);
g_object_set (cell, "text", text, NULL);
g_free (text);
}
void
set_up_new_columns (GtkTreeView *myview)
{
GtkCellRendererText *renderer;
GtkTreeViewColumn *column;
GtkListStore *mycolumns;
/* Create the data model and associate it with the given TreeView */
mycolumns = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE);
gtk_tree_view_set_model (myview, GTK_TREE_MODEL (mycolumns));
/* Create a GtkCellRendererText */
renderer = gtk_cell_renderer_text_new ();
/* Create a new column that has a title ("Example column"),
* uses the above created renderer that will render the double
* value into text from the associated model's rows.
*/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Example column");
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
/* Append the new column after the GtkTreeView's previous columns. */
gtk_tree_view_append_column (GTK_TREE_VIEW (myview), column);
/* Since we created the column by hand, we can set it up for our
* needs, e.g. set its minimum and maximum width, etc.
*/
/* Set up a custom function that will be called when the column content
* is rendered. We use the func_data pointer as an index into our
* model. This is convenient when using multi column lists.
*/
gtk_tree_view_column_set_cell_data_func (column, renderer,
my_cell_double_to_text,
(gpointer)DOUBLE_COLUMN, NULL);
}
How do I hide the expander arrows in my tree view ?
Set the expander-column property of the tree view to a hidden column.
See gtk_tree_view_set_expander_column() and gtk_tree_view_column_set_visible().
Using cairo with GTK
How do I use cairo to draw in GTK applications ?
Use gtk_snapshot_append_cairo() in your #GtkWidget::snapshot signal handler
to optain a cairo context and draw with that.
Can I improve the performance of my application by using another backend
of cairo (such as GL) ?
No. Most drawing in GTK is not done via cairo anymore (but instead
by the GL or Vulkan renderers of GSK).
If you use cairo for drawing your own widgets, gtk_snapshot_append_cairo()
will choose the most appropriate surface type for you.
If you are interested in using GL for your own drawing, see #GtkGLArea.
Can I use cairo to draw on a #GdkPixbuf ?
No. The cairo image surface does not support the pixel format used by GdkPixbuf.
If you need to get cairo drawing into a format that can be displayed efficiently
by GTK, you may want to use an image surface and gdk_memory_texture_new().
docs/reference/gtk/resources.xml 0000664 0001750 0001750 00000011142 13640771677 017136 0 ustar mclasen mclasen
Mailing lists and bug reports
3
Mailing lists and bug reports
Mailing lists and bug reports
Getting help with GTK
Opening a bug or feature request
If you encounter a bug, misfeature, or missing feature in GTK, please
file a bug report on our
GitLab project .
You should also file issues if the documentation is out of date with the
existing API, or unclear.
Don't hesitate to file a bug report, even if you think we may know
about it already, or aren't sure of the details. Just give us as much
information as you have, and if it's already fixed or has already been
discussed, we'll add a note to that effect in the report.
The bug tracker should definitely be used for feature requests, it's
not only for bugs. We track all GTK development in GitLab, to ensure
that nothing gets lost.
Working on GTK
If you develop a bugfix or enhancement for GTK, please open a merge
request in GitLab as well. You should not attach patches to an issue,
or describe the fix as a comment. Merge requests allow us to build
GTK with your code applied, and run the test suite, on multiple platforms
and architectures, and verify that nothing breaks. They also allow us to
do proper code reviews, so we can iterate over the changes.
You should follow the contribution guide
for GTK, available on GitLab.
If you want to discuss your approach before or after working on it,
send and email to gtk-devel-list@gnome.org .
You should not send a patch to the mailing list, as it will inevitably
get lost, or forgotten. Always open a merge request.
Mailing lists
There are several mailing lists dedicated to GTK and related
libraries. Discussion of GLib, Pango, and ATK in addition to GTK
proper is welcome on these lists. You can subscribe or view the
archives of these lists on
http://mail.gnome.org .
If you aren't subscribed to the list, any message you post to
the list will be held for manual moderation, which might take
some days to happen.
gtk-list@gnome.org
gtk-list covers general GTK topics; questions about using GTK in programs,
GTK from a user standpoint, announcements of GTK-related projects
such as themes or GTK modules would all be on-topic. The bulk of the
traffic consists of GTK programming questions.
gtk-app-devel-list@gnome.org
gtk-app-devel-list covers writing applications in GTK. It's narrower
in scope than gtk-list, but the two lists overlap quite a
bit. gtk-app-devel-list is a good place to ask questions about GTK
programming.
gtk-devel-list@gnome.org
gtk-devel-list is for discussion of work on GTK itself, it is
not for
asking questions about how to use GTK in applications. gtk-devel-list
is appropriate for discussion of patches, bugs, proposed features,
and so on.
gtk-i18n-list@gnome.org
gtk-i18n-list is for discussion of internationalization in GTK;
Pango is the main focus of the list. Questions about the details of
using Pango, and discussion of proposed Pango patches or features, are
all on topic.
gtk-doc-list@gnome.org
gtk-doc-list is for discussion of the gtk-doc
documentation system (used to document GTK), and for work on the GTK
documentation.
docs/reference/gtk/running.xml 0000664 0001750 0001750 00000052204 13640771677 016610 0 ustar mclasen mclasen
Running GTK Applications
3
GTK Library
Running GTK Applications
How to run and debug your GTK application
Running and debugging GTK Applications
Environment variables
GTK inspects a number of environment variables in addition to standard
variables like LANG , PATH , HOME
or DISPLAY ; mostly to determine paths to look for certain
files. The X11,
Windows and
Broadway GDK backends use some
additional environment variables.
GTK_DEBUG
Unless GTK has been configured with --enable-debug=no ,
this variable can be set to a list of debug options, which cause GTK
to print out different types of debugging information.
actions
Actions and menu models
builder
GtkBuilder support
geometry
Size allocation
icontheme
Icon themes
keybindings
Keybindings
modules
Loading of modules
printing
Printing support
size-request
Size requests
text
Text widget internals
tree
Tree widget internals
A number of keys are influencing behavior instead of just logging:
interactive
Open the interactive debugger
no-css-cache
Bypass caching for CSS style properties
touchscreen
Pretend the pointer is a touchscreen device
updates
Visual feedback about window updates
resize
Highlight resizing widgets
layout
Show layout borders
snapshot
Include debug render nodes in the generated snapshots
The special value all can be used to turn on all
debug options. The special value help can be used
to obtain a list of all supported debug options.
GTK_PATH
Specifies a list of directories to search when GTK is looking for
dynamically loaded objects such as input method
modules and print backends. If the path to
the dynamically loaded object is given as an absolute path name,
then GTK loads it directly.
Otherwise, GTK goes in turn through the directories in GTK_PATH ,
followed by the directory .gtk-4.0 in the user's
home directory, followed by the system default directory,
which is libdir /gtk-4.0/modules .
(If GTK_EXE_PREFIX is defined, libdir is
$GTK_EXE_PREFIX/lib . Otherwise it is the libdir
specified when GTK was configured, usually
/usr/lib , or
/usr/local/lib .)
For each directory in this list, GTK actually looks in a
subdirectory
directory /version /host /type
Where version is derived from the
version of GTK (use pkg-config
--variable=gtk_binary_version gtk4 to determine this from a
script), host is the architecture on
which GTK was built. (use pkg-config
--variable=gtk_host gtk4 to determine this from a
script), and type is a directory
specific to the type of modules; currently it can be
modules , engines ,
immodules , filesystems or
printbackends , corresponding to the types of
modules mentioned above. Either version ,
host , or both may be omitted. GTK looks
first in the most specific directory, then in directories with
fewer components.
The components of GTK_PATH are separated by the ':' character on
Linux and Unix, and the ';' character on Windows.
Note that this environment variable is read by GTK 2.x and GTK 3.x too,
which makes it unsuitable for setting it system-wide (or session-wide),
since doing so will cause applications using different GTK versions
to see incompatible modules.
GTK_IM_MODULE
Specifies an IM module to use in preference to the one determined
from the locale. If this isn't set and you are running on the system
that enables XSETTINGS and has a value in
Gtk/IMModule , that will be used for the default
IM module.
This also can be a colon-separated list of input-methods, which
GTK will try in turn until it finds one available on the system.
GTK_EXE_PREFIX
If set, GTK uses $GTK_EXE_PREFIX/lib instead of
the libdir configured when GTK was compiled.
GTK_DATA_PREFIX
If set, makes GTK use $GTK_DATA_PREFIX
instead of the prefix configured when GTK was compiled.
GTK_THEME
If set, makes GTK use the named theme instead of the theme
that is specified by the gtk-theme-name setting. This is intended
mainly for easy debugging of theme issues.
It is also possible to specify a theme variant to load, by appending
the variant name with a colon, like this: `GTK_THEME=Adwaita:dark`.
The following environment variables are used by GdkPixbuf, GDK or
Pango, not by GTK itself, but we list them here for completeness
nevertheless.
GDK_PIXBUF_MODULE_FILE
Specifies the file listing the GdkPixbuf loader modules to load.
This environment variable overrides the default value
libdir /gtk-4.0/4.0.0/loaders.cache
(libdir is the sysconfdir specified when
GTK was configured, usually /usr/local/lib .)
The loaders.cache file is generated by the
gdk-pixbuf-query-loaders utility.
GDK_DEBUG
If GTK has been configured with --enable-debug=yes ,
this variable can be set to a list of debug options, which cause GDK
to print out different types of debugging information.
cursor
Information about cursor objects (only win32)
eventloop
Information about event loop operation (mostly Quartz)
misc
Miscellaneous information
frames
Information about the frame clock
settings
Information about xsettings
selection
Information about selections
clipboard
Information about clipboards
dnd
Information about drag-and-drop
opengl
Information about OpenGL
vulkan
Information about Vulkan
A number of options affect behavior instead of logging:
nograbs
Turn off all pointer and keyboard grabs
gl-disable
Disable OpenGL support
gl-software
Force OpenGL software rendering
gl-texture-rect
Use the OpenGL texture rectangle extension, if available
gl-legacy
Use a legacy OpenGL context
gl-gles
Use a GLES OpenGL context
vulkan-disable
Disable Vulkan support
vulkan-validate
Load the Vulkan validation layer, if available
The special value all can be used to turn on all
debug options. The special value help can be used
to obtain a list of all supported debug options.
GSK_DEBUG
If GTK has been configured with --enable-debug=yes ,
this variable can be set to a list of debug options, which cause GSK
to print out different types of debugging information.
renderer
General renderer information
cairo
cairo renderer information
opengl
OpenGL renderer information
shaders
Shaders
ssurface
Surfaces
vulkan
Vulkan renderer information
fallback
Information about fallbacks
glyphcache
Information about glyph caching
A number of options affect behavior instead of logging:
diff
Show differences
geometry
Show borders
full-redraw
Force full redraws for every frame
sync
Sync after each frame
vulkan-staging-image
Use a staging image for Vulkan texture upload
vulkan-staging-buffer
Use a staging buffer for Vulkan texture upload
The special value all can be used to turn on all
debug options. The special value help can be used
to obtain a list of all supported debug options.
GDK_BACKEND
If set, selects the GDK backend to use. Selecting a backend requires that
GTK is compiled with support for that backend. The following backends can
be selected, provided they are included in the GDK libraries you are using:
quartz
Selects the native Quartz backend
win32
Selects the native backend for Microsoft Windows
x11
Selects the native backend for connecting to X11 servers.
broadway
Selects the Broadway backend for display in web browsers
wayland
Selects the Wayland backend for connecting to Wayland display servers
Since 3.10, this environment variable can contain a comma-separated list
of backend names, which are tried in order. The list may also contain
a *, which means: try all remaining backends. The special value "help" can
be used to make GDK print out a list of all available backends.
For more information about selecting backends, see the gdk_display_manager_get() function.
GDK_VULKAN_DEVICE
This variable can be set to the index of a Vulkan device to override the
default selection of the device that is used for Vulkan rendering.
The special value list can be used to obtain a list
of all Vulkan devices.
GSK_RENDERER
If set, selects the GSK renderer to use. The following renderers can
be selected, provided they are included in the GTK library you are using
and the GDK backend supports them:
help
Prints information about available options
broadway
Selects the Broadway-backend specific renderer
cairo
Selects the fallback Cairo renderer
gl
Selects the default OpenGL renderer
vulkan
Selects the Vulkan renderer
GTK_CSD
The default value of this environment variable is 1. If changed to 0, this
disables the default use of client-side decorations on GTK windows, thus
making the window manager responsible for drawing the decorations of
windows that do not have a custom titlebar widget.
CSD is always used for windows with a custom titlebar widget set, as the WM
should not draw another titlebar or other decorations around the custom one.
XDG_DATA_HOME , XDG_DATA_DIRS
GTK uses these environment variables to locate icon themes
and MIME information. For more information, see
Icon Theme Specification ,
the Shared MIME-info Database
and the Base Directory Specification .
DESKTOP_STARTUP_ID
GTK uses this environment variable to provide startup notification
according to the Startup Notification Spec .
Following the specification, GTK unsets this variable after reading
it (to keep it from leaking to child processes). So, if you need its
value for your own purposes, you have to read it before calling
gtk_init().
Interactive debugging
GTK includes an interactive debugger, called the GTK Inspector, which
lets you explore the widget tree of any GTK application at runtime, as
well as tweak the theme and trigger visual debugging aids. You can
easily try out changes at runtime before putting them into the code.
Note that the GTK inspector can only show GTK internals. It can not
understand the application-specific logic of a GTK application. Also,
the fact that the GTK inspector is running in the application process
limits what it can do. It is meant as a complement to full-blown debuggers
and system tracing facilities such as DTrace, not as a replacement.
To enable the GTK inspector, you can use the Control-Shift-I or
Control-Shift-D keyboard shortcuts, or set the
GTK_DEBUG=interactive environment variable.
There are a few more environment variables that can be set to influence
how the inspector renders its UI. GTK_INSPECTOR_DISPLAY and
GTK_INSPECTOR_RENDERER determine the GDK display and
the GSK renderer that the inspector is using.
In some situations, it may be inappropriate to give users access to the
GTK inspector. The keyboard shortcuts can be disabled with the
`enable-inspector-keybinding` key in the `org.gtk.Settings.Debug`
GSettings schema.
Profiling
GTK supports profiling with sysprof. It exports timing information
about frameclock phases and various characteristics of GskRenders
in a format that can be displayed by sysprof or GNOME Builder.
A simple way to capture data is to set the GTK_TRACE
environment variable. When it is set, GTK will write profiling
data to a file called
gtk.PID .syscap .
When launching the application from sysprof, it will set the
SYSPROF_TRACE_FD environment variable to point
GTK at a file descriptor to write profiling data to.
When GtkApplication registers with D-Bus, it exports the
org.gnome.Sysprof2.Profiler interface
that lets sysprof request profiling data at runtime.
docs/reference/gtk/text_widget.xml 0000664 0001750 0001750 00000020441 13640771677 017455 0 ustar mclasen mclasen
Text Widget Overview
3
GTK Library
Text Widget Overview
Overview of GtkTextBuffer, GtkTextView, and friends
Conceptual Overview
GTK has an extremely powerful framework for multiline text editing. The
primary objects involved in the process are #GtkTextBuffer, which represents the
text being edited, and #GtkTextView, a widget which can display a #GtkTextBuffer.
Each buffer can be displayed by any number of views.
One of the important things to remember about text in GTK is that it's in the
UTF-8 encoding. This means that one character can be encoded as multiple
bytes. Character counts are usually referred to as
offsets , while byte counts are called
indexes . If you confuse these two, things will work fine
with ASCII, but as soon as your buffer contains multibyte characters, bad
things will happen.
Text in a buffer can be marked with tags . A tag is an
attribute that can be applied to some range of text. For example, a tag might
be called "bold" and make the text inside the tag bold. However, the tag
concept is more general than that; tags don't have to affect appearance. They
can instead affect the behavior of mouse and key presses, "lock" a range of
text so the user can't edit it, or countless other things. A tag is
represented by a #GtkTextTag object. One #GtkTextTag can be applied to any
number of text ranges in any number of buffers.
Each tag is stored in a #GtkTextTagTable. A tag table defines a set of
tags that can be used together. Each buffer has one tag table associated with
it; only tags from that tag table can be used with the buffer. A single tag
table can be shared between multiple buffers, however.
Tags can have names, which is convenient sometimes (for example, you can name
your tag that makes things bold "bold"), but they can also be anonymous (which
is convenient if you're creating tags on-the-fly).
Most text manipulation is accomplished with iterators ,
represented by a #GtkTextIter. An iterator represents a position between two
characters in the text buffer. #GtkTextIter is a struct designed to be
allocated on the stack; it's guaranteed to be copiable by value and never
contain any heap-allocated data. Iterators are not valid indefinitely;
whenever the buffer is modified in a way that affects the number of characters
in the buffer, all outstanding iterators become invalid. (Note that deleting
5 characters and then reinserting 5 still invalidates iterators, though you
end up with the same number of characters you pass through a state with a
different number).
Because of this, iterators can't be used to preserve positions across buffer
modifications. To preserve a position, the #GtkTextMark object is ideal. You
can think of a mark as an invisible cursor or insertion point; it floats in
the buffer, saving a position. If the text surrounding the mark is deleted,
the mark remains in the position the text once occupied; if text is inserted
at the mark, the mark ends up either to the left or to the right of the new
text, depending on its gravity . The standard text
cursor in left-to-right languages is a mark with right gravity, because it
stays to the right of inserted text.
Like tags, marks can be either named or anonymous. There are two marks built-in
to #GtkTextBuffer; these are named "insert" and
"selection_bound" and refer to the insertion point and the
boundary of the selection which is not the insertion point, respectively. If
no text is selected, these two marks will be in the same position. You can
manipulate what is selected and where the cursor appears by moving these
marks around.
If you want to place the cursor in response to a user action, be sure to use
gtk_text_buffer_place_cursor(), which moves both at once without causing a
temporary selection (moving one then the other temporarily selects the range in
between the old and new positions).
Text buffers always contain at least one line, but may be empty (that
is, buffers can contain zero characters). The last line in the text
buffer never ends in a line separator (such as newline); the other
lines in the buffer always end in a line separator. Line separators
count as characters when computing character counts and character
offsets. Note that some Unicode line separators are represented with
multiple bytes in UTF-8, and the two-character sequence "\r\n" is also
considered a line separator.
Text buffers support undo and redo if gtk_text_buffer_set_undo_enabled()
has been set to %TRUE. Use gtk_text_buffer_undo() or gtk_text_buffer_redo()
to perform the necessary action. Note that these operations are ignored if
the buffer is not editable. Developers may want some operations to not be
undoable. To do this, wrap your changes in
gtk_text_buffer_begin_irreversible_action() and
gtk_text_buffer_end_irreversible_action().
Simple Example
The simplest usage of #GtkTextView might look like this:
GtkWidget *view;
GtkTextBuffer *buffer;
view = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (buffer, "Hello, this is some text", -1);
/* Now you might put the view in a container and display it on the
* screen; when the user edits the text, signals on the buffer
* will be emitted, such as "changed", "insert_text", and so on.
*/
In many cases it's also convenient to first create the buffer with
gtk_text_buffer_new(), then create a widget for that buffer with
gtk_text_view_new_with_buffer(). Or you can change the buffer the widget
displays after the widget is created with gtk_text_view_set_buffer().
Example of Changing Text Attributes
The way to affect text attributes in #GtkTextView is to
apply tags that change the attributes for a region of text.
For text features that come from the theme — such as font and
foreground color — use CSS to override their default values.
GtkWidget *view;
GtkTextBuffer *buffer;
GtkTextIter start, end;
PangoFontDescription *font_desc;
GdkRGBA rgba;
GtkTextTag *tag;
GtkCssProvider *provider;
GtkStyleContext *context;
view = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_set_text (buffer, "Hello, this is some text", -1);
/* Change default font and color throughout the widget */
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
"textview {"
" font: 15 serif;"
" color: green;"
"}",
-1);
context = gtk_widget_get_style_context (view);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
/* Change left margin throughout the widget */
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), 30);
/* Use a tag to change the color for just one part of the widget */
tag = gtk_text_buffer_create_tag (buffer, "blue_foreground",
"foreground", "blue", NULL);
gtk_text_buffer_get_iter_at_offset (buffer, &start, 7);
gtk_text_buffer_get_iter_at_offset (buffer, &end, 12);
gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
The gtk-demo application that comes with
GTK contains more example code for #GtkTextView.
docs/reference/gtk/tree_widget.xml 0000664 0001750 0001750 00000031057 13640771677 017435 0 ustar mclasen mclasen
Tree and List Widget Overview
3
GTK Library
Tree and List Widget Overview
Overview of GtkTreeModel, GtkTreeView, and friends
Overview
To create a tree or list in GTK, use the #GtkTreeModel interface in
conjunction with the #GtkTreeView widget. This widget is
designed around a Model/View/Controller
design and consists of four major parts:
The tree view widget (GtkTreeView )
The view column (GtkTreeViewColumn )
The cell renderers (GtkCellRenderer etc.)
The model interface (GtkTreeModel )
The View is composed of the first three
objects, while the last is the Model . One
of the prime benefits of the MVC design is that multiple views
can be created of a single model. For example, a model mapping
the file system could be created for a file manager. Many views
could be created to display various parts of the file system,
but only one copy need be kept in memory.
The purpose of the cell renderers is to provide extensibility to the
widget and to allow multiple ways of rendering the same type of data.
For example, consider how to render a boolean variable. Should it
render it as a string of "True" or "False", "On" or "Off", or should
it be rendered as a checkbox?
Creating a model
GTK provides two simple models that can be used: the #GtkListStore
and the #GtkTreeStore. GtkListStore is used to model list widgets,
while the GtkTreeStore models trees. It is possible to develop a new
type of model, but the existing models should be satisfactory for all
but the most specialized of situations. Creating the model is quite
simple:
This creates a list store with two columns: a string column and a boolean
column. Typically the 2 is never passed directly like that; usually an
enum is created wherein the different columns are enumerated, followed by
a token that represents the total number of columns. The next example will
illustrate this, only using a tree store instead of a list store. Creating
a tree store operates almost exactly the same.
Adding data to the model is done using gtk_tree_store_set() or
gtk_list_store_set(), depending upon which sort of model was
created. To do this, a #GtkTreeIter must be acquired. The iterator
points to the location where data will be added.
Once an iterator has been acquired, gtk_tree_store_set() is used to
apply data to the part of the model that the iterator points to.
Consider the following example:
Notice that the last argument is -1. This is always done because
this is a variable-argument function and it needs to know when to stop
processing arguments. It can be used to set the data in any or all
columns in a given row.
The third argument to gtk_tree_store_append() is the parent iterator. It
is used to add a row to a GtkTreeStore as a child of an existing row. This
means that the new row will only be visible when its parent is visible and
in its expanded state. Consider the following example:
Creating the view component
While there are several different models to choose from, there is
only one view widget to deal with. It works with either the list
or the tree store. Setting up a #GtkTreeView is not a difficult
matter. It needs a #GtkTreeModel to know where to retrieve its data
from.
Columns and cell renderers
Once the #GtkTreeView widget has a model, it will need to know how
to display the model. It does this with columns and cell renderers.
Cell renderers are used to draw the data in the tree model in a
way. There are a number of cell renderers that come with GTK,
including the #GtkCellRendererText, #GtkCellRendererPixbuf and
the #GtkCellRendererToggle.
It is relatively easy to write a custom renderer.
A #GtkTreeViewColumn is the object that GtkTreeView uses to organize
the vertical columns in the tree view. It needs to know the name of
the column to label for the user, what type of cell renderer to use,
and which piece of data to retrieve from the model for a given row.
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Author",
renderer,
"text", AUTHOR_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
At this point, all the steps in creating a displayable tree have been
covered. The model is created, data is stored in it, a tree view is
created and columns are added to it.
Selection handling
Most applications will need to not only deal with displaying data, but
also receiving input events from users. To do this, simply get a
reference to a selection object and connect to the
#GtkTreeSelection::changed signal.
Then to retrieve data for the row selected:
Simple Example
Here is a simple example of using a #GtkTreeView widget in context
of the other widgets. It simply creates a simple model and view,
and puts them together. Note that the model is never populated
with data — that is left as an exercise for the reader.
More information can be found on this in the #GtkTreeModel section.
enum
{
TITLE_COLUMN,
AUTHOR_COLUMN,
CHECKED_COLUMN,
N_COLUMNS
};
void
setup_tree (void)
{
GtkTreeStore *store;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* Create a model. We are using the store model for now, though we
* could use any other GtkTreeModel */
store = gtk_tree_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
/* custom function to fill the model with data */
populate_tree_model (store);
/* Create a view */
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
/* The view now holds a reference. We can get rid of our own
* reference */
g_object_unref (G_OBJECT (store));
/* Create a cell render and arbitrarily make it red for demonstration
* purposes */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"foreground", "red",
NULL);
/* Create a column, associating the "text" attribute of the
* cell_renderer to the first column of the model */
column = gtk_tree_view_column_new_with_attributes ("Author", renderer,
"text", AUTHOR_COLUMN,
NULL);
/* Add the column to the view. */
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Second column.. title of the book. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Title",
renderer,
"text", TITLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last column.. whether a book is checked out. */
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Checked out",
renderer,
"active", CHECKED_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Now we can manipulate the view just like any other GTK widget */
...
}
docs/reference/gtk/visual_index.xml 0000664 0001750 0001750 00000016615 13640771677 017630 0 ustar mclasen mclasen
docs/reference/gtk/wayland.xml 0000664 0001750 0001750 00000002062 13640771677 016564 0 ustar mclasen mclasen
Using GTK with Wayland
3
GTK Library
Using GTK with Wayland
Wayland-specific aspects of using GTK
Using GTK with Wayland
The GDK Wayland backend provides support for running GTK applications
under the Wayland display server. To run your application in this way,
select the Wayland backend by setting GDK_BACKEND=wayland .
Currently, the Wayland backend does not use any additional commandline
options or environment variables.
For up-to-date information about the current status of this backend, see
the project page .
docs/reference/gtk/windows.xml 0000664 0001750 0001750 00000007060 13640771677 016622 0 ustar mclasen mclasen
Using GTK on Windows
3
GTK Library
Using GTK on Windows
Windows-specific aspects of using GTK
Using GTK on Windows
The Windows port of GTK is an implementation of GDK (and therefore GTK)
on top of the Win32 API. When compiling GTK on Windows, this backend is
the default.
Windows-specific commandline options
The Windows GDK backend can be influenced with some
additional command line arguments.
--sync
Don't batch GDI requests. This might be a marginally useful option for
debugging.
--no-wintab ,
--ignore-wintab
Don't use the Wintab API for tablet support.
--use-wintab
Use the Wintab API for tablet support. This is the default.
--max-colors number
In 256 color mode, restrict the size of the color palette to
the specified number of colors. This option is obsolete.
Windows-specific environment variables
The Win32 GDK backend can be influenced with some
additional environment variables.
GDK_IGNORE_WINTAB
If this variable is set, GTK doesn't use
the Wintab API for tablet support.
GDK_USE_WINTAB
If this variable is set, GTK uses the Wintab API for
tablet support. This is the default.
GDK_WIN32_MAX_COLORS
Specifies the size of the color palette used
in 256 color mode.
Windows-specific handling of cursors
By default the "system" cursor theme is used. This makes GTK prefer cursors
that Windows currently uses, falling back to Adwaita cursors and (as the last
resort) built-in X cursors.
When any other cursor theme is used, GTK will prefer cursors from that theme,
falling back to Windows cursors and built-in X cursors.
Theme can be changed by setting gtk-cursor-theme-name GTK setting. Users can override GTK settings in the settings.ini file or at runtime in the GTK Inspector.
Themes are loaded from normal Windows variants of the XDG locations:
%HOME%/icons/THEME/cursors ,
%APPDATA%/icons/THEME/cursors ,
RUNTIME_PREFIX/share/icons/THEME/cursors .
The gtk-cursor-theme-size setting is ignored, GTK will use the cursor size that Windows tells it to use.
More information about GTK on Windows, including detailed build
instructions, binary downloads, etc, can be found
online .
docs/reference/gtk/x11.xml 0000664 0001750 0001750 00000011361 13640771677 015540 0 ustar mclasen mclasen
Using GTK on the X Window System
3
GTK Library
Using GTK on the X Window System
X11-specific aspects of using GTK
GTK for the X Window System
On UNIX, the X backend is the default build for GTK.
So you don't need to do anything special when compiling it,
and everything should "just work."
To mix low-level Xlib routines into a GTK program,
see GDK X Window
System interaction in the GDK manual.
X11-specific commandline options
The X backend understands some additional command line arguments.
--display display
The name of the X display to open instead of the one specified
in the DISPLAY environment variable.
X11-specific environment variables
The X11 GDK backend can be influenced with some additional environment variables.
GDK_SYNCHRONIZE
If set, GDK makes all X requests synchronously. This is a useful
option for debugging, but it will slow down the performance considerably.
GDK_SCALE
Must be set to an integer, typically 2. If set, GDK will scale all
windows by the specified factor. Scaled output is meant to be used on
high-dpi displays. Normally, GDK will pick up a suitable scale factor
for each monitor from the display system. This environment variable
allows to override that.
Understanding the X11 architecture
People coming from a Windows or MacOS background often find certain
aspects of the X Window System surprising. This section introduces
some basic X concepts at a high level. For more details, the book most
people use is called the Xlib Programming
Manual by Adrian Nye; this book is volume one in the
O'Reilly X Window System series.
Standards are another important resource if you're poking in low-level
X11 details, in particular the ICCCM and the Extended Window Manager
Hints specifications. freedesktop.org
has links to many relevant specifications.
The GDK manual covers using Xlib in a GTK
program.
Server, client, window manager
Other window systems typically put all their functionality in the
application itself. With X, each application involves three different
programs: the X server , the application (called
a client because it's a client of the X
server), and a special client called the window
manager .
The X server is in charge of managing resources, processing drawing
requests, and dispatching events such as keyboard and mouse events to
interested applications. So client applications can ask the X server
to create a window, draw a circle, or move windows around.
The window manager is in charge of rendering the frame or borders
around windows; it also has final say on the size of each window,
and window states such as minimized, maximized, and so forth.
On Windows and MacOS the application handles most of this.
On X11, if you wish to modify the window's state, or
change its frame, you must ask the window manager to do so on your
behalf, using an established convention .
GTK has functions for asking the window manager to do various things;
see for example gtk_window_minimize() or gtk_window_maximize() or gtk_window_set_decorated().
Keep in mind that most window managers will ignore
certain requests from time to time, in the interests of good user interface.
docs/reference/gtk/gtk4-docs.xml 0000664 0001750 0001750 00000041442 13640771677 016731 0 ustar mclasen mclasen
]>
GTK 4 Reference Manual
This document is for the GTK 4 library, version &version;.
The latest versions can be found online at
https://developer.gnome.org/gtk4/ .
If you are looking for the older GTK 3 series of libraries,
see https://developer.gnome.org/gtk3/ .
GTK Overview
GTK Widgets and Objects
Object Hierarchy
Widget Gallery
GListModel support
Application support
Interface builder
Windows
Layout Containers
Layout Managers
Display Widgets
Media Support
Buttons and Toggles
Numeric and Text Data Entry
Multiline Text Editor
Tree, List and Icon Grid Widgets
Menus, Combo Box
Selector Widgets and Dialogs
Widgets for custom drawing
Ornaments
Scrolling
Printing
Shortcuts Overview
Miscellaneous
Abstract Base Classes
Recently Used Documents
Choosing from installed applications
Gestures and event handling
Keyboard shortcuts
Data exchange, clipboards and Drag-and-Drop
GTK Core Reference
Theming in GTK
Migrating from Previous Versions of GTK
This part describes what you need to change in programs use
older versions of GTK so that they can use the new features.
It also mentions how to convert applications using widgets
found in the libgnomeui library to use their counterparts
in GTK.
GTK Tools
GTK Platform Support
Index of all symbols
Index of deprecated symbols
docs/reference/gtk/gtk4-sections.txt 0000664 0001750 0001750 00000477247 13640771677 017667 0 ustar mclasen mclasen
gtkaboutdialog
GtkAboutDialog
GtkAboutDialog
GtkLicense
gtk_about_dialog_new
gtk_about_dialog_get_program_name
gtk_about_dialog_set_program_name
gtk_about_dialog_get_version
gtk_about_dialog_set_version
gtk_about_dialog_get_copyright
gtk_about_dialog_set_copyright
gtk_about_dialog_get_comments
gtk_about_dialog_set_comments
gtk_about_dialog_get_license
gtk_about_dialog_set_license
gtk_about_dialog_get_wrap_license
gtk_about_dialog_set_wrap_license
gtk_about_dialog_get_license_type
gtk_about_dialog_set_license_type
gtk_about_dialog_get_website
gtk_about_dialog_set_website
gtk_about_dialog_get_website_label
gtk_about_dialog_set_website_label
gtk_about_dialog_get_authors
gtk_about_dialog_set_authors
gtk_about_dialog_get_artists
gtk_about_dialog_set_artists
gtk_about_dialog_get_documenters
gtk_about_dialog_set_documenters
gtk_about_dialog_get_translator_credits
gtk_about_dialog_set_translator_credits
gtk_about_dialog_get_logo
gtk_about_dialog_set_logo
gtk_about_dialog_get_logo_icon_name
gtk_about_dialog_set_logo_icon_name
gtk_about_dialog_get_system_information
gtk_about_dialog_set_system_information
gtk_about_dialog_add_credit_section
gtk_show_about_dialog
GTK_ABOUT_DIALOG
GTK_IS_ABOUT_DIALOG
GTK_TYPE_ABOUT_DIALOG
GTK_ABOUT_DIALOG_CLASS
GTK_IS_ABOUT_DIALOG_CLASS
GTK_ABOUT_DIALOG_GET_CLASS
GtkAboutDialogPrivate
gtk_about_dialog_get_type
gtkaccelgroup
Keyboard Accelerators
gtk_accelerator_valid
gtk_accelerator_parse
gtk_accelerator_name
gtk_accelerator_get_label
gtk_accelerator_parse_with_keycode
gtk_accelerator_name_with_keycode
gtk_accelerator_get_label_with_keycode
gtk_accelerator_set_default_mod_mask
gtk_accelerator_get_default_mod_mask
gtkaccellabel
GtkAccelLabel
GtkAccelLabel
gtk_accel_label_new
gtk_accel_label_get_accel_width
gtk_accel_label_set_accel
gtk_accel_label_get_accel
gtk_accel_label_refetch
gtk_accel_label_set_label
gtk_accel_label_get_label
GTK_ACCEL_LABEL
GTK_IS_ACCEL_LABEL
GTK_TYPE_ACCEL_LABEL
GTK_ACCEL_LABEL_CLASS
GTK_IS_ACCEL_LABEL_CLASS
GTK_ACCEL_LABEL_GET_CLASS
GtkAccelLabelPrivate
gtk_accel_label_get_type
gtkaccessible
GtkAccessible
GtkAccessible
gtk_accessible_get_widget
gtk_accessible_set_widget
GTK_ACCESSIBLE
GTK_TYPE_ACCESSIBLE
GTK_ACCESSIBLE_CLASS
GTK_ACCESSIBLE_GET_CLASS
GTK_IS_ACCESSIBLE
GTK_IS_ACCESSIBLE_CLASS
GtkAccessiblePrivate
gtk_accessible_get_type
gtkadjustment
GtkAdjustment
GtkAdjustment
gtk_adjustment_new
gtk_adjustment_get_value
gtk_adjustment_set_value
gtk_adjustment_clamp_page
gtk_adjustment_configure
gtk_adjustment_get_lower
gtk_adjustment_get_page_increment
gtk_adjustment_get_page_size
gtk_adjustment_get_step_increment
gtk_adjustment_get_minimum_increment
gtk_adjustment_get_upper
gtk_adjustment_set_lower
gtk_adjustment_set_page_increment
gtk_adjustment_set_page_size
gtk_adjustment_set_step_increment
gtk_adjustment_set_upper
GTK_ADJUSTMENT
GTK_IS_ADJUSTMENT
GTK_TYPE_ADJUSTMENT
GTK_ADJUSTMENT_CLASS
GTK_IS_ADJUSTMENT_CLASS
GTK_ADJUSTMENT_GET_CLASS
GtkAdjustmentPrivate
gtk_adjustment_get_type
gtkassistant
GtkAssistant
GtkAssistant
GtkAssistantPage
gtk_assistant_new
gtk_assistant_get_page
gtk_assistant_get_pages
gtk_assistant_page_get_child
gtk_assistant_get_current_page
gtk_assistant_set_current_page
gtk_assistant_get_n_pages
gtk_assistant_get_nth_page
gtk_assistant_prepend_page
gtk_assistant_append_page
gtk_assistant_insert_page
gtk_assistant_remove_page
GtkAssistantPageFunc
gtk_assistant_set_forward_page_func
GtkAssistantPageType
gtk_assistant_set_page_type
gtk_assistant_get_page_type
gtk_assistant_set_page_title
gtk_assistant_get_page_title
gtk_assistant_set_page_complete
gtk_assistant_get_page_complete
gtk_assistant_add_action_widget
gtk_assistant_remove_action_widget
gtk_assistant_update_buttons_state
gtk_assistant_commit
gtk_assistant_next_page
gtk_assistant_previous_page
GTK_TYPE_ASSISTANT
GTK_ASSISTANT
GTK_ASSISTANT_CLASS
GTK_IS_ASSISTANT
GTK_IS_ASSISTANT_CLASS
GTK_ASSISTANT_GET_CLASS
GtkAssistantPrivate
gtk_assistant_get_type
gtkaspectframe
GtkAspectFrame
GtkAspectFrame
gtk_aspect_frame_new
gtk_aspect_frame_set
GTK_ASPECT_FRAME
GTK_IS_ASPECT_FRAME
GTK_TYPE_ASPECT_FRAME
GTK_ASPECT_FRAME_CLASS
GTK_IS_ASPECT_FRAME_CLASS
GTK_ASPECT_FRAME_GET_CLASS
GtkAspectFramePrivate
gtk_aspect_frame_get_type
gtkbin
GtkBin
GtkBin
GtkBinClass
gtk_bin_get_child
GTK_BIN
GTK_IS_BIN
GTK_TYPE_BIN
GTK_BIN_CLASS
GTK_IS_BIN_CLASS
GTK_BIN_GET_CLASS
GtkBinPrivate
gtk_bin_get_type
gtkbox
GtkBox
GtkBox
GtkBoxClass
gtk_box_new
gtk_box_get_homogeneous
gtk_box_set_homogeneous
gtk_box_get_spacing
gtk_box_set_spacing
gtk_box_get_baseline_position
gtk_box_set_baseline_position
gtk_box_insert_child_after
gtk_box_reorder_child_after
GTK_BOX
GTK_IS_BOX
GTK_TYPE_BOX
GTK_BOX_CLASS
GTK_IS_BOX_CLASS
GTK_BOX_GET_CLASS
GtkBoxPrivate
gtk_box_get_type
gtkcenterbox
GtkCenterBox
GtkCenterBox
gtk_center_box_new
gtk_center_box_set_start_widget
gtk_center_box_set_center_widget
gtk_center_box_set_end_widget
gtk_center_box_get_start_widget
gtk_center_box_get_center_widget
gtk_center_box_get_end_widget
gtk_center_box_set_baseline_position
gtk_center_box_get_baseline_position
GTK_TYPE_CENTER_BOX
GTK_CENTER_BOX
GTK_CENTER_BOX_CLASS
GTK_IS_CENTER_BOX
GTK_IS_CENTER_BOX_CLASS
GTK_CENTER_BOX_GET_CLASS
gtk_center_box_get_type
gtkcenterlayout
GtkCenterLayout
GtkCenterLayout
gtk_center_layout_new
gtk_center_layout_set_start_widget
gtk_center_layout_set_center_widget
gtk_center_layout_set_end_widget
gtk_center_layout_get_start_widget
gtk_center_layout_get_center_widget
gtk_center_layout_get_end_widget
gtk_center_layout_set_baseline_position
gtk_center_layout_get_baseline_position
GTK_TYPE_CENTER_layout
GTK_CENTER_LAYOUT
GTK_CENTER_LAYOUT_CLASS
GTK_IS_CENTER_LAYOUT
GTK_IS_CENTER_LAYOUT_CLASS
GTK_CENTER_LAYOUT_GET_CLASS
gtk_center_layout_get_type
gtklistbox
GtkListBox
GtkListBox
GtkListBoxRow
GtkListBoxRowClass
GtkListBoxFilterFunc
GtkListBoxSortFunc
GtkListBoxUpdateHeaderFunc
gtk_list_box_new
gtk_list_box_prepend
gtk_list_box_insert
gtk_list_box_select_row
gtk_list_box_unselect_row
gtk_list_box_select_all
gtk_list_box_unselect_all
gtk_list_box_get_selected_row
GtkListBoxForeachFunc
gtk_list_box_selected_foreach
gtk_list_box_get_selected_rows
gtk_list_box_set_show_separators
gtk_list_box_get_show_separators
gtk_list_box_set_selection_mode
gtk_list_box_get_selection_mode
gtk_list_box_set_activate_on_single_click
gtk_list_box_get_activate_on_single_click
gtk_list_box_get_adjustment
gtk_list_box_set_adjustment
gtk_list_box_set_placeholder
gtk_list_box_get_row_at_index
gtk_list_box_get_row_at_y
gtk_list_box_invalidate_filter
gtk_list_box_invalidate_headers
gtk_list_box_invalidate_sort
gtk_list_box_set_filter_func
gtk_list_box_set_header_func
gtk_list_box_set_sort_func
gtk_list_box_drag_highlight_row
gtk_list_box_drag_unhighlight_row
GtkListBoxCreateWidgetFunc
gtk_list_box_bind_model
gtk_list_box_row_new
gtk_list_box_row_changed
gtk_list_box_row_is_selected
gtk_list_box_row_get_header
gtk_list_box_row_set_header
gtk_list_box_row_get_index
gtk_list_box_row_set_activatable
gtk_list_box_row_get_activatable
gtk_list_box_row_set_selectable
gtk_list_box_row_get_selectable
GTK_LIST_BOX
GTK_LIST_BOX_CLASS
GTK_LIST_BOX_GET_CLASS
GTK_LIST_BOX_ROW
GTK_LIST_BOX_ROW_CLASS
GTK_LIST_BOX_ROW_GET_CLASS
GTK_IS_LIST_BOX
GTK_IS_LIST_BOX_CLASS
GTK_IS_LIST_BOX_ROW
GTK_IS_LIST_BOX_ROW_CLASS
GTK_TYPE_LIST_BOX
GTK_TYPE_LIST_BOX_ROW
gtk_list_box_get_type
gtk_list_box_row_get_type
gtkselectionmodel
GtkSelectionModel
GtkSelectionModel
gtk_selection_model_is_selected
gtk_selection_model_select_item
gtk_selection_model_unselect_item
gtk_selection_model_select_range
gtk_selection_model_unselect_range
gtk_selection_model_select_all
gtk_selection_model_unselect_all
gtk_selection_model_query_range
gtk_selection_model_selection_changed
GTK_SELECTION_MODEL
GTK_SELECTION_MODEL_CLASS
GTK_SELECTION_MODEL_GET_CLASS
GTK_IS_SELECTION_MODEL
GTK_IS_SELECTION_MODEL_CLASS
GTK_TYPE_SELECTION_MODEL
gtk_selection_model_get_type
gtknoselection
GtkNoSelection
GtkNoSelection
gtk_no_selection_new
gtk_no_selection_get_model
gtk_no_selection_get_type
gtksingleselection
GtkSingleSelection
GtkSingleSelection
GTK_INVALID_LIST_POSITION
gtk_single_selection_new
gtk_single_selection_get_model
gtk_single_selection_get_selected
gtk_single_selection_set_selected
gtk_single_selection_get_selected_item
gtk_single_selection_get_autoselect
gtk_single_selection_set_autoselect
gtk_single_selection_get_can_unselect
gtk_single_selection_set_can_unselect
gtk_single_selection_get_type
gtkbuildable
GtkBuildable
GtkBuildableIface
gtk_buildable_set_name
gtk_buildable_get_name
gtk_buildable_add_child
gtk_buildable_set_buildable_property
gtk_buildable_construct_child
gtk_buildable_custom_tag_start
gtk_buildable_custom_tag_end
gtk_buildable_custom_finished
gtk_buildable_parser_finished
gtk_buildable_get_internal_child
GTK_BUILDABLE
GTK_IS_BUILDABLE
GTK_TYPE_BUILDABLE
gtk_buildable_get_type
GTK_BUILDABLE_CLASS
GTK_BUILDABLE_GET_IFACE
gtkbuilderscope
GtkBuilderScope
gtk_builder_cscope_new
gtk_builder_cscope_add_callback_symbol
gtk_builder_cscope_add_callback_symbols
gtk_builder_cscope_lookup_callback_symbol
GTK_BUILDER_SCOPE
GTK_IS_BUILDER_SCOPE
GTK_TYPE_BUILDER_SCOPE
GTK_BUILDER_SCOPE_INTERFACE
GTK_IS_BUILDER_SCOPE_INTERFACE
GTK_BUILDER_SCOPE_GET_INTERFACE
GTK_BUILDER_CSCOPE
GTK_IS_BUILDER_CSCOPE
GTK_TYPE_BUILDER_CSCOPE
GTK_BUILDER_CSCOPE_CLASS
GTK_IS_BUILDER_CSCOPE_CLASS
GTK_BUILDER_CSCOPE_GET_CLASS
gtk_builder_scope_get_type
gtk_builder_cscope_get_type
gtkbuilder
GtkBuilder
GtkBuilder
GtkBuilderError
gtk_builder_new
gtk_builder_new_from_file
gtk_builder_new_from_resource
gtk_builder_new_from_string
gtk_builder_create_closure
gtk_builder_add_from_file
gtk_builder_add_from_resource
gtk_builder_add_from_string
gtk_builder_add_objects_from_file
gtk_builder_add_objects_from_string
gtk_builder_add_objects_from_resource
gtk_builder_extend_with_template
gtk_builder_get_object
gtk_builder_get_objects
gtk_builder_expose_object
gtk_builder_set_current_object
gtk_builder_get_current_object
gtk_builder_set_scope
gtk_builder_get_scope
gtk_builder_set_translation_domain
gtk_builder_get_translation_domain
gtk_builder_get_type_from_name
gtk_builder_value_from_string
gtk_builder_value_from_string_type
GTK_BUILDER_WARN_INVALID_CHILD_TYPE
GTK_BUILDER_ERROR
GTK_BUILDER
GTK_IS_BUILDER
GTK_TYPE_BUILDER
GTK_BUILDER_CLASS
GTK_IS_BUILDER_CLASS
GTK_BUILDER_GET_CLASS
gtk_builder_get_type
gtk_builder_error_quark
gtkbutton
GtkButton
GtkButton
GtkButtonClass
gtk_button_new
gtk_button_new_with_label
gtk_button_new_with_mnemonic
gtk_button_new_from_icon_name
gtk_button_set_relief
gtk_button_get_relief
gtk_button_get_label
gtk_button_set_label
gtk_button_get_use_underline
gtk_button_set_use_underline
gtk_button_set_icon_name
gtk_button_get_icon_name
GTK_BUTTON
GTK_IS_BUTTON
GTK_TYPE_BUTTON
GTK_BUTTON_CLASS
GTK_IS_BUTTON_CLASS
GTK_BUTTON_GET_CLASS
GtkButtonPrivate
gtk_button_get_type
gtkcalendar
GtkCalendar
GtkCalendar
gtk_calendar_new
gtk_calendar_select_day
gtk_calendar_mark_day
gtk_calendar_unmark_day
gtk_calendar_get_day_is_marked
gtk_calendar_clear_marks
gtk_calendar_get_date
GTK_CALENDAR
GTK_IS_CALENDAR
GTK_TYPE_CALENDAR
GTK_CALENDAR_CLASS
GTK_IS_CALENDAR_CLASS
GTK_CALENDAR_GET_CLASS
GtkCalendarPrivate
gtk_calendar_get_type
gtkcheckbutton
GtkCheckButton
GtkCheckButton
gtk_check_button_new
gtk_check_button_new_with_label
gtk_check_button_new_with_mnemonic
gtk_check_button_get_draw_indicator
gtk_check_button_set_draw_indicator
gtk_check_button_get_inconsistent
gtk_check_button_set_inconsistent
GTK_CHECK_BUTTON
GTK_IS_CHECK_BUTTON
GTK_TYPE_CHECK_BUTTON
GTK_CHECK_BUTTON_CLASS
GTK_IS_CHECK_BUTTON_CLASS
GTK_CHECK_BUTTON_GET_CLASS
gtk_check_button_get_type
gtkcolorbutton
GtkColorButton
GtkColorButton
gtk_color_button_new
gtk_color_button_new_with_rgba
gtk_color_button_set_title
gtk_color_button_get_title
GTK_COLOR_BUTTON
GTK_IS_COLOR_BUTTON
GTK_TYPE_COLOR_BUTTON
GTK_COLOR_BUTTON_CLASS
GTK_IS_COLOR_BUTTON_CLASS
GTK_COLOR_BUTTON_GET_CLASS
gtk_color_button_get_type
GtkColorButtonPrivate
gtkcombobox
GtkComboBox
GtkComboBox
GtkComboBoxClass
gtk_combo_box_new
gtk_combo_box_new_with_entry
gtk_combo_box_new_with_model
gtk_combo_box_new_with_model_and_entry
gtk_combo_box_get_active
gtk_combo_box_set_active
gtk_combo_box_get_active_iter
gtk_combo_box_set_active_iter
gtk_combo_box_get_id_column
gtk_combo_box_set_id_column
gtk_combo_box_get_active_id
gtk_combo_box_set_active_id
gtk_combo_box_get_model
gtk_combo_box_set_model
gtk_combo_box_popdown
gtk_combo_box_get_popup_accessible
gtk_combo_box_get_row_separator_func
gtk_combo_box_set_row_separator_func
GtkSensitivityType
gtk_combo_box_set_button_sensitivity
gtk_combo_box_get_button_sensitivity
gtk_combo_box_get_has_entry
gtk_combo_box_set_entry_text_column
gtk_combo_box_get_entry_text_column
gtk_combo_box_set_popup_fixed_width
gtk_combo_box_get_popup_fixed_width
GTK_TYPE_COMBO_BOX
GTK_COMBO_BOX
GTK_COMBO_BOX_CLASS
GTK_IS_COMBO_BOX
GTK_IS_COMBO_BOX_CLASS
GTK_COMBO_BOX_GET_CLASS
GtkComboBoxPrivate
gtk_combo_box_get_type
gtkcomboboxtext
GtkComboBoxText
GtkComboBoxText
gtk_combo_box_text_new
gtk_combo_box_text_new_with_entry
gtk_combo_box_text_append
gtk_combo_box_text_prepend
gtk_combo_box_text_insert
gtk_combo_box_text_append_text
gtk_combo_box_text_prepend_text
gtk_combo_box_text_insert_text
gtk_combo_box_text_remove
gtk_combo_box_text_remove_all
gtk_combo_box_text_get_active_text
GTK_TYPE_COMBO_BOX_TEXT
GTK_COMBO_BOX_TEXT
GTK_IS_COMBO_BOX_TEXT
GTK_COMBO_BOX_TEXT_CLASS
GTK_IS_COMBO_BOX_TEXT_CLASS
GTK_COMBO_BOX_TEXT_GET_CLASS
GtkComboBoxTextPrivate
gtk_combo_box_text_get_type
gtkcontainer
GtkContainer
GtkContainer
GtkContainerClass
gtk_container_add
gtk_container_remove
gtk_container_foreach
gtk_container_get_children
gtk_container_get_focus_vadjustment
gtk_container_set_focus_vadjustment
gtk_container_get_focus_hadjustment
gtk_container_set_focus_hadjustment
gtk_container_child_type
gtk_container_forall
GTK_CONTAINER
GTK_IS_CONTAINER
GTK_TYPE_CONTAINER
GTK_CONTAINER_CLASS
GTK_IS_CONTAINER_CLASS
GTK_CONTAINER_GET_CLASS
GtkContainerPrivate
gtk_container_get_type
gtkdialog
GtkDialog
GtkDialog
GtkDialogClass
GtkDialogFlags
GtkResponseType
gtk_dialog_new
gtk_dialog_new_with_buttons
gtk_dialog_run
gtk_dialog_response
gtk_dialog_add_button
gtk_dialog_add_buttons
gtk_dialog_add_action_widget
gtk_dialog_set_default_response
gtk_dialog_set_response_sensitive
gtk_dialog_get_response_for_widget
gtk_dialog_get_widget_for_response
gtk_dialog_get_content_area
gtk_dialog_get_header_bar
GTK_DIALOG
GTK_IS_DIALOG
GTK_TYPE_DIALOG
GTK_DIALOG_CLASS
GTK_IS_DIALOG_CLASS
GTK_DIALOG_GET_CLASS
GtkDialogPrivate
gtk_dialog_get_type
gtkdrawingarea
GtkDrawingArea
GtkDrawingArea
gtk_drawing_area_new
gtk_drawing_area_get_content_width
gtk_drawing_area_set_content_width
gtk_drawing_area_get_content_height
gtk_drawing_area_set_content_height
GtkDrawingAreaDrawFunc
gtk_drawing_area_set_draw_func
GTK_DRAWING_AREA
GTK_IS_DRAWING_AREA
GTK_TYPE_DRAWING_AREA
GTK_DRAWING_AREA_CLASS
GTK_IS_DRAWING_AREA_CLASS
GTK_DRAWING_AREA_GET_CLASS
gtk_drawing_area_get_type
gtkeditable
GtkEditable
GtkEditable
gtk_editable_get_text
gtk_editable_set_text
gtk_editable_get_chars
gtk_editable_insert_text
gtk_editable_delete_text
gtk_editable_get_selection_bounds
gtk_editable_select_region
gtk_editable_delete_selection
gtk_editable_set_position
gtk_editable_get_position
gtk_editable_set_editable
gtk_editable_get_editable
gtk_editable_set_alignment
gtk_editable_get_alignment
gtk_editable_get_width_chars
gtk_editable_set_width_chars
gtk_editable_get_max_width_chars
gtk_editable_set_max_width_chars
gtk_editable_get_enable_undo
gtk_editable_set_enable_undo
gtk_editable_install_properties
gtk_editable_init_delegate
gtk_editable_finish_delegate
gtk_editable_delegate_set_property
gtk_editable_delegate_get_property
GTK_EDITABLE
GTK_IS_EDITABLE
GTK_TYPE_EDITABLE
GTK_EDITABLE_GET_IFACE
gtk_editable_get_type
gtktext
GtkText
GtkText
GtkTextClass
gtk_text_new
gtk_text_new_with_buffer
gtk_text_set_buffer
gtk_text_get_buffer
gtk_text_set_visibility
gtk_text_get_visibility
gtk_text_set_invisible_char
gtk_text_get_invisible_char
gtk_text_unset_invisible_char
gtk_text_set_overwrite_mode
gtk_text_get_overwrite_mode
gtk_text_set_max_length
gtk_text_get_max_length
gtk_text_get_text_length
gtk_text_set_activates_default
gtk_text_get_activates_default
gtk_text_set_placeholder_text
gtk_text_get_placeholder_text
gtk_text_set_input_purpose
gtk_text_get_input_purpose
gtk_text_set_input_hints
gtk_text_get_input_hints
gtk_text_set_attributes
gtk_text_get_attributes
gtk_text_set_tabs
gtk_text_get_tabs
gtk_text_grab_focus_without_selecting
gtk_text_set_extra_menu
gtk_text_get_extra_menu
gtk_text_get_type
gtkentry
GtkEntry
GtkEntry
GtkEntryClass
gtk_entry_new
gtk_entry_new_with_buffer
gtk_entry_get_buffer
gtk_entry_set_buffer
gtk_entry_get_text_length
gtk_entry_set_visibility
gtk_entry_get_visibility
gtk_entry_set_invisible_char
gtk_entry_get_invisible_char
gtk_entry_unset_invisible_char
gtk_entry_set_max_length
gtk_entry_get_max_length
gtk_entry_set_activates_default
gtk_entry_get_activates_default
gtk_entry_set_has_frame
gtk_entry_get_has_frame
gtk_entry_set_alignment
gtk_entry_get_alignment
gtk_entry_set_placeholder_text
gtk_entry_get_placeholder_text
gtk_entry_set_overwrite_mode
gtk_entry_get_overwrite_mode
gtk_entry_set_attributes
gtk_entry_get_attributes
gtk_entry_set_completion
gtk_entry_get_completion
gtk_entry_set_progress_fraction
gtk_entry_get_progress_fraction
gtk_entry_set_progress_pulse_step
gtk_entry_get_progress_pulse_step
gtk_entry_progress_pulse
gtk_entry_reset_im_context
gtk_entry_set_tabs
gtk_entry_get_tabs
GtkEntryIconPosition
gtk_entry_set_icon_from_paintable
gtk_entry_set_icon_from_icon_name
gtk_entry_set_icon_from_gicon
gtk_entry_get_icon_storage_type
gtk_entry_get_icon_paintable
gtk_entry_get_icon_name
gtk_entry_get_icon_gicon
gtk_entry_set_icon_activatable
gtk_entry_get_icon_activatable
gtk_entry_set_icon_sensitive
gtk_entry_get_icon_sensitive
gtk_entry_get_icon_at_pos
gtk_entry_set_icon_tooltip_text
gtk_entry_get_icon_tooltip_text
gtk_entry_set_icon_tooltip_markup
gtk_entry_get_icon_tooltip_markup
gtk_entry_set_icon_drag_source
gtk_entry_get_current_icon_drag_source
gtk_entry_get_icon_area
GtkInputPurpose
gtk_entry_set_input_purpose
gtk_entry_get_input_purpose
GtkInputHints
gtk_entry_set_input_hints
gtk_entry_get_input_hints
gtk_entry_grab_focus_without_selecting
gtk_entry_set_extra_menu
gtk_entry_get_extra_menu
GTK_ENTRY
GTK_IS_ENTRY
GTK_TYPE_ENTRY
GTK_ENTRY_CLASS
GTK_IS_ENTRY_CLASS
GTK_ENTRY_GET_CLASS
GTK_TYPE_TEXT_HANDLE_POSITION
GTK_TYPE_TEXT_HANDLE_MODE
GtkEntryPrivate
gtk_entry_get_type
gtkpasswordentry
GtkPasswordEntry
GtkPasswordEntry
gtk_password_entry_new
gtk_password_entry_set_show_peek_icon
gtk_password_entry_get_show_peek_icon
gtk_password_entry_set_extra_menu
gtk_password_entry_get_extra_menu
gtk_password_entry_get_type
gtkentrybuffer
GtkEntryBuffer
GtkEntryBuffer
gtk_entry_buffer_new
gtk_entry_buffer_get_text
gtk_entry_buffer_set_text
gtk_entry_buffer_get_bytes
gtk_entry_buffer_get_length
gtk_entry_buffer_get_max_length
gtk_entry_buffer_set_max_length
gtk_entry_buffer_insert_text
gtk_entry_buffer_delete_text
gtk_entry_buffer_emit_deleted_text
gtk_entry_buffer_emit_inserted_text
GTK_ENTRY_BUFFER
GTK_IS_ENTRY_BUFFER
GTK_TYPE_ENTRY_BUFFER
GTK_ENTRY_BUFFER_CLASS
GTK_IS_ENTRY_BUFFER_CLASS
GTK_ENTRY_BUFFER_GET_CLASS
GTK_ENTRY_BUFFER_MAX_SIZE
GtkEntryBufferPrivate
gtk_entry_buffer_get_type
gtkentrycompletion
GtkEntryCompletion
GtkEntryCompletion
GtkEntryCompletionMatchFunc
gtk_entry_completion_new
gtk_entry_completion_new_with_area
gtk_entry_completion_get_entry
gtk_entry_completion_set_model
gtk_entry_completion_get_model
gtk_entry_completion_set_match_func
gtk_entry_completion_set_minimum_key_length
gtk_entry_completion_get_minimum_key_length
gtk_entry_completion_compute_prefix
gtk_entry_completion_complete
gtk_entry_completion_get_completion_prefix
gtk_entry_completion_insert_prefix
gtk_entry_completion_insert_action_text
gtk_entry_completion_insert_action_markup
gtk_entry_completion_delete_action
gtk_entry_completion_set_text_column
gtk_entry_completion_get_text_column
gtk_entry_completion_set_inline_completion
gtk_entry_completion_get_inline_completion
gtk_entry_completion_set_inline_selection
gtk_entry_completion_get_inline_selection
gtk_entry_completion_set_popup_completion
gtk_entry_completion_get_popup_completion
gtk_entry_completion_set_popup_set_width
gtk_entry_completion_get_popup_set_width
gtk_entry_completion_set_popup_single_match
gtk_entry_completion_get_popup_single_match
GTK_TYPE_ENTRY_COMPLETION
GTK_ENTRY_COMPLETION
GTK_ENTRY_COMPLETION_CLASS
GTK_IS_ENTRY_COMPLETION
GTK_IS_ENTRY_COMPLETION_CLASS
GTK_ENTRY_COMPLETION_GET_CLASS
GtkEntryCompletionPrivate
gtk_entry_completion_get_type
gtkexpander
GtkExpander
GtkExpander
gtk_expander_new
gtk_expander_new_with_mnemonic
gtk_expander_set_expanded
gtk_expander_get_expanded
gtk_expander_set_label
gtk_expander_get_label
gtk_expander_set_use_underline
gtk_expander_get_use_underline
gtk_expander_set_use_markup
gtk_expander_get_use_markup
gtk_expander_set_label_widget
gtk_expander_get_label_widget
gtk_expander_set_resize_toplevel
gtk_expander_get_resize_toplevel
GTK_TYPE_EXPANDER
GTK_EXPANDER_CLASS
GTK_EXPANDER
GTK_IS_EXPANDER
GTK_IS_EXPANDER_CLASS
GTK_EXPANDER_GET_CLASS
gtk_expander_get_type
GtkExpanderPrivate
gtkfilechooser
GtkFileChooser
GtkFileChooser
GtkFileChooserAction
GTK_FILE_CHOOSER_ERROR
GtkFileChooserError
gtk_file_chooser_set_action
gtk_file_chooser_get_action
gtk_file_chooser_set_select_multiple
gtk_file_chooser_get_select_multiple
gtk_file_chooser_set_create_folders
gtk_file_chooser_get_create_folders
gtk_file_chooser_set_current_name
gtk_file_chooser_get_current_name
gtk_file_chooser_get_file
gtk_file_chooser_set_file
gtk_file_chooser_select_file
gtk_file_chooser_unselect_file
gtk_file_chooser_select_all
gtk_file_chooser_unselect_all
gtk_file_chooser_get_files
gtk_file_chooser_set_current_folder
gtk_file_chooser_get_current_folder
gtk_file_chooser_add_filter
gtk_file_chooser_remove_filter
gtk_file_chooser_list_filters
gtk_file_chooser_set_filter
gtk_file_chooser_get_filter
gtk_file_chooser_add_shortcut_folder
gtk_file_chooser_remove_shortcut_folder
gtk_file_chooser_list_shortcut_folders
gtk_file_chooser_add_choice
gtk_file_chooser_remove_choice
gtk_file_chooser_set_choice
gtk_file_chooser_get_choice
GTK_FILE_CHOOSER
GTK_IS_FILE_CHOOSER
GTK_TYPE_FILE_CHOOSER
gtk_file_chooser_error_quark
gtk_file_chooser_get_type
gtkfilechoosernative
GtkFileChooserNative
gtk_file_chooser_native_new
gtk_file_chooser_native_get_accept_label
gtk_file_chooser_native_set_accept_label
gtk_file_chooser_native_get_cancel_label
gtk_file_chooser_native_set_cancel_label
GTK_FILE_CHOOSER_NATIVE
GTK_IS_FILE_CHOOSER_NATIVE
GTK_TYPE_FILE_CHOOSER_NATIVE
GTK_FILE_CHOOSER_NATIVE_CLASS
GTK_IS_FILE_CHOOSER_NATIVE_CLASS
GTK_FILE_CHOOSER_NATIVE_GET_CLASS
gtk_file_chooser_native_get_type
gtkfilechooserdialog
GtkFileChooserDialog
GtkFileChooserDialog
gtk_file_chooser_dialog_new
GTK_FILE_CHOOSER_DIALOG
GTK_IS_FILE_CHOOSER_DIALOG
GTK_TYPE_FILE_CHOOSER_DIALOG
GTK_FILE_CHOOSER_DIALOG_CLASS
GTK_IS_FILE_CHOOSER_DIALOG_CLASS
GTK_FILE_CHOOSER_DIALOG_GET_CLASS
gtk_file_chooser_dialog_get_type
GtkFileChooserDialogPrivate
gtkfilechooserwidget
GtkFileChooserWidget
GtkFileChooserWidget
gtk_file_chooser_widget_new
GTK_FILE_CHOOSER_WIDGET
GTK_IS_FILE_CHOOSER_WIDGET
GTK_TYPE_FILE_CHOOSER_WIDGET
GTK_FILE_CHOOSER_WIDGET_CLASS
GTK_IS_FILE_CHOOSER_WIDGET_CLASS
GTK_FILE_CHOOSER_WIDGET_GET_CLASS
gtk_file_chooser_widget_get_type
GtkFileChooserWidgetPrivate
gtkfilechooserbutton
GtkFileChooserButton
GtkFileChooserButton
gtk_file_chooser_button_new
gtk_file_chooser_button_new_with_dialog
gtk_file_chooser_button_get_title
gtk_file_chooser_button_set_title
gtk_file_chooser_button_get_width_chars
gtk_file_chooser_button_set_width_chars
GTK_FILE_CHOOSER_BUTTON
GTK_IS_FILE_CHOOSER_BUTTON
GTK_TYPE_FILE_CHOOSER_BUTTON
GTK_FILE_CHOOSER_BUTTON_CLASS
GTK_IS_FILE_CHOOSER_BUTTON_CLASS
GTK_FILE_CHOOSER_BUTTON_GET_CLASS
gtk_file_chooser_button_get_type
GtkFileChooserButtonPrivate
gtkfilefilter
GtkFileFilter
GtkFileFilterInfo
GtkFileFilterFlags
GtkFileFilterFunc
gtk_file_filter_new
gtk_file_filter_set_name
gtk_file_filter_get_name
gtk_file_filter_add_mime_type
gtk_file_filter_add_pattern
gtk_file_filter_add_pixbuf_formats
gtk_file_filter_add_custom
gtk_file_filter_get_needed
gtk_file_filter_filter
gtk_file_filter_new_from_gvariant
gtk_file_filter_to_gvariant
GTK_FILE_FILTER
GTK_IS_FILE_FILTER
GTK_TYPE_FILE_FILTER
gtk_file_filter_get_type
gtkfilterlistmodel
GtkFilterListModel
GtkFilterListModel
gtk_filter_list_model_new
gtk_filter_list_model_new_for_type
gtk_filter_list_model_set_model
gtk_filter_list_model_get_model
gtk_filter_list_model_set_filter_func
gtk_filter_list_model_has_filter
gtk_filter_list_model_refilter
GTK_FILTER_LIST_MODEL
GTK_IS_FILTER_LIST_MODEL
GTK_TYPE_FILTER_LIST_MODEL
GTK_FILTER_LIST_MODEL_CLASS
GTK_IS_FILTER_LIST_MODEL_CLASS
GTK_FILTER_LIST_MODEL_GET_CLASS
gtk_filter_list_model_get_type
gtkfixed
GtkFixed
GtkFixed
gtk_fixed_new
gtk_fixed_put
gtk_fixed_move
GTK_FIXED
GTK_IS_FIXED
GTK_TYPE_FIXED
GTK_FIXED_CLASS
GTK_IS_FIXED_CLASS
GTK_FIXED_GET_CLASS
GtkFixedPrivate
GtkFixedChild
gtk_fixed_get_type
gtkflattenlistmodel
GtkFlattenListModel
GtkFlattenListModel
gtk_flatten_list_model_new
gtk_flatten_list_model_set_model
gtk_flatten_list_model_get_model
gtk_flatten_list_model_get_model_for_item
GTK_FLATTEN_LIST_MODEL
GTK_IS_FLATTEN_LIST_MODEL
GTK_TYPE_FLATTEN_LIST_MODEL
GTK_FLATTEN_LIST_MODEL_CLASS
GTK_IS_FLATTEN_LIST_MODEL_CLASS
GTK_FLATTEN_LIST_MODEL_GET_CLASS
gtk_flatten_list_model_get_type
gtkfontbutton
GtkFontButton
GtkFontButton
gtk_font_button_new
gtk_font_button_new_with_font
gtk_font_button_set_use_font
gtk_font_button_get_use_font
gtk_font_button_set_use_size
gtk_font_button_get_use_size
gtk_font_button_set_title
gtk_font_button_get_title
GTK_FONT_BUTTON
GTK_IS_FONT_BUTTON
GTK_TYPE_FONT_BUTTON
GTK_FONT_BUTTON_CLASS
GTK_IS_FONT_BUTTON_CLASS
GTK_FONT_BUTTON_GET_CLASS
GtkFontButtonPrivate
gtk_font_button_get_type
gtkfontchooser
GtkFontChooser
GtkFontChooser
gtk_font_chooser_get_font_family
gtk_font_chooser_get_font_face
gtk_font_chooser_get_font_size
gtk_font_chooser_get_font
gtk_font_chooser_set_font
gtk_font_chooser_get_font_desc
gtk_font_chooser_set_font_desc
gtk_font_chooser_get_font_features
gtk_font_chooser_get_language
gtk_font_chooser_set_language
gtk_font_chooser_get_preview_text
gtk_font_chooser_set_preview_text
gtk_font_chooser_get_show_preview_entry
gtk_font_chooser_set_show_preview_entry
GtkFontChooserLevel
gtk_font_chooser_get_level
gtk_font_chooser_set_level
GtkFontFilterFunc
gtk_font_chooser_set_filter_func
gtk_font_chooser_set_font_map
gtk_font_chooser_get_font_map
GtkFontChooserIface
GTK_TYPE_FONT_CHOOSER
GTK_FONT_CHOOSER
GTK_FONT_CHOOSER_IFACE
GTK_IS_FONT_CHOOSER
GTK_IS_FONT_CHOOSER_IFACE
GTK_FONT_CHOOSER_GET_IFACE
GTK_FONT_CHOOSER_DELEGATE_QUARK
gtk_font_chooser_get_type
gtkfontchooserwidget
GtkFontChooserWidget
GtkFontChooserWidget
gtk_font_chooser_widget_new
GTK_TYPE_FONT_CHOOSER_WIDGET
GTK_FONT_CHOOSER_WIDGET
GTK_FONT_CHOOSER_WIDGET_CLASS
GTK_IS_FONT_CHOOSER_WIDGET
GTK_IS_FONT_CHOOSER_WIDGET_CLASS
GTK_FONT_CHOOSER_WIDGET_GET_CLASS
GtkFontChooserWidgetPrivate
gtk_font_chooser_widget_get_type
gtkfontchooserdialog
GtkFontChooserDialog
GtkFontChooserDialog
gtk_font_chooser_dialog_new
GTK_TYPE_FONT_CHOOSER_DIALOG
GTK_FONT_CHOOSER_DIALOG
GTK_FONT_CHOOSER_DIALOG_CLASS
GTK_IS_FONT_CHOOSER_DIALOG
GTK_IS_FONT_CHOOSER_DIALOG_CLASS
GTK_FONT_CHOOSER_DIALOG_GET_CLASS
GtkFontChooserDialogPrivate
gtk_font_chooser_dialog_get_type
gtkframe
GtkFrame
GtkFrame
GtkFrameClass
gtk_frame_new
gtk_frame_set_label
gtk_frame_set_label_widget
gtk_frame_set_label_align
gtk_frame_set_shadow_type
gtk_frame_get_label
gtk_frame_get_label_align
gtk_frame_get_label_widget
gtk_frame_get_shadow_type
GTK_FRAME
GTK_IS_FRAME
GTK_TYPE_FRAME
GTK_FRAME_CLASS
GTK_IS_FRAME_CLASS
GTK_FRAME_GET_CLASS
GtkFramePrivate
gtk_frame_get_type
gtkiconview
GtkIconView
GtkIconView
GtkIconViewForeachFunc
gtk_icon_view_new
gtk_icon_view_new_with_area
gtk_icon_view_new_with_model
gtk_icon_view_set_model
gtk_icon_view_get_model
gtk_icon_view_set_text_column
gtk_icon_view_get_text_column
gtk_icon_view_set_markup_column
gtk_icon_view_get_markup_column
gtk_icon_view_set_pixbuf_column
gtk_icon_view_get_pixbuf_column
gtk_icon_view_get_path_at_pos
gtk_icon_view_get_item_at_pos
gtk_icon_view_set_cursor
gtk_icon_view_get_cursor
gtk_icon_view_selected_foreach
gtk_icon_view_set_selection_mode
gtk_icon_view_get_selection_mode
gtk_icon_view_set_item_orientation
gtk_icon_view_get_item_orientation
gtk_icon_view_set_columns
gtk_icon_view_get_columns
gtk_icon_view_set_item_width
gtk_icon_view_get_item_width
gtk_icon_view_set_spacing
gtk_icon_view_get_spacing
gtk_icon_view_set_row_spacing
gtk_icon_view_get_row_spacing
gtk_icon_view_set_column_spacing
gtk_icon_view_get_column_spacing
gtk_icon_view_set_margin
gtk_icon_view_get_margin
gtk_icon_view_set_item_padding
gtk_icon_view_get_item_padding
gtk_icon_view_set_activate_on_single_click
gtk_icon_view_get_activate_on_single_click
gtk_icon_view_get_cell_rect
gtk_icon_view_select_path
gtk_icon_view_unselect_path
gtk_icon_view_path_is_selected
gtk_icon_view_get_selected_items
gtk_icon_view_select_all
gtk_icon_view_unselect_all
gtk_icon_view_item_activated
gtk_icon_view_scroll_to_path
gtk_icon_view_get_visible_range
gtk_icon_view_set_tooltip_item
gtk_icon_view_set_tooltip_cell
gtk_icon_view_get_tooltip_context
gtk_icon_view_set_tooltip_column
gtk_icon_view_get_tooltip_column
gtk_icon_view_get_item_row
gtk_icon_view_get_item_column
GtkIconViewDropPosition
gtk_icon_view_enable_model_drag_source
gtk_icon_view_enable_model_drag_dest
gtk_icon_view_unset_model_drag_source
gtk_icon_view_unset_model_drag_dest
gtk_icon_view_set_reorderable
gtk_icon_view_get_reorderable
gtk_icon_view_set_drag_dest_item
gtk_icon_view_get_drag_dest_item
gtk_icon_view_get_dest_item_at_pos
gtk_icon_view_create_drag_icon
GTK_ICON_VIEW_CLASS
GTK_IS_ICON_VIEW
GTK_IS_ICON_VIEW_CLASS
GTK_ICON_VIEW_GET_CLASS
GTK_TYPE_ICON_VIEW
GTK_ICON_VIEW
gtk_icon_view_get_type
GtkIconViewPrivate
gtkimage
GtkImage
GtkImage
GtkImageType
gtk_image_new
gtk_image_new_from_file
gtk_image_new_from_resource
gtk_image_new_from_pixbuf
gtk_image_new_from_paintable
gtk_image_new_from_icon_name
gtk_image_new_from_gicon
gtk_image_clear
gtk_image_set_from_file
gtk_image_set_from_resource
gtk_image_set_from_pixbuf
gtk_image_set_from_paintable
gtk_image_set_from_icon_name
gtk_image_set_from_gicon
gtk_image_get_storage_type
gtk_image_get_paintable
gtk_image_get_icon_name
gtk_image_get_gicon
gtk_image_set_pixel_size
gtk_image_get_pixel_size
gtk_image_set_icon_size
gtk_image_get_icon_size
GTK_IMAGE
GTK_IS_IMAGE
GTK_TYPE_IMAGE
GTK_IMAGE_CLASS
GTK_IS_IMAGE_CLASS
GTK_IMAGE_GET_CLASS
GtkImagePrivate
gtk_image_get_type
GtkImagePixbufData
GtkImageAnimationData
GtkImageIconNameData
GtkImageGIconData
gtkimcontext
GtkIMContext
GtkIMContext
GtkIMContextClass
gtk_im_context_get_preedit_string
gtk_im_context_filter_keypress
gtk_im_context_focus_in
gtk_im_context_focus_out
gtk_im_context_reset
gtk_im_context_set_cursor_location
gtk_im_context_set_use_preedit
gtk_im_context_set_surrounding
gtk_im_context_get_surrounding
gtk_im_context_delete_surrounding
GTK_IM_CONTEXT
GTK_IS_IM_CONTEXT
GTK_TYPE_IM_CONTEXT
GTK_IM_CONTEXT_CLASS
GTK_IS_IM_CONTEXT_CLASS
GTK_IM_CONTEXT_GET_CLASS
gtk_im_context_get_type
gtkimcontextsimple
GtkIMContextSimple
GtkIMContextSimple
gtk_im_context_simple_new
gtk_im_context_simple_add_table
gtk_im_context_simple_add_compose_file
GTK_MAX_COMPOSE_LEN
GTK_IM_CONTEXT_SIMPLE
GTK_IS_IM_CONTEXT_SIMPLE
GTK_TYPE_IM_CONTEXT_SIMPLE
GTK_IM_CONTEXT_SIMPLE_CLASS
GTK_IS_IM_CONTEXT_SIMPLE_CLASS
GTK_IM_CONTEXT_SIMPLE_GET_CLASS
GtkIMContextSimplePrivate
gtk_im_context_simple_get_type
gtkimmulticontext
GtkIMMulticontext
GtkIMMulticontext
gtk_im_multicontext_new
gtk_im_multicontext_get_context_id
gtk_im_multicontext_set_context_id
GTK_IM_MULTICONTEXT
GTK_IS_IM_MULTICONTEXT
GTK_TYPE_IM_MULTICONTEXT
GTK_IM_MULTICONTEXT_CLASS
GTK_IS_IM_MULTICONTEXT_CLASS
GTK_IM_MULTICONTEXT_GET_CLASS
gtk_im_multicontext_get_type
GtkIMMulticontextPrivate
gtklabel
GtkLabel
GtkLabel
gtk_label_new
gtk_label_set_text
gtk_label_set_attributes
gtk_label_set_markup
gtk_label_set_markup_with_mnemonic
gtk_label_set_pattern
gtk_label_set_justify
gtk_label_set_xalign
gtk_label_set_yalign
gtk_label_set_ellipsize
gtk_label_set_width_chars
gtk_label_set_max_width_chars
gtk_label_set_wrap
gtk_label_set_wrap_mode
gtk_label_set_lines
gtk_label_get_layout_offsets
gtk_label_get_mnemonic_keyval
gtk_label_get_selectable
gtk_label_get_text
gtk_label_new_with_mnemonic
gtk_label_select_region
gtk_label_set_mnemonic_widget
gtk_label_set_selectable
gtk_label_set_text_with_mnemonic
gtk_label_get_attributes
gtk_label_get_justify
gtk_label_get_xalign
gtk_label_get_yalign
gtk_label_get_ellipsize
gtk_label_get_width_chars
gtk_label_get_max_width_chars
gtk_label_get_label
gtk_label_get_layout
gtk_label_get_wrap
gtk_label_get_wrap_mode
gtk_label_get_lines
gtk_label_get_mnemonic_widget
gtk_label_get_selection_bounds
gtk_label_get_use_markup
gtk_label_get_use_underline
gtk_label_get_single_line_mode
gtk_label_set_label
gtk_label_set_use_markup
gtk_label_set_use_underline
gtk_label_set_single_line_mode
gtk_label_get_current_uri
gtk_label_set_track_visited_links
gtk_label_get_track_visited_links
gtk_label_set_extra_menu
gtk_label_get_extra_menu
GTK_LABEL
GTK_IS_LABEL
GTK_TYPE_LABEL
GTK_LABEL_CLASS
GTK_IS_LABEL_CLASS
GTK_LABEL_GET_CLASS
gtk_label_get_type
GtkLabelPrivate
GtkLabelSelectionInfo
gtklinkbutton
GtkLinkButton
GtkLinkButton
gtk_link_button_new
gtk_link_button_new_with_label
gtk_link_button_get_uri
gtk_link_button_set_uri
gtk_link_button_get_visited
gtk_link_button_set_visited
GTK_TYPE_LINK_BUTTON
GTK_LINK_BUTTON
GTK_IS_LINK_BUTTON
GTK_LINK_BUTTON_CLASS
GTK_IS_LINK_BUTTON_CLASS
GTK_LINK_BUTTON_GET_CLASS
GtkLinkButtonPrivate
gtk_link_button_get_type
gtkmaplistmodel
GtkMapListModel
GtkMapListModel
GtkMapListModelMapFunc
gtk_map_list_model_new
gtk_map_list_model_set_map_func
gtk_map_list_model_set_model
gtk_map_list_model_get_model
gtk_map_list_model_has_map
GTK_MAP_LIST_MODEL
GTK_IS_MAP_LIST_MODEL
GTK_TYPE_MAP_LIST_MODEL
GTK_MAP_LIST_MODEL_CLASS
GTK_IS_MAP_LIST_MODEL_CLASS
GTK_MAP_LIST_MODEL_GET_CLASS
gtk_map_list_model_get_type
gtkmenubutton
GtkMenuButton
GtkMenuButton
gtk_menu_button_new
gtk_menu_button_set_popover
gtk_menu_button_get_popover
gtk_menu_button_set_menu_model
gtk_menu_button_get_menu_model
GtkArrowType
gtk_menu_button_set_direction
gtk_menu_button_get_direction
gtk_menu_button_set_align_widget
gtk_menu_button_get_align_widget
gtk_menu_button_set_icon_name
gtk_menu_button_get_icon_name
gtk_menu_button_set_label
gtk_menu_button_get_label
gtk_menu_button_set_relief
gtk_menu_button_get_relief
gtk_menu_button_popup
gtk_menu_button_popdown
GtkMenuButtonCreatePopupFunc
gtk_menu_button_set_create_popup_func
GTK_TYPE_MENU_BUTTON
GTK_MENU_BUTTON
GTK_MENU_BUTTON_CLASS
GTK_IS_MENU_BUTTON
GTK_IS_MENU_BUTTON_CLASS
GTK_MENU_BUTTON_GET_CLASS
GtkMenuButtonPrivate
gtk_menu_button_get_type
gtkmessagedialog
GtkMessageDialog
GtkMessageDialog
GtkMessageType
GtkButtonsType
gtk_message_dialog_new
gtk_message_dialog_new_with_markup
gtk_message_dialog_set_markup
gtk_message_dialog_format_secondary_text
gtk_message_dialog_format_secondary_markup
gtk_message_dialog_get_message_area
GTK_MESSAGE_DIALOG
GTK_IS_MESSAGE_DIALOG
GTK_TYPE_MESSAGE_DIALOG
GTK_MESSAGE_DIALOG_CLASS
GTK_IS_MESSAGE_DIALOG_CLASS
GTK_MESSAGE_DIALOG_GET_CLASS
GtkMessageDialogPrivate
gtk_message_dialog_get_type
gtkinfobar
GtkInfoBar
GtkInfoBar
gtk_info_bar_new
gtk_info_bar_new_with_buttons
gtk_info_bar_add_action_widget
gtk_info_bar_add_button
gtk_info_bar_add_buttons
gtk_info_bar_set_response_sensitive
gtk_info_bar_set_default_response
gtk_info_bar_response
gtk_info_bar_set_message_type
gtk_info_bar_get_message_type
gtk_info_bar_get_show_close_button
gtk_info_bar_set_show_close_button
gtk_info_bar_get_revealed
gtk_info_bar_set_revealed
GTK_TYPE_INFO_BAR
GTK_INFO_BAR
GTK_INFO_BAR_CLASS
GTK_IS_INFO_BAR
GTK_IS_INFO_BAR_CLASS
GTK_INFO_BAR_GET_CLASS
GtkInfoBarPrivate
gtk_info_bar_get_type
gtknativedialog
GtkNativeDialog
GTK_TYPE_NATIVE_DIALOG
GtkNativeDialogClass
gtk_native_dialog_show
gtk_native_dialog_hide
gtk_native_dialog_destroy
gtk_native_dialog_get_visible
gtk_native_dialog_set_modal
gtk_native_dialog_get_modal
gtk_native_dialog_set_title
gtk_native_dialog_get_title
gtk_native_dialog_set_transient_for
gtk_native_dialog_get_transient_for
gtk_native_dialog_run
GtkNativeDialog
gtk_native_dialog_get_type
gtknotebook
GtkNotebook
GtkNotebook
GtkNotebookPage
gtk_notebook_new
gtk_notebook_get_page
gtk_notebook_get_pages
gtk_notebook_page_get_child
gtk_notebook_append_page
gtk_notebook_append_page_menu
gtk_notebook_prepend_page
gtk_notebook_prepend_page_menu
gtk_notebook_insert_page
gtk_notebook_insert_page_menu
gtk_notebook_remove_page
gtk_notebook_detach_tab
gtk_notebook_page_num
gtk_notebook_next_page
gtk_notebook_prev_page
gtk_notebook_reorder_child
gtk_notebook_set_tab_pos
gtk_notebook_set_show_tabs
gtk_notebook_set_show_border
gtk_notebook_set_scrollable
gtk_notebook_popup_enable
gtk_notebook_popup_disable
gtk_notebook_get_current_page
gtk_notebook_get_menu_label
gtk_notebook_get_nth_page
gtk_notebook_get_n_pages
gtk_notebook_get_tab_label
gtk_notebook_set_menu_label
gtk_notebook_set_menu_label_text
gtk_notebook_set_tab_label
gtk_notebook_set_tab_label_text
gtk_notebook_set_tab_reorderable
gtk_notebook_set_tab_detachable
gtk_notebook_get_menu_label_text
gtk_notebook_get_scrollable
gtk_notebook_get_show_border
gtk_notebook_get_show_tabs
gtk_notebook_get_tab_label_text
gtk_notebook_get_tab_pos
gtk_notebook_get_tab_reorderable
gtk_notebook_get_tab_detachable
gtk_notebook_set_current_page
gtk_notebook_set_group_name
gtk_notebook_get_group_name
gtk_notebook_set_action_widget
gtk_notebook_get_action_widget
GTK_NOTEBOOK
GTK_IS_NOTEBOOK
GTK_TYPE_NOTEBOOK
GTK_NOTEBOOK_CLASS
GTK_IS_NOTEBOOK_CLASS
GTK_NOTEBOOK_GET_CLASS
gtk_notebook_get_type
gtk_notebook_page_get_type
GtkNotebookTab
GtkNotebookPrivate
gtkpaned
GtkPaned
GtkPaned
gtk_paned_new
gtk_paned_add1
gtk_paned_add2
gtk_paned_pack1
gtk_paned_pack2
gtk_paned_get_child1
gtk_paned_get_child2
gtk_paned_set_position
gtk_paned_get_position
gtk_paned_set_wide_handle
gtk_paned_get_wide_handle
GTK_PANED
GTK_IS_PANED
GTK_TYPE_PANED
GTK_PANED_CLASS
GTK_IS_PANED_CLASS
GTK_PANED_GET_CLASS
GtkPanedPrivate
gtk_paned_get_type
gtkpicture
GtkPicture
GtkPicture
gtk_picture_new
gtk_picture_new_for_paintable
gtk_picture_new_for_pixbuf
gtk_picture_new_for_file
gtk_picture_new_for_filename
gtk_picture_new_for_resource
gtk_picture_set_paintable
gtk_picture_get_paintable
gtk_picture_set_pixbuf
gtk_picture_set_file
gtk_picture_get_file
gtk_picture_set_filename
gtk_picture_set_resource
gtk_picture_set_keep_aspect_ratio
gtk_picture_get_keep_aspect_ratio
gtk_picture_set_can_shrink
gtk_picture_get_can_shrink
gtk_picture_set_alternative_text
gtk_picture_get_alternative_text
GTK_PICTURE
GTK_IS_PICTURE
GTK_TYPE_PICTURE
GTK_PICTURE_CLASS
GTK_IS_PICTURE_CLASS
GTK_PICTURE_GET_CLASS
gtk_picture_get_type
gtkprogressbar
GtkProgressBar
GtkProgressBar
gtk_progress_bar_new
gtk_progress_bar_pulse
gtk_progress_bar_set_fraction
gtk_progress_bar_get_fraction
gtk_progress_bar_set_inverted
gtk_progress_bar_get_inverted
gtk_progress_bar_set_show_text
gtk_progress_bar_get_show_text
gtk_progress_bar_set_text
gtk_progress_bar_get_text
gtk_progress_bar_set_ellipsize
gtk_progress_bar_get_ellipsize
gtk_progress_bar_set_pulse_step
gtk_progress_bar_get_pulse_step
GTK_PROGRESS_BAR
GTK_IS_PROGRESS_BAR
GTK_TYPE_PROGRESS_BAR
GTK_PROGRESS_BAR_CLASS
GTK_IS_PROGRESS_BAR_CLASS
GTK_PROGRESS_BAR_GET_CLASS
GtkProgressBarPrivate
gtk_progress_bar_get_type
gtkradiobutton
GtkRadioButton
GtkRadioButton
gtk_radio_button_new
gtk_radio_button_new_from_widget
gtk_radio_button_new_with_label
gtk_radio_button_new_with_label_from_widget
gtk_radio_button_new_with_mnemonic
gtk_radio_button_new_with_mnemonic_from_widget
gtk_radio_button_set_group
gtk_radio_button_get_group
gtk_radio_button_join_group
GTK_RADIO_BUTTON
GTK_IS_RADIO_BUTTON
GTK_TYPE_RADIO_BUTTON
GTK_RADIO_BUTTON_CLASS
GTK_IS_RADIO_BUTTON_CLASS
GTK_RADIO_BUTTON_GET_CLASS
GtkRadioButtonPrivate
gtk_radio_button_get_type
gtkrange
GtkRange
GtkRange
gtk_range_get_fill_level
gtk_range_get_restrict_to_fill_level
gtk_range_get_show_fill_level
gtk_range_set_fill_level
gtk_range_set_restrict_to_fill_level
gtk_range_set_show_fill_level
gtk_range_get_adjustment
gtk_range_set_adjustment
gtk_range_get_inverted
gtk_range_set_inverted
gtk_range_get_value
gtk_range_set_value
gtk_range_set_increments
gtk_range_set_range
gtk_range_get_round_digits
gtk_range_set_round_digits
gtk_range_get_flippable
gtk_range_set_flippable
gtk_range_get_range_rect
gtk_range_get_slider_range
gtk_range_get_slider_size_fixed
gtk_range_set_slider_size_fixed
GTK_RANGE
GTK_IS_RANGE
GTK_TYPE_RANGE
GTK_RANGE_CLASS
GTK_IS_RANGE_CLASS
GTK_RANGE_GET_CLASS
gtk_range_get_type
GtkRangePrivate
gtkrecentmanager
GtkRecentManager
GtkRecentManager
GtkRecentInfo
GtkRecentData
GTK_RECENT_MANAGER_ERROR
GtkRecentManagerError
gtk_recent_manager_new
gtk_recent_manager_get_default
gtk_recent_manager_add_item
gtk_recent_manager_add_full
gtk_recent_manager_remove_item
gtk_recent_manager_lookup_item
gtk_recent_manager_has_item
gtk_recent_manager_move_item
gtk_recent_manager_get_items
gtk_recent_manager_purge_items
gtk_recent_info_ref
gtk_recent_info_unref
gtk_recent_info_get_uri
gtk_recent_info_get_display_name
gtk_recent_info_get_description
gtk_recent_info_get_mime_type
gtk_recent_info_get_added
gtk_recent_info_get_modified
gtk_recent_info_get_visited
gtk_recent_info_get_private_hint
gtk_recent_info_get_application_info
gtk_recent_info_get_applications
gtk_recent_info_last_application
gtk_recent_info_has_application
gtk_recent_info_create_app_info
gtk_recent_info_get_groups
gtk_recent_info_has_group
gtk_recent_info_get_gicon
gtk_recent_info_get_short_name
gtk_recent_info_get_uri_display
gtk_recent_info_get_age
gtk_recent_info_is_local
gtk_recent_info_exists
gtk_recent_info_match
GTK_RECENT_MANAGER
GTK_IS_RECENT_MANAGER
GTK_TYPE_RECENT_MANAGER
GTK_RECENT_MANAGER_CLASS
GTK_IS_RECENT_MANAGER_CLASS
GTK_RECENT_MANAGER_GET_CLASS
GTK_TYPE_RECENT_INFO
gtk_recent_manager_get_type
gtk_recent_info_get_type
GtkRecentManagerPrivate
gtk_recent_manager_error_quark
gtkscale
GtkScale
GtkScale
gtk_scale_new
gtk_scale_new_with_range
gtk_scale_set_digits
gtk_scale_set_draw_value
gtk_scale_set_has_origin
gtk_scale_set_value_pos
gtk_scale_get_digits
gtk_scale_get_draw_value
gtk_scale_get_has_origin
gtk_scale_get_value_pos
gtk_scale_get_layout
gtk_scale_get_layout_offsets
gtk_scale_add_mark
gtk_scale_clear_marks
GTK_SCALE
GTK_IS_SCALE
GTK_TYPE_SCALE
GTK_SCALE_CLASS
GTK_IS_SCALE_CLASS
GTK_SCALE_GET_CLASS
GtkScalePrivate
gtk_scale_get_type
gtkscalebutton
GtkScaleButton
GtkScaleButton
gtk_scale_button_new
gtk_scale_button_set_adjustment
gtk_scale_button_set_icons
gtk_scale_button_set_value
gtk_scale_button_get_adjustment
gtk_scale_button_get_value
gtk_scale_button_get_popup
gtk_scale_button_get_plus_button
gtk_scale_button_get_minus_button
GTK_SCALE_BUTTON
GTK_IS_SCALE_BUTTON
GTK_TYPE_SCALE_BUTTON
GTK_SCALE_BUTTON_CLASS
GTK_IS_SCALE_BUTTON_CLASS
GTK_SCALE_BUTTON_GET_CLASS
GtkScaleButtonPrivate
gtk_scale_button_get_type
gtkscrollable
GtkScrollable
GtkScrollable
gtk_scrollable_get_hadjustment
gtk_scrollable_set_hadjustment
gtk_scrollable_get_vadjustment
gtk_scrollable_set_vadjustment
GtkScrollablePolicy
gtk_scrollable_get_hscroll_policy
gtk_scrollable_set_hscroll_policy
gtk_scrollable_get_vscroll_policy
gtk_scrollable_set_vscroll_policy
gtk_scrollable_get_border
GtkScrollableInterface
GTK_TYPE_SCROLLABLE
GTK_SCROLLABLE
GTK_IS_SCROLLABLE
GTK_SCROLLABLE_GET_IFACE
gtk_scrollable_get_type
gtkscrollbar
GtkScrollbar
GtkScrollbar
gtk_scrollbar_new
gtk_scrollbar_get_adjustment
gtk_scrollbar_set_adjustment
GTK_SCROLLBAR
GTK_IS_SCROLLBAR
GTK_TYPE_SCROLLBAR
GTK_SCROLLBAR_CLASS
GTK_IS_SCROLLBAR_CLASS
GTK_SCROLLBAR_GET_CLASS
gtk_scrollbar_get_type
gtkscrolledwindow
GtkScrolledWindow
GtkScrolledWindow
gtk_scrolled_window_new
gtk_scrolled_window_get_hadjustment
gtk_scrolled_window_set_hadjustment
gtk_scrolled_window_get_vadjustment
gtk_scrolled_window_set_vadjustment
gtk_scrolled_window_get_hscrollbar
gtk_scrolled_window_get_vscrollbar
GtkPolicyType
gtk_scrolled_window_get_policy
gtk_scrolled_window_set_policy
GtkCornerType
gtk_scrolled_window_get_placement
gtk_scrolled_window_set_placement
gtk_scrolled_window_unset_placement
gtk_scrolled_window_get_shadow_type
gtk_scrolled_window_set_shadow_type
gtk_scrolled_window_get_kinetic_scrolling
gtk_scrolled_window_set_kinetic_scrolling
gtk_scrolled_window_get_capture_button_press
gtk_scrolled_window_set_capture_button_press
gtk_scrolled_window_get_overlay_scrolling
gtk_scrolled_window_set_overlay_scrolling
gtk_scrolled_window_get_min_content_width
gtk_scrolled_window_set_min_content_width
gtk_scrolled_window_get_min_content_height
gtk_scrolled_window_set_min_content_height
gtk_scrolled_window_get_max_content_width
gtk_scrolled_window_set_max_content_width
gtk_scrolled_window_get_max_content_height
gtk_scrolled_window_set_max_content_height
gtk_scrolled_window_get_propagate_natural_width
gtk_scrolled_window_set_propagate_natural_width
gtk_scrolled_window_get_propagate_natural_height
gtk_scrolled_window_set_propagate_natural_height
GTK_SCROLLED_WINDOW
GTK_IS_SCROLLED_WINDOW
GTK_TYPE_SCROLLED_WINDOW
GTK_SCROLLED_WINDOW_CLASS
GTK_IS_SCROLLED_WINDOW_CLASS
GTK_SCROLLED_WINDOW_GET_CLASS
gtk_scrolled_window_get_type
GtkScrolledWindowPrivate
gtksearchbar
GtkSearchBar
GtkSearchBar
gtk_search_bar_new
gtk_search_bar_connect_entry
gtk_search_bar_get_search_mode
gtk_search_bar_set_search_mode
gtk_search_bar_get_show_close_button
gtk_search_bar_set_show_close_button
gtk_search_bar_set_key_capture_widget
gtk_search_bar_get_key_capture_widget
GTK_TYPE_SEARCH_BAR
GTK_SEARCH_BAR
GTK_SEARCH_BAR_CLASS
GTK_IS_SEARCH_BAR
GTK_IS_SEARCH_BAR_CLASS
GTK_SEARCH_BAR_GET_CLASS
gtk_search_bar_get_type
gtksearchentry
GtkSearchEntry
GtkSearchEntry
gtk_search_entry_new
gtk_search_entry_set_key_capture_widget
gtk_search_entry_get_key_capture_widget
GTK_TYPE_SEARCH_ENTRY
GTK_SEARCH_ENTRY
GTK_SEARCH_ENTRY_CLASS
GTK_IS_SEARCH_ENTRY
GTK_IS_SEARCH_ENTRY_CLASS
GTK_SEARCH_ENTRY_GET_CLASS
gtk_search_entry_get_type
gtkseparator
GtkSeparator
GtkSeparator
gtk_separator_new
GTK_SEPARATOR
GTK_IS_SEPARATOR
GTK_TYPE_SEPARATOR
GTK_SEPARATOR_CLASS
GTK_IS_SEPARATOR_CLASS
GTK_SEPARATOR_GET_CLASS
gtk_separator_get_type
GtkSeparatorPrivate
gtksettings
GtkSettings
GtkSettings
GtkSettingsValue
gtk_settings_get_default
gtk_settings_get_for_display
gtk_settings_reset_property
GtkSettingsClass
GTK_IS_SETTINGS
GTK_IS_SETTINGS_CLASS
GTK_SETTINGS
GTK_SETTINGS_CLASS
GTK_SETTINGS_GET_CLASS
GTK_TYPE_SETTINGS
GtkSettingsPrivate
gtk_settings_get_type
GtkSettingsPropertyValue
gtksizegroup
GtkSizeGroup
GtkSizeGroup
GtkSizeGroupMode
gtk_size_group_new
gtk_size_group_set_mode
gtk_size_group_get_mode
gtk_size_group_add_widget
gtk_size_group_remove_widget
gtk_size_group_get_widgets
GTK_SIZE_GROUP
GTK_IS_SIZE_GROUP
GTK_TYPE_SIZE_GROUP
GTK_SIZE_GROUP_CLASS
GTK_IS_SIZE_GROUP_CLASS
GTK_SIZE_GROUP_GET_CLASS
GtkSizeGroupPrivate
gtk_size_group_get_type
gtkslicelistmodel
GtkSliceListModel
GtkSliceListModel
gtk_slice_list_model_new
gtk_slice_list_model_new_for_type
gtk_slice_list_model_set_model
gtk_slice_list_model_get_model
gtk_slice_list_model_set_offset
gtk_slice_list_model_get_offset
gtk_slice_list_model_set_size
gtk_slice_list_model_get_size
GTK_SLICE_LIST_MODEL
GTK_IS_SLICE_LIST_MODEL
GTK_TYPE_SLICE_LIST_MODEL
GTK_SLICE_LIST_MODEL_CLASS
GTK_IS_SLICE_LIST_MODEL_CLASS
GTK_SLICE_LIST_MODEL_GET_CLASS
gtk_slice_list_model_get_type
gtksortlistmodel
GtkSortListModel
GtkSortListModel
gtk_sort_list_model_new
gtk_sort_list_model_new_for_type
gtk_sort_list_model_set_sort_func
gtk_sort_list_model_has_sort
gtk_sort_list_model_set_model
gtk_sort_list_model_get_model
gtk_sort_list_model_resort
GTK_SORT_LIST_MODEL
GTK_IS_SORT_LIST_MODEL
GTK_TYPE_SORT_LIST_MODEL
GTK_SORT_LIST_MODEL_CLASS
GTK_IS_SORT_LIST_MODEL_CLASS
GTK_SORT_LIST_MODEL_GET_CLASS
gtk_sort_list_model_get_type
gtkspinbutton
GtkSpinButton
GtkSpinButton
GtkSpinButtonUpdatePolicy
GtkSpinType
gtk_spin_button_configure
gtk_spin_button_new
gtk_spin_button_new_with_range
gtk_spin_button_set_adjustment
gtk_spin_button_get_adjustment
gtk_spin_button_set_digits
gtk_spin_button_set_increments
gtk_spin_button_set_range
gtk_spin_button_get_value_as_int
gtk_spin_button_set_value
gtk_spin_button_set_update_policy
gtk_spin_button_set_numeric
gtk_spin_button_spin
gtk_spin_button_set_wrap
gtk_spin_button_set_snap_to_ticks
gtk_spin_button_update
gtk_spin_button_get_digits
gtk_spin_button_get_increments
gtk_spin_button_get_numeric
gtk_spin_button_get_range
gtk_spin_button_get_snap_to_ticks
gtk_spin_button_get_update_policy
gtk_spin_button_get_value
gtk_spin_button_get_wrap
GTK_INPUT_ERROR
GTK_SPIN_BUTTON
GTK_IS_SPIN_BUTTON
GTK_TYPE_SPIN_BUTTON
GTK_SPIN_BUTTON_CLASS
GTK_IS_SPIN_BUTTON_CLASS
GTK_SPIN_BUTTON_GET_CLASS
GtkSpinButtonPrivate
gtk_spin_button_get_type
gtkspinner
GtkSpinner
GtkSpinner
gtk_spinner_new
gtk_spinner_start
gtk_spinner_stop
gtk_spinner_set_spinning
gtk_spinner_get_spinning
GTK_SPINNER
GTK_IS_SPINNER
GTK_TYPE_SPINNER
GTK_SPINNER_CLASS
GTK_IS_SPINNER_CLASS
GTK_SPINNER_GET_CLASS
GtkSpinnerPrivate
gtk_spinner_get_type
gtkstatusbar
GtkStatusbar
GtkStatusbar
gtk_statusbar_new
gtk_statusbar_get_context_id
gtk_statusbar_push
gtk_statusbar_pop
gtk_statusbar_remove
gtk_statusbar_remove_all
GTK_STATUSBAR
GTK_IS_STATUSBAR
GTK_TYPE_STATUSBAR
GTK_STATUSBAR_CLASS
GTK_IS_STATUSBAR_CLASS
GTK_STATUSBAR_GET_CLASS
GtkStatusbarPrivate
gtk_statusbar_get_type
gtklevelbar
GtkLevelBar
GTK_LEVEL_BAR_OFFSET_LOW
GTK_LEVEL_BAR_OFFSET_HIGH
GTK_LEVEL_BAR_OFFSET_FULL
GtkLevelBarMode
GtkLevelBar
gtk_level_bar_new
gtk_level_bar_new_for_interval
gtk_level_bar_set_mode
gtk_level_bar_get_mode
gtk_level_bar_set_value
gtk_level_bar_get_value
gtk_level_bar_set_min_value
gtk_level_bar_get_min_value
gtk_level_bar_set_max_value
gtk_level_bar_get_max_value
gtk_level_bar_set_inverted
gtk_level_bar_get_inverted
gtk_level_bar_add_offset_value
gtk_level_bar_remove_offset_value
gtk_level_bar_get_offset_value
GTK_LEVEL_BAR
GTK_IS_LEVEL_BAR
GTK_TYPE_LEVEL_BAR
GTK_LEVEL_BAR_CLASS
GTK_IS_LEVEL_BAR_CLASS
GTK_LEVEL_BAR_GET_CLASS
GtkLevelBarPrivate
gtk_level_bar_get_type
gtktextbuffer
GtkTextBuffer
GtkTextBuffer
GtkTextBufferClass
gtk_text_buffer_new
gtk_text_buffer_get_line_count
gtk_text_buffer_get_char_count
gtk_text_buffer_get_tag_table
gtk_text_buffer_insert
gtk_text_buffer_insert_at_cursor
gtk_text_buffer_insert_interactive
gtk_text_buffer_insert_interactive_at_cursor
gtk_text_buffer_insert_range
gtk_text_buffer_insert_range_interactive
gtk_text_buffer_insert_with_tags
gtk_text_buffer_insert_with_tags_by_name
gtk_text_buffer_insert_markup
gtk_text_buffer_delete
gtk_text_buffer_delete_interactive
gtk_text_buffer_backspace
gtk_text_buffer_set_text
gtk_text_buffer_get_text
gtk_text_buffer_get_slice
gtk_text_buffer_insert_child_anchor
gtk_text_buffer_create_child_anchor
gtk_text_buffer_create_mark
gtk_text_buffer_move_mark
gtk_text_buffer_move_mark_by_name
gtk_text_buffer_add_mark
gtk_text_buffer_delete_mark
gtk_text_buffer_delete_mark_by_name
gtk_text_buffer_get_mark
gtk_text_buffer_get_insert
gtk_text_buffer_get_selection_bound
gtk_text_buffer_get_has_selection
gtk_text_buffer_place_cursor
gtk_text_buffer_select_range
gtk_text_buffer_apply_tag
gtk_text_buffer_remove_tag
gtk_text_buffer_apply_tag_by_name
gtk_text_buffer_remove_tag_by_name
gtk_text_buffer_remove_all_tags
gtk_text_buffer_create_tag
gtk_text_buffer_get_iter_at_line_offset
gtk_text_buffer_get_iter_at_offset
gtk_text_buffer_get_iter_at_line
gtk_text_buffer_get_iter_at_line_index
gtk_text_buffer_get_iter_at_mark
gtk_text_buffer_get_iter_at_child_anchor
gtk_text_buffer_get_start_iter
gtk_text_buffer_get_end_iter
gtk_text_buffer_get_bounds
gtk_text_buffer_get_modified
gtk_text_buffer_set_modified
gtk_text_buffer_delete_selection
gtk_text_buffer_paste_clipboard
gtk_text_buffer_copy_clipboard
gtk_text_buffer_cut_clipboard
gtk_text_buffer_get_selection_bounds
gtk_text_buffer_begin_user_action
gtk_text_buffer_end_user_action
gtk_text_buffer_add_selection_clipboard
gtk_text_buffer_remove_selection_clipboard
gtk_text_buffer_get_can_undo
gtk_text_buffer_get_can_redo
gtk_text_buffer_get_enable_undo
gtk_text_buffer_set_enable_undo
gtk_text_buffer_get_max_undo_levels
gtk_text_buffer_set_max_undo_levels
gtk_text_buffer_undo
gtk_text_buffer_redo
gtk_text_buffer_begin_irreversible_action
gtk_text_buffer_end_irreversible_action
gtk_text_buffer_begin_user_action
gtk_text_buffer_end_user_action
GTK_TEXT_BUFFER
GTK_IS_TEXT_BUFFER
GTK_TYPE_TEXT_BUFFER
GTK_TEXT_BUFFER_CLASS
GTK_IS_TEXT_BUFFER_CLASS
GTK_TEXT_BUFFER_GET_CLASS
gtk_text_buffer_get_type
GtkTextBufferPrivate
gtktextiter
GtkTextIter
GtkTextIter
gtk_text_iter_get_buffer
gtk_text_iter_copy
gtk_text_iter_assign
gtk_text_iter_free
gtk_text_iter_get_offset
gtk_text_iter_get_line
gtk_text_iter_get_line_offset
gtk_text_iter_get_line_index
gtk_text_iter_get_visible_line_index
gtk_text_iter_get_visible_line_offset
gtk_text_iter_get_char
gtk_text_iter_get_slice
gtk_text_iter_get_text
gtk_text_iter_get_visible_slice
gtk_text_iter_get_visible_text
gtk_text_iter_get_marks
gtk_text_iter_get_toggled_tags
gtk_text_iter_get_child_anchor
gtk_text_iter_starts_tag
gtk_text_iter_ends_tag
gtk_text_iter_toggles_tag
gtk_text_iter_has_tag
gtk_text_iter_get_tags
gtk_text_iter_editable
gtk_text_iter_can_insert
gtk_text_iter_starts_word
gtk_text_iter_ends_word
gtk_text_iter_inside_word
gtk_text_iter_starts_line
gtk_text_iter_ends_line
gtk_text_iter_starts_sentence
gtk_text_iter_ends_sentence
gtk_text_iter_inside_sentence
gtk_text_iter_is_cursor_position
gtk_text_iter_get_chars_in_line
gtk_text_iter_get_bytes_in_line
gtk_text_iter_get_language
gtk_text_iter_is_end
gtk_text_iter_is_start
gtk_text_iter_forward_char
gtk_text_iter_backward_char
gtk_text_iter_forward_chars
gtk_text_iter_backward_chars
gtk_text_iter_forward_line
gtk_text_iter_backward_line
gtk_text_iter_forward_lines
gtk_text_iter_backward_lines
gtk_text_iter_forward_word_ends
gtk_text_iter_backward_word_starts
gtk_text_iter_forward_word_end
gtk_text_iter_backward_word_start
gtk_text_iter_forward_cursor_position
gtk_text_iter_backward_cursor_position
gtk_text_iter_forward_cursor_positions
gtk_text_iter_backward_cursor_positions
gtk_text_iter_backward_sentence_start
gtk_text_iter_backward_sentence_starts
gtk_text_iter_forward_sentence_end
gtk_text_iter_forward_sentence_ends
gtk_text_iter_forward_visible_word_ends
gtk_text_iter_backward_visible_word_starts
gtk_text_iter_forward_visible_word_end
gtk_text_iter_backward_visible_word_start
gtk_text_iter_forward_visible_cursor_position
gtk_text_iter_backward_visible_cursor_position
gtk_text_iter_forward_visible_cursor_positions
gtk_text_iter_backward_visible_cursor_positions
gtk_text_iter_forward_visible_line
gtk_text_iter_backward_visible_line
gtk_text_iter_forward_visible_lines
gtk_text_iter_backward_visible_lines
gtk_text_iter_set_offset
gtk_text_iter_set_line
gtk_text_iter_set_line_offset
gtk_text_iter_set_line_index
gtk_text_iter_set_visible_line_index
gtk_text_iter_set_visible_line_offset
gtk_text_iter_forward_to_end
gtk_text_iter_forward_to_line_end
gtk_text_iter_forward_to_tag_toggle
gtk_text_iter_backward_to_tag_toggle
GtkTextCharPredicate
gtk_text_iter_forward_find_char
gtk_text_iter_backward_find_char
GtkTextSearchFlags
gtk_text_iter_forward_search
gtk_text_iter_backward_search
gtk_text_iter_equal
gtk_text_iter_compare
gtk_text_iter_in_range
gtk_text_iter_order
GTK_TYPE_TEXT_ITER
gtk_text_iter_get_type
gtktextmark
GtkTextMark
GtkTextMark
gtk_text_mark_new
gtk_text_mark_set_visible
gtk_text_mark_get_visible
gtk_text_mark_get_deleted
gtk_text_mark_get_name
gtk_text_mark_get_buffer
gtk_text_mark_get_left_gravity
GTK_TEXT_MARK
GTK_IS_TEXT_MARK
GTK_TYPE_TEXT_MARK
GTK_TEXT_MARK_CLASS
GTK_IS_TEXT_MARK_CLASS
GTK_TEXT_MARK_GET_CLASS
gtk_text_mark_get_type
gtktexttag
GtkTextTag
GtkTextTag
gtk_text_tag_new
gtk_text_tag_get_priority
gtk_text_tag_set_priority
gtk_text_tag_changed
GTK_TEXT_TAG
GTK_IS_TEXT_TAG
GTK_TYPE_TEXT_TAG
GTK_TEXT_TAG_CLASS
GTK_IS_TEXT_TAG_CLASS
GTK_TEXT_TAG_GET_CLASS
GtkTextTagPrivate
gtk_text_tag_get_type
gtktexttagtable
GtkTextTagTable
GtkTextTagTable
GtkTextTagTableForeach
gtk_text_tag_table_new
gtk_text_tag_table_add
gtk_text_tag_table_remove
gtk_text_tag_table_lookup
gtk_text_tag_table_foreach
gtk_text_tag_table_get_size
GTK_TEXT_TAG_TABLE
GTK_IS_TEXT_TAG_TABLE
GTK_TYPE_TEXT_TAG_TABLE
GTK_TEXT_TAG_TABLE_CLASS
GTK_IS_TEXT_TAG_TABLE_CLASS
GTK_TEXT_TAG_TABLE_GET_CLASS
GtkTextTagTablePrivate
gtk_text_tag_table_get_type
gtktextview
GtkTextView
GtkTextView
GtkTextViewClass
GtkTextViewLayer
GtkTextWindowType
GtkTextExtendSelection
GtkWrapMode
gtk_text_view_new
gtk_text_view_new_with_buffer
gtk_text_view_set_buffer
gtk_text_view_get_buffer
gtk_text_view_scroll_to_mark
gtk_text_view_scroll_to_iter
gtk_text_view_scroll_mark_onscreen
gtk_text_view_move_mark_onscreen
gtk_text_view_place_cursor_onscreen
gtk_text_view_get_visible_rect
gtk_text_view_get_iter_location
gtk_text_view_get_cursor_locations
gtk_text_view_get_line_at_y
gtk_text_view_get_line_yrange
gtk_text_view_get_iter_at_location
gtk_text_view_get_iter_at_position
gtk_text_view_buffer_to_window_coords
gtk_text_view_window_to_buffer_coords
gtk_text_view_forward_display_line
gtk_text_view_backward_display_line
gtk_text_view_forward_display_line_end
gtk_text_view_backward_display_line_start
gtk_text_view_starts_display_line
gtk_text_view_move_visually
gtk_text_view_add_child_at_anchor
GtkTextChildAnchor
gtk_text_child_anchor_new
gtk_text_child_anchor_get_widgets
gtk_text_child_anchor_get_deleted
gtk_text_view_get_gutter
gtk_text_view_set_gutter
gtk_text_view_add_overlay
gtk_text_view_move_overlay
gtk_text_view_set_wrap_mode
gtk_text_view_get_wrap_mode
gtk_text_view_set_editable
gtk_text_view_get_editable
gtk_text_view_set_cursor_visible
gtk_text_view_get_cursor_visible
gtk_text_view_reset_cursor_blink
gtk_text_view_set_overwrite
gtk_text_view_get_overwrite
gtk_text_view_set_pixels_above_lines
gtk_text_view_get_pixels_above_lines
gtk_text_view_set_pixels_below_lines
gtk_text_view_get_pixels_below_lines
gtk_text_view_set_pixels_inside_wrap
gtk_text_view_get_pixels_inside_wrap
gtk_text_view_set_justification
gtk_text_view_get_justification
gtk_text_view_set_left_margin
gtk_text_view_get_left_margin
gtk_text_view_set_right_margin
gtk_text_view_get_right_margin
gtk_text_view_set_top_margin
gtk_text_view_get_top_margin
gtk_text_view_set_bottom_margin
gtk_text_view_get_bottom_margin
gtk_text_view_set_indent
gtk_text_view_get_indent
gtk_text_view_set_tabs
gtk_text_view_get_tabs
gtk_text_view_set_accepts_tab
gtk_text_view_get_accepts_tab
gtk_text_view_im_context_filter_keypress
gtk_text_view_reset_im_context
gtk_text_view_set_input_purpose
gtk_text_view_get_input_purpose
gtk_text_view_set_input_hints
gtk_text_view_get_input_hints
gtk_text_view_set_monospace
gtk_text_view_get_monospace
gtk_text_view_set_extra_menu
gtk_text_view_get_extra_menu
GTK_TEXT_VIEW_PRIORITY_VALIDATE
GTK_TEXT_VIEW
GTK_IS_TEXT_VIEW
GTK_TYPE_TEXT_VIEW
GTK_TEXT_VIEW_CLASS
GTK_IS_TEXT_VIEW_CLASS
GTK_TEXT_VIEW_GET_CLASS
GtkTextChildAnchorClass
GTK_TEXT_CHILD_ANCHOR
GTK_IS_TEXT_CHILD_ANCHOR
GTK_TYPE_TEXT_CHILD_ANCHOR
GTK_TEXT_CHILD_ANCHOR_CLASS
GTK_IS_TEXT_CHILD_ANCHOR_CLASS
GTK_TEXT_CHILD_ANCHOR_GET_CLASS
GtkTextViewPrivate
gtk_text_view_get_type
gtk_text_child_anchor_get_type
GtkTextBTree
gtktogglebutton
GtkToggleButton
GtkToggleButton
gtk_toggle_button_new
gtk_toggle_button_new_with_label
gtk_toggle_button_new_with_mnemonic
gtk_toggle_button_toggled
gtk_toggle_button_get_active
gtk_toggle_button_set_active
GTK_TOGGLE_BUTTON
GTK_IS_TOGGLE_BUTTON
GTK_TYPE_TOGGLE_BUTTON
GTK_TOGGLE_BUTTON_CLASS
GTK_IS_TOGGLE_BUTTON_CLASS
GTK_TOGGLE_BUTTON_GET_CLASS
gtk_toggle_button_get_type
GtkToggleButtonPrivate
gtktooltip
GtkTooltip
GtkTooltip
gtk_tooltip_set_markup
gtk_tooltip_set_text
gtk_tooltip_set_icon
gtk_tooltip_set_icon_from_icon_name
gtk_tooltip_set_icon_from_gicon
gtk_tooltip_set_custom
gtk_tooltip_set_tip_area
GTK_TYPE_TOOLTIP
GTK_IS_TOOLTIP
GTK_TOOLTIP
gtk_tooltip_get_type
gtktreelistrow
GtkTreeListRow
gtk_tree_list_row_get_item
gtk_tree_list_row_set_expanded
gtk_tree_list_row_get_expanded
gtk_tree_list_row_is_expandable
gtk_tree_list_row_get_position
gtk_tree_list_row_get_depth
gtk_tree_list_row_get_children
gtk_tree_list_row_get_parent
gtk_tree_list_row_get_child_row
GTK_TREE_LIST_ROW
GTK_IS_TREE_LIST_ROW
GTK_TYPE_TREE_LIST_ROW
GTK_TREE_LIST_ROW_CLASS
GTK_IS_TREE_LIST_ROW_CLASS
GTK_TREE_LIST_ROW_GET_CLASS
gtk_tree_list_row_get_type
gtktreelistmodel
GtkTreeListModel
GtkTreeListModel
GtkTreeListRow
GtkTreeListModelCreateModelFunc
gtk_tree_list_model_new
gtk_tree_list_model_get_model
gtk_tree_list_model_get_passthrough
gtk_tree_list_model_set_autoexpand
gtk_tree_list_model_get_autoexpand
gtk_tree_list_model_get_child_row
gtk_tree_list_model_get_row
GTK_TREE_LIST_MODEL
GTK_IS_TREE_LIST_MODEL
GTK_TYPE_TREE_LIST_MODEL
GTK_TREE_LIST_MODEL_CLASS
GTK_IS_TREE_LIST_MODEL_CLASS
GTK_TREE_LIST_MODEL_GET_CLASS
gtk_tree_list_row_get_type
gtktreemodel
GtkTreeModel
GtkTreeModel
GtkTreeIter
GtkTreePath
GtkTreeRowReference
GtkTreeModelIface
GtkTreeModelForeachFunc
GtkTreeModelFlags
gtk_tree_path_new
gtk_tree_path_new_from_string
gtk_tree_path_new_from_indices
gtk_tree_path_new_from_indicesv
gtk_tree_path_to_string
gtk_tree_path_new_first
gtk_tree_path_append_index
gtk_tree_path_prepend_index
gtk_tree_path_get_depth
gtk_tree_path_get_indices
gtk_tree_path_get_indices_with_depth
gtk_tree_path_free
gtk_tree_path_copy
gtk_tree_path_compare
gtk_tree_path_next
gtk_tree_path_prev
gtk_tree_path_up
gtk_tree_path_down
gtk_tree_path_is_ancestor
gtk_tree_path_is_descendant
gtk_tree_row_reference_new
gtk_tree_row_reference_new_proxy
gtk_tree_row_reference_get_model
gtk_tree_row_reference_get_path
gtk_tree_row_reference_valid
gtk_tree_row_reference_free
gtk_tree_row_reference_copy
gtk_tree_row_reference_inserted
gtk_tree_row_reference_deleted
gtk_tree_row_reference_reordered
gtk_tree_iter_copy
gtk_tree_iter_free
gtk_tree_model_get_flags
gtk_tree_model_get_n_columns
gtk_tree_model_get_column_type
gtk_tree_model_get_iter
gtk_tree_model_get_iter_from_string
gtk_tree_model_get_iter_first
gtk_tree_model_get_path
gtk_tree_model_get_value
gtk_tree_model_iter_next
gtk_tree_model_iter_previous
gtk_tree_model_iter_children
gtk_tree_model_iter_has_child
gtk_tree_model_iter_n_children
gtk_tree_model_iter_nth_child
gtk_tree_model_iter_parent
gtk_tree_model_get_string_from_iter
gtk_tree_model_ref_node
gtk_tree_model_unref_node
gtk_tree_model_get
gtk_tree_model_get_valist
gtk_tree_model_foreach
gtk_tree_model_row_changed
gtk_tree_model_row_inserted
gtk_tree_model_row_has_child_toggled
gtk_tree_model_row_deleted
gtk_tree_model_rows_reordered
gtk_tree_model_rows_reordered_with_length
GTK_TREE_MODEL
GTK_IS_TREE_MODEL
GTK_TYPE_TREE_MODEL
GTK_TREE_MODEL_GET_IFACE
GTK_TYPE_TREE_ITER
GTK_TYPE_TREE_PATH
GTK_TYPE_TREE_ROW_REFERENCE
gtk_tree_row_reference_get_type
gtk_tree_model_get_type
gtk_tree_iter_get_type
gtk_tree_path_get_type
gtktreemodelsort
GtkTreeModelSort
GtkTreeModelSort
gtk_tree_model_sort_new_with_model
gtk_tree_model_sort_get_model
gtk_tree_model_sort_convert_child_path_to_path
gtk_tree_model_sort_convert_child_iter_to_iter
gtk_tree_model_sort_convert_path_to_child_path
gtk_tree_model_sort_convert_iter_to_child_iter
gtk_tree_model_sort_reset_default_sort_func
gtk_tree_model_sort_clear_cache
gtk_tree_model_sort_iter_is_valid
GTK_TREE_MODEL_SORT
GTK_IS_TREE_MODEL_SORT
GTK_TYPE_TREE_MODEL_SORT
GTK_TREE_MODEL_SORT_CLASS
GTK_IS_TREE_MODEL_SORT_CLASS
GTK_TREE_MODEL_SORT_GET_CLASS
GtkTreeModelSortPrivate
gtk_tree_model_sort_get_type
gtktreemodelfilter
GtkTreeModelFilter
GtkTreeModelFilter
GtkTreeModelFilterVisibleFunc
GtkTreeModelFilterModifyFunc
gtk_tree_model_filter_new
gtk_tree_model_filter_set_visible_func
gtk_tree_model_filter_set_modify_func
gtk_tree_model_filter_set_visible_column
gtk_tree_model_filter_get_model
gtk_tree_model_filter_convert_child_iter_to_iter
gtk_tree_model_filter_convert_iter_to_child_iter
gtk_tree_model_filter_convert_child_path_to_path
gtk_tree_model_filter_convert_path_to_child_path
gtk_tree_model_filter_refilter
gtk_tree_model_filter_clear_cache
GTK_TYPE_TREE_MODEL_FILTER
GTK_TREE_MODEL_FILTER
GTK_TREE_MODEL_FILTER_CLASS
GTK_IS_TREE_MODEL_FILTER
GTK_IS_TREE_MODEL_FILTER_CLASS
GTK_TREE_MODEL_FILTER_GET_CLASS
GtkTreeModelFilterPrivate
gtk_tree_model_filter_get_type
gtktreeselection
GtkTreeSelection
GtkTreeSelection
GtkTreeSelectionFunc
GtkTreeSelectionForeachFunc
gtk_tree_selection_set_mode
gtk_tree_selection_get_mode
gtk_tree_selection_set_select_function
gtk_tree_selection_get_select_function
gtk_tree_selection_get_user_data
gtk_tree_selection_get_tree_view
gtk_tree_selection_get_selected
gtk_tree_selection_selected_foreach
gtk_tree_selection_get_selected_rows
gtk_tree_selection_count_selected_rows
gtk_tree_selection_select_path
gtk_tree_selection_unselect_path
gtk_tree_selection_path_is_selected
gtk_tree_selection_select_iter
gtk_tree_selection_unselect_iter
gtk_tree_selection_iter_is_selected
gtk_tree_selection_select_all
gtk_tree_selection_unselect_all
gtk_tree_selection_select_range
gtk_tree_selection_unselect_range
GTK_TREE_SELECTION
GTK_IS_TREE_SELECTION
GTK_TYPE_TREE_SELECTION
GTK_TREE_SELECTION_CLASS
GTK_TREE_SELECTION_GET_CLASS
GTK_IS_TREE_SELECTION_CLASS
GtkTreeSelectionPrivate
gtk_tree_selection_get_type
gtktreesortable
GtkTreeSortable
GtkTreeSortable
GtkTreeSortableIface
GtkTreeIterCompareFunc
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID
gtk_tree_sortable_sort_column_changed
gtk_tree_sortable_get_sort_column_id
gtk_tree_sortable_set_sort_column_id
gtk_tree_sortable_set_sort_func
gtk_tree_sortable_set_default_sort_func
gtk_tree_sortable_has_default_sort_func
GTK_TREE_SORTABLE
GTK_IS_TREE_SORTABLE
GTK_TYPE_TREE_SORTABLE
GTK_TREE_SORTABLE_CLASS
GTK_TREE_SORTABLE_GET_IFACE
gtk_tree_sortable_get_type
gtktreednd
GtkTreeView drag-and-drop
GtkTreeDragSource
GtkTreeDragSourceIface
gtk_tree_drag_source_drag_data_delete
gtk_tree_drag_source_drag_data_get
gtk_tree_drag_source_row_draggable
GtkTreeDragDest
GtkTreeDragDestIface
gtk_tree_drag_dest_drag_data_received
gtk_tree_drag_dest_row_drop_possible
GTK_TYPE_TREE_ROW_DATA
gtk_tree_create_row_drag_content
gtk_tree_get_row_drag_data
GTK_TYPE_TREE_DRAG_DEST
GTK_TREE_DRAG_DEST
GTK_IS_TREE_DRAG_DEST
GTK_TREE_DRAG_DEST_GET_IFACE
GTK_TREE_DRAG_SOURCE
GTK_IS_TREE_DRAG_SOURCE
GTK_TYPE_TREE_DRAG_SOURCE
GTK_TREE_DRAG_SOURCE_GET_IFACE
gtk_tree_row_data_get_type
gtk_tree_drag_source_get_type
gtk_tree_drag_dest_get_type
gtktreestore
GtkTreeStore
GtkTreeStore
gtk_tree_store_new
gtk_tree_store_newv
gtk_tree_store_set_column_types
gtk_tree_store_set_value
gtk_tree_store_set
gtk_tree_store_set_valist
gtk_tree_store_set_valuesv
gtk_tree_store_remove
gtk_tree_store_insert
gtk_tree_store_insert_before
gtk_tree_store_insert_after
gtk_tree_store_insert_with_values
gtk_tree_store_insert_with_valuesv
gtk_tree_store_prepend
gtk_tree_store_append
gtk_tree_store_is_ancestor
gtk_tree_store_iter_depth
gtk_tree_store_clear
gtk_tree_store_iter_is_valid
gtk_tree_store_reorder
gtk_tree_store_swap
gtk_tree_store_move_before
gtk_tree_store_move_after
GTK_TREE_STORE
GTK_IS_TREE_STORE
GTK_TYPE_TREE_STORE
GTK_TREE_STORE_CLASS
GTK_IS_TREE_STORE_CLASS
GTK_TREE_STORE_GET_CLASS
GtkTreeStorePrivate
gtk_tree_store_get_type
gtktreeviewcolumn
GtkTreeViewColumn
GtkTreeViewColumnSizing
GtkTreeCellDataFunc
GtkTreeViewColumn
gtk_tree_view_column_new
gtk_tree_view_column_new_with_area
gtk_tree_view_column_new_with_attributes
gtk_tree_view_column_pack_start
gtk_tree_view_column_pack_end
gtk_tree_view_column_clear
gtk_tree_view_column_add_attribute
gtk_tree_view_column_set_attributes
gtk_tree_view_column_set_cell_data_func
gtk_tree_view_column_clear_attributes
gtk_tree_view_column_set_spacing
gtk_tree_view_column_get_spacing
gtk_tree_view_column_set_visible
gtk_tree_view_column_get_visible
gtk_tree_view_column_set_resizable
gtk_tree_view_column_get_resizable
gtk_tree_view_column_set_sizing
gtk_tree_view_column_get_sizing
gtk_tree_view_column_get_width
gtk_tree_view_column_get_fixed_width
gtk_tree_view_column_set_fixed_width
gtk_tree_view_column_set_min_width
gtk_tree_view_column_get_min_width
gtk_tree_view_column_set_max_width
gtk_tree_view_column_get_max_width
gtk_tree_view_column_clicked
gtk_tree_view_column_set_title
gtk_tree_view_column_get_title
gtk_tree_view_column_set_expand
gtk_tree_view_column_get_expand
gtk_tree_view_column_set_clickable
gtk_tree_view_column_get_clickable
gtk_tree_view_column_set_widget
gtk_tree_view_column_get_widget
gtk_tree_view_column_get_button
gtk_tree_view_column_set_alignment
gtk_tree_view_column_get_alignment
gtk_tree_view_column_set_reorderable
gtk_tree_view_column_get_reorderable
gtk_tree_view_column_set_sort_column_id
gtk_tree_view_column_get_sort_column_id
gtk_tree_view_column_set_sort_indicator
gtk_tree_view_column_get_sort_indicator
gtk_tree_view_column_set_sort_order
gtk_tree_view_column_get_sort_order
gtk_tree_view_column_cell_set_cell_data
gtk_tree_view_column_cell_get_size
gtk_tree_view_column_cell_get_position
gtk_tree_view_column_cell_is_visible
gtk_tree_view_column_focus_cell
gtk_tree_view_column_queue_resize
gtk_tree_view_column_get_tree_view
gtk_tree_view_column_get_x_offset
GTK_TREE_VIEW_COLUMN
GTK_IS_TREE_VIEW_COLUMN
GTK_TYPE_TREE_VIEW_COLUMN
GTK_TREE_VIEW_COLUMN_CLASS
GTK_IS_TREE_VIEW_COLUMN_CLASS
GTK_TREE_VIEW_COLUMN_GET_CLASS
GtkTreeViewColumnPrivate
gtk_tree_view_column_get_type
gtktreeview
GtkTreeView
GtkTreeView
GtkTreeViewDropPosition
GtkTreeViewColumnDropFunc
GtkTreeViewMappingFunc
GtkTreeViewSearchEqualFunc
gtk_tree_view_new
gtk_tree_view_get_level_indentation
gtk_tree_view_get_show_expanders
gtk_tree_view_set_level_indentation
gtk_tree_view_set_show_expanders
gtk_tree_view_new_with_model
gtk_tree_view_get_model
gtk_tree_view_set_model
gtk_tree_view_get_selection
gtk_tree_view_get_headers_visible
gtk_tree_view_set_headers_visible
gtk_tree_view_columns_autosize
gtk_tree_view_get_headers_clickable
gtk_tree_view_set_headers_clickable
gtk_tree_view_set_activate_on_single_click
gtk_tree_view_get_activate_on_single_click
gtk_tree_view_append_column
gtk_tree_view_remove_column
gtk_tree_view_insert_column
gtk_tree_view_insert_column_with_attributes
gtk_tree_view_insert_column_with_data_func
gtk_tree_view_get_n_columns
gtk_tree_view_get_column
gtk_tree_view_get_columns
gtk_tree_view_move_column_after
gtk_tree_view_set_expander_column
gtk_tree_view_get_expander_column
gtk_tree_view_set_column_drag_function
gtk_tree_view_scroll_to_point
gtk_tree_view_scroll_to_cell
gtk_tree_view_set_cursor
gtk_tree_view_set_cursor_on_cell
gtk_tree_view_get_cursor
gtk_tree_view_row_activated
gtk_tree_view_expand_all
gtk_tree_view_collapse_all
gtk_tree_view_expand_to_path
gtk_tree_view_expand_row
gtk_tree_view_collapse_row
gtk_tree_view_map_expanded_rows
gtk_tree_view_row_expanded
gtk_tree_view_set_reorderable
gtk_tree_view_get_reorderable
gtk_tree_view_get_path_at_pos
gtk_tree_view_is_blank_at_pos
gtk_tree_view_get_cell_area
gtk_tree_view_get_background_area
gtk_tree_view_get_visible_rect
gtk_tree_view_get_visible_range
gtk_tree_view_convert_bin_window_to_tree_coords
gtk_tree_view_convert_bin_window_to_widget_coords
gtk_tree_view_convert_tree_to_bin_window_coords
gtk_tree_view_convert_tree_to_widget_coords
gtk_tree_view_convert_widget_to_bin_window_coords
gtk_tree_view_convert_widget_to_tree_coords
gtk_tree_view_enable_model_drag_dest
gtk_tree_view_enable_model_drag_source
gtk_tree_view_unset_rows_drag_source
gtk_tree_view_unset_rows_drag_dest
gtk_tree_view_set_drag_dest_row
gtk_tree_view_get_drag_dest_row
gtk_tree_view_get_dest_row_at_pos
gtk_tree_view_create_row_drag_icon
gtk_tree_view_set_enable_search
gtk_tree_view_get_enable_search
gtk_tree_view_get_search_column
gtk_tree_view_set_search_column
gtk_tree_view_get_search_equal_func
gtk_tree_view_set_search_equal_func
gtk_tree_view_get_search_entry
gtk_tree_view_set_search_entry
gtk_tree_view_get_fixed_height_mode
gtk_tree_view_set_fixed_height_mode
gtk_tree_view_get_hover_selection
gtk_tree_view_set_hover_selection
gtk_tree_view_get_hover_expand
gtk_tree_view_set_hover_expand
GtkTreeViewRowSeparatorFunc
gtk_tree_view_get_row_separator_func
gtk_tree_view_set_row_separator_func
gtk_tree_view_get_rubber_banding
gtk_tree_view_set_rubber_banding
gtk_tree_view_is_rubber_banding_active
gtk_tree_view_get_enable_tree_lines
gtk_tree_view_set_enable_tree_lines
GtkTreeViewGridLines
gtk_tree_view_get_grid_lines
gtk_tree_view_set_grid_lines
gtk_tree_view_set_tooltip_row
gtk_tree_view_set_tooltip_cell
gtk_tree_view_get_tooltip_context
gtk_tree_view_get_tooltip_column
gtk_tree_view_set_tooltip_column
GTK_TREE_VIEW
GTK_IS_TREE_VIEW
GTK_TYPE_TREE_VIEW
GTK_TREE_VIEW_CLASS
GTK_IS_TREE_VIEW_CLASS
GTK_TREE_VIEW_GET_CLASS
gtk_tree_view_get_type
gtkcellview
GtkCellView
GtkCellView
gtk_cell_view_new
gtk_cell_view_new_with_context
gtk_cell_view_new_with_text
gtk_cell_view_new_with_markup
gtk_cell_view_new_with_texture
gtk_cell_view_set_model
gtk_cell_view_get_model
gtk_cell_view_set_displayed_row
gtk_cell_view_get_displayed_row
gtk_cell_view_set_draw_sensitive
gtk_cell_view_get_draw_sensitive
gtk_cell_view_set_fit_model
gtk_cell_view_get_fit_model
GTK_TYPE_CELL_VIEW
GTK_CELL_VIEW
GTK_CELL_VIEW_CLASS
GTK_IS_CELL_VIEW
GTK_IS_CELL_VIEW_CLASS
GTK_CELL_VIEW_GET_CLASS
GtkCellViewPrivate
gtk_cell_view_get_type
gtkcelllayout
GtkCellLayout
GtkCellLayout
GtkCellLayoutIface
GtkCellLayoutDataFunc
gtk_cell_layout_pack_start
gtk_cell_layout_pack_end
gtk_cell_layout_get_area
gtk_cell_layout_get_cells
gtk_cell_layout_reorder
gtk_cell_layout_clear
gtk_cell_layout_set_attributes
gtk_cell_layout_add_attribute
gtk_cell_layout_set_cell_data_func
gtk_cell_layout_clear_attributes
GTK_TYPE_CELL_LAYOUT
GTK_CELL_LAYOUT
GTK_IS_CELL_LAYOUT
GTK_CELL_LAYOUT_GET_IFACE
gtk_cell_layout_get_type
gtkcellarea
GtkCellArea
GtkCellArea
GtkCellAreaClass
GtkCellCallback
GtkCellAllocCallback
GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID
gtk_cell_area_add
gtk_cell_area_remove
gtk_cell_area_has_renderer
gtk_cell_area_foreach
gtk_cell_area_foreach_alloc
gtk_cell_area_event
gtk_cell_area_snapshot
gtk_cell_area_get_cell_allocation
gtk_cell_area_get_cell_at_position
gtk_cell_area_create_context
gtk_cell_area_copy_context
gtk_cell_area_get_request_mode
gtk_cell_area_get_preferred_width
gtk_cell_area_get_preferred_height_for_width
gtk_cell_area_get_preferred_height
gtk_cell_area_get_preferred_width_for_height
gtk_cell_area_get_current_path_string
gtk_cell_area_apply_attributes
gtk_cell_area_attribute_connect
gtk_cell_area_attribute_disconnect
gtk_cell_area_attribute_get_column
gtk_cell_area_class_install_cell_property
gtk_cell_area_class_find_cell_property
gtk_cell_area_class_list_cell_properties
gtk_cell_area_add_with_properties
gtk_cell_area_cell_set
gtk_cell_area_cell_get
gtk_cell_area_cell_set_valist
gtk_cell_area_cell_get_valist
gtk_cell_area_cell_set_property
gtk_cell_area_cell_get_property
gtk_cell_area_is_activatable
gtk_cell_area_activate
gtk_cell_area_focus
gtk_cell_area_set_focus_cell
gtk_cell_area_get_focus_cell
gtk_cell_area_add_focus_sibling
gtk_cell_area_remove_focus_sibling
gtk_cell_area_is_focus_sibling
gtk_cell_area_get_focus_siblings
gtk_cell_area_get_focus_from_sibling
gtk_cell_area_get_edited_cell
gtk_cell_area_get_edit_widget
gtk_cell_area_activate_cell
gtk_cell_area_stop_editing
gtk_cell_area_inner_cell_area
gtk_cell_area_request_renderer
GTK_CELL_AREA
GTK_IS_CELL_AREA
GTK_TYPE_CELL_AREA
gtk_cell_area_get_type
GTK_CELL_AREA_CLASS
GTK_IS_CELL_AREA_CLASS
GTK_CELL_AREA_GET_CLASS
GtkCellAreaPrivate
gtkcellareacontext
GtkCellAreaContext
GtkCellAreaContextClass
GtkCellAreaContext
gtk_cell_area_context_get_area
gtk_cell_area_context_allocate
gtk_cell_area_context_reset
gtk_cell_area_context_get_preferred_width
gtk_cell_area_context_get_preferred_height
gtk_cell_area_context_get_preferred_height_for_width
gtk_cell_area_context_get_preferred_width_for_height
gtk_cell_area_context_get_allocation
gtk_cell_area_context_push_preferred_width
gtk_cell_area_context_push_preferred_height
GTK_CELL_AREA_CONTEXT
GTK_IS_CELL_AREA_CONTEXT
GTK_TYPE_CELL_AREA_CONTEXT
gtk_cell_area_context_get_type
GTK_CELL_AREA_CONTEXT_CLASS
GTK_IS_CELL_AREA_CONTEXT_CLASS
GTK_CELL_AREA_CONTEXT_GET_CLASS
GtkCellAreaContextPrivate
gtkcellareabox
GtkCellAreaBox
GtkCellAreaBox
gtk_cell_area_box_new
gtk_cell_area_box_pack_start
gtk_cell_area_box_pack_end
gtk_cell_area_box_get_spacing
gtk_cell_area_box_set_spacing
GTK_CELL_AREA_BOX
GTK_IS_CELL_AREA_BOX
GTK_TYPE_CELL_AREA_BOX
GTK_CELL_AREA_BOX_CLASS
GTK_IS_CELL_AREA_BOX_CLASS
GTK_CELL_AREA_BOX_GET_CLASS
GTK_CELL_AREA_BOX_CONTEXT
GTK_CELL_AREA_BOX_CONTEXT_CLASS
GTK_CELL_AREA_BOX_CONTEXT_GET_CLASS
GTK_IS_CELL_AREA_BOX_CONTEXT
GTK_IS_CELL_AREA_BOX_CONTEXT_CLASS
gtk_cell_area_box_get_type
GtkCellAreaBoxPrivate
gtkcellrenderer
GtkCellRenderer
GtkCellRendererState
GtkCellRendererMode
GtkCellRenderer
GtkCellRendererClass
gtk_cell_renderer_class_set_accessible_type
gtk_cell_renderer_get_aligned_area
gtk_cell_renderer_snapshot
gtk_cell_renderer_activate
gtk_cell_renderer_start_editing
gtk_cell_renderer_stop_editing
gtk_cell_renderer_get_fixed_size
gtk_cell_renderer_set_fixed_size
gtk_cell_renderer_get_visible
gtk_cell_renderer_set_visible
gtk_cell_renderer_get_sensitive
gtk_cell_renderer_set_sensitive
gtk_cell_renderer_get_alignment
gtk_cell_renderer_set_alignment
gtk_cell_renderer_get_padding
gtk_cell_renderer_set_padding
gtk_cell_renderer_get_state
gtk_cell_renderer_is_activatable
gtk_cell_renderer_get_preferred_height
gtk_cell_renderer_get_preferred_height_for_width
gtk_cell_renderer_get_preferred_size
gtk_cell_renderer_get_preferred_width
gtk_cell_renderer_get_preferred_width_for_height
gtk_cell_renderer_get_request_mode
GTK_CELL_RENDERER
GTK_IS_CELL_RENDERER
GTK_TYPE_CELL_RENDERER
GTK_CELL_RENDERER_CLASS
GTK_IS_CELL_RENDERER_CLASS
GTK_CELL_RENDERER_GET_CLASS
GtkCellRendererPrivate
GtkCellRendererClassPrivate
gtk_cell_renderer_get_type
gtk_cell_renderer_mode_get_type
gtk_cell_renderer_state_get_type
gtkcelleditable
GtkCellEditable
GtkCellEditable
GtkCellEditableIface
gtk_cell_editable_start_editing
gtk_cell_editable_editing_done
gtk_cell_editable_remove_widget
GTK_CELL_EDITABLE
GTK_IS_CELL_EDITABLE
GTK_TYPE_CELL_EDITABLE
GTK_CELL_EDITABLE_CLASS
GTK_CELL_EDITABLE_GET_IFACE
gtk_cell_editable_get_type
gtkcellrenderercombo
GtkCellRendererCombo
GtkCellRendererCombo
gtk_cell_renderer_combo_new
GTK_TYPE_CELL_RENDERER_COMBO
GTK_CELL_RENDERER_COMBO
GTK_CELL_RENDERER_COMBO_CLASS
GTK_IS_CELL_RENDERER_COMBO
GTK_IS_CELL_RENDERER_COMBO_CLASS
GTK_CELL_RENDERER_COMBO_GET_CLASS
gtk_cell_renderer_combo_get_type
GtkCellRendererComboPrivate
gtkcellrendererspin
GtkCellRendererSpin
GtkCellRendererSpin
gtk_cell_renderer_spin_new
GTK_TYPE_CELL_RENDERER_SPIN
GTK_CELL_RENDERER_SPIN
GTK_CELL_RENDERER_SPIN_CLASS
GTK_IS_CELL_RENDERER_SPIN
GTK_IS_CELL_RENDERER_SPIN_CLASS
GTK_CELL_RENDERER_SPIN_GET_CLASS
GtkCellRendererSpinPrivate
gtk_cell_renderer_spin_get_type
gtkcellrendererspinner
GtkCellRendererSpinner
GtkCellRendererSpinner
gtk_cell_renderer_spinner_new
GTK_TYPE_CELL_RENDERER_SPINNER
GTK_CELL_RENDERER_SPINNER
GTK_CELL_RENDERER_SPINNER_CLASS
GTK_IS_CELL_RENDERER_SPINNER
GTK_IS_CELL_RENDERER_SPINNER_CLASS
GTK_CELL_RENDERER_SPINNER_GET_CLASS
GtkCellRendererSpinnerPrivate
gtk_cell_renderer_spinner_get_type
gtkcellrendererpixbuf
GtkCellRendererPixbuf
GtkCellRendererPixbuf
gtk_cell_renderer_pixbuf_new
GTK_CELL_RENDERER_PIXBUF
GTK_IS_CELL_RENDERER_PIXBUF
GTK_TYPE_CELL_RENDERER_PIXBUF
GTK_CELL_RENDERER_PIXBUF_CLASS
GTK_IS_CELL_RENDERER_PIXBUF_CLASS
GTK_CELL_RENDERER_PIXBUF_GET_CLASS
gtk_cell_renderer_pixbuf_get_type
GtkCellRendererPixbufPrivate
gtkcellrenderertext
GtkCellRendererText
GtkCellRendererText
gtk_cell_renderer_text_new
gtk_cell_renderer_text_set_fixed_height_from_font
GTK_CELL_RENDERER_TEXT
GTK_IS_CELL_RENDERER_TEXT
GTK_TYPE_CELL_RENDERER_TEXT
GTK_CELL_RENDERER_TEXT_CLASS
GTK_IS_CELL_RENDERER_TEXT_CLASS
GTK_CELL_RENDERER_TEXT_GET_CLASS
gtk_cell_renderer_text_get_type
GtkCellRendererTextPrivate
gtkcellrenderertoggle
GtkCellRendererToggle
GtkCellRendererToggle
gtk_cell_renderer_toggle_new
gtk_cell_renderer_toggle_get_radio
gtk_cell_renderer_toggle_set_radio
gtk_cell_renderer_toggle_get_active
gtk_cell_renderer_toggle_set_active
gtk_cell_renderer_toggle_get_activatable
gtk_cell_renderer_toggle_set_activatable
GTK_CELL_RENDERER_TOGGLE
GTK_IS_CELL_RENDERER_TOGGLE
GTK_TYPE_CELL_RENDERER_TOGGLE
GTK_CELL_RENDERER_TOGGLE_CLASS
GTK_IS_CELL_RENDERER_TOGGLE_CLASS
GTK_CELL_RENDERER_TOGGLE_GET_CLASS
gtk_cell_renderer_toggle_get_type
GtkCellRendererTogglePrivate
gtkcellrendererprogress
GtkCellRendererProgress
GtkCellRendererProgress
gtk_cell_renderer_progress_new
GTK_CELL_RENDERER_PROGRESS
GTK_IS_CELL_RENDERER_PROGRESS
GTK_TYPE_CELL_RENDERER_PROGRESS
GTK_CELL_RENDERER_PROGRESS_CLASS
GTK_IS_CELL_RENDERER_PROGRESS_CLASS
GTK_CELL_RENDERER_PROGRESS_GET_CLASS
gtk_cell_renderer_progress_get_type
GtkCellRendererProgressPrivate
gtkcellrendereraccel
GtkCellRendererAccel
GtkCellRendererAccel
GtkCellRendererAccelMode
gtk_cell_renderer_accel_new
GTK_TYPE_CELL_RENDERER_ACCEL
GTK_CELL_RENDERER_ACCEL
GTK_CELL_RENDERER_ACCEL_CLASS
GTK_IS_CELL_RENDERER_ACCEL
GTK_IS_CELL_RENDERER_ACCEL_CLASS
GTK_CELL_RENDERER_ACCEL_GET_CLASS
gtk_cell_renderer_accel_get_type
gtk_cell_renderer_accel_mode_get_type
GtkCellRendererAccelPrivate
gtkliststore
GtkListStore
GtkListStore
gtk_list_store_new
gtk_list_store_newv
gtk_list_store_set_column_types
gtk_list_store_set
gtk_list_store_set_valist
gtk_list_store_set_value
gtk_list_store_set_valuesv
gtk_list_store_remove
gtk_list_store_insert
gtk_list_store_insert_before
gtk_list_store_insert_after
gtk_list_store_insert_with_values
gtk_list_store_insert_with_valuesv
gtk_list_store_prepend
gtk_list_store_append
gtk_list_store_clear
gtk_list_store_iter_is_valid
gtk_list_store_reorder
gtk_list_store_swap
gtk_list_store_move_before
gtk_list_store_move_after
GTK_LIST_STORE
GTK_IS_LIST_STORE
GTK_TYPE_LIST_STORE
GTK_LIST_STORE_CLASS
GTK_IS_LIST_STORE_CLASS
GTK_LIST_STORE_GET_CLASS
GtkListStorePrivate
gtk_list_store_get_type
gtkviewport
GtkViewport
GtkViewport
gtk_viewport_new
gtk_viewport_set_shadow_type
gtk_viewport_get_shadow_type
GTK_VIEWPORT
GTK_IS_VIEWPORT
GTK_TYPE_VIEWPORT
GTK_VIEWPORT_CLASS
GTK_IS_VIEWPORT_CLASS
GTK_VIEWPORT_GET_CLASS
GtkViewportPrivate
gtk_viewport_get_type
gtkvolumebutton
GtkVolumeButton
GtkVolumeButton
gtk_volume_button_new
GTK_VOLUME_BUTTON
GTK_IS_VOLUME_BUTTON
GTK_TYPE_VOLUME_BUTTON
GTK_VOLUME_BUTTON_CLASS
GTK_IS_VOLUME_BUTTON_CLASS
GTK_VOLUME_BUTTON_GET_CLASS
gtk_volume_button_get_type
gtksnapshot
GtkSnapshot
GtkSnapshot
gtk_snapshot_new
gtk_snapshot_to_node
gtk_snapshot_to_paintable
gtk_snapshot_free_to_node
gtk_snapshot_free_to_paintable
gtk_snapshot_push_opacity
gtk_snapshot_push_color_matrix
gtk_snapshot_push_repeat
gtk_snapshot_push_clip
gtk_snapshot_push_rounded_clip
gtk_snapshot_push_cross_fade
gtk_snapshot_push_blend
gtk_snapshot_push_blur
gtk_snapshot_push_shadow
gtk_snapshot_push_debug
gtk_snapshot_pop
gtk_snapshot_save
gtk_snapshot_restore
gtk_snapshot_transform
gtk_snapshot_transform_matrix
gtk_snapshot_translate
gtk_snapshot_translate_3d
gtk_snapshot_rotate
gtk_snapshot_rotate_3d
gtk_snapshot_scale
gtk_snapshot_scale_3d
gtk_snapshot_perspective
gtk_snapshot_append_node
gtk_snapshot_append_cairo
gtk_snapshot_append_texture
gtk_snapshot_append_color
gtk_snapshot_append_layout
gtk_snapshot_append_linear_gradient
gtk_snapshot_append_repeating_linear_gradient
gtk_snapshot_append_border
gtk_snapshot_append_inset_shadow
gtk_snapshot_append_outset_shadow
gtk_snapshot_render_background
gtk_snapshot_render_frame
gtk_snapshot_render_focus
gtk_snapshot_render_layout
gtk_snapshot_render_insertion_cursor
gtk_snapshot_get_type
gtkwidgetpaintable
GtkWidgetPaintable
gtk_widget_paintable_new
gtk_widget_paintable_get_widget
gtk_widget_paintable_set_widget
GTK_WIDGET_PAINTABLE
GTK_IS_WIDGET_PAINTABLE
GTK_TYPE_WIDGET_PAINTABLE
GTK_WIDGET_PAINTABLE_CLASS
GTK_IS_WIDGET_PAINTABLE_CLASS
GTK_WIDGET_PAINTABLE_GET_CLASS
gtk_widget_paintable_get_type
gtkwidget
GtkWidget
GtkWidget
GtkWidgetClass
GtkCallback
GtkRequisition
GtkAllocation
gtk_widget_new
gtk_widget_destroy
gtk_widget_in_destruction
gtk_widget_destroyed
gtk_widget_unparent
gtk_widget_show
gtk_widget_hide
gtk_widget_map
gtk_widget_unmap
gtk_widget_realize
gtk_widget_unrealize
gtk_widget_queue_draw
gtk_widget_queue_resize
gtk_widget_queue_allocate
gtk_widget_get_frame_clock
gtk_widget_get_scale_factor
GtkTickCallback
gtk_widget_add_tick_callback
gtk_widget_remove_tick_callback
gtk_widget_size_allocate
gtk_widget_allocate
gtk_widget_class_add_shortcut
gtk_widget_class_add_binding
gtk_widget_class_add_binding_signal
gtk_widget_can_activate_accel
gtk_widget_activate
gtk_widget_is_focus
gtk_widget_grab_focus
gtk_widget_set_name
gtk_widget_get_name
gtk_widget_set_sensitive
gtk_widget_set_parent
gtk_widget_get_root
gtk_widget_get_native
gtk_widget_get_ancestor
gtk_widget_is_ancestor
gtk_widget_translate_coordinates
gtk_widget_add_controller
gtk_widget_remove_controller
gtk_widget_set_direction
GtkTextDirection
gtk_widget_get_direction
gtk_widget_set_default_direction
gtk_widget_get_default_direction
gtk_widget_create_pango_context
gtk_widget_get_pango_context
gtk_widget_set_font_options
gtk_widget_get_font_options
gtk_widget_set_font_map
gtk_widget_get_font_map
gtk_widget_create_pango_layout
gtk_widget_get_cursor
gtk_widget_set_cursor
gtk_widget_set_cursor_from_name
gtk_widget_mnemonic_activate
gtk_widget_class_set_accessible_type
gtk_widget_class_set_accessible_role
gtk_widget_get_accessible
gtk_widget_child_focus
gtk_widget_get_child_visible
gtk_widget_get_parent
gtk_widget_get_settings
gtk_widget_get_clipboard
gtk_widget_get_primary_clipboard
gtk_widget_get_display
gtk_widget_get_size_request
gtk_widget_set_child_visible
gtk_widget_set_size_request
gtk_widget_list_mnemonic_labels
gtk_widget_add_mnemonic_label
gtk_widget_remove_mnemonic_label
gtk_widget_error_bell
gtk_widget_keynav_failed
gtk_widget_get_tooltip_markup
gtk_widget_set_tooltip_markup
gtk_widget_get_tooltip_text
gtk_widget_set_tooltip_text
gtk_widget_get_has_tooltip
gtk_widget_set_has_tooltip
gtk_widget_trigger_tooltip_query
gtk_widget_get_allocated_width
gtk_widget_get_allocated_height
gtk_widget_get_allocation
gtk_widget_get_allocated_baseline
gtk_widget_get_width
gtk_widget_get_height
gtk_widget_compute_bounds
gtk_widget_compute_transform
gtk_widget_compute_point
gtk_widget_contains
GtkPickFlags
gtk_widget_pick
gtk_widget_get_can_focus
gtk_widget_set_can_focus
gtk_widget_get_focus_on_click
gtk_widget_set_focus_on_click
gtk_widget_set_focus_child
gtk_widget_get_can_target
gtk_widget_set_can_target
gtk_widget_get_sensitive
gtk_widget_is_sensitive
gtk_widget_get_visible
gtk_widget_is_visible
gtk_widget_set_visible
gtk_widget_set_state_flags
gtk_widget_unset_state_flags
gtk_widget_get_state_flags
gtk_widget_has_default
gtk_widget_has_focus
gtk_widget_has_visible_focus
gtk_widget_has_grab
gtk_widget_is_drawable
gtk_widget_set_receives_default
gtk_widget_get_receives_default
gtk_widget_set_support_multidevice
gtk_widget_get_support_multidevice
gtk_widget_get_realized
gtk_widget_get_mapped
gtk_widget_device_is_shadowed
gtk_widget_get_modifier_mask
gtk_widget_get_opacity
gtk_widget_set_opacity
gtk_widget_get_overflow
gtk_widget_set_overflow
gtk_widget_measure
gtk_widget_snapshot_child
gtk_widget_get_next_sibling
gtk_widget_get_prev_sibling
gtk_widget_get_first_child
gtk_widget_get_last_child
gtk_widget_insert_before
gtk_widget_insert_after
gtk_widget_set_layout_manager
gtk_widget_get_layout_manager
gtk_widget_should_layout
gtk_widget_get_css_name
gtk_widget_add_css_class
gtk_widget_remove_css_class
gtk_widget_has_css_class
gtk_widget_get_css_classes
gtk_widget_set_css_classes
gtk_widget_get_style_context
gtk_widget_reset_style
gtk_widget_class_get_css_name
gtk_widget_class_set_css_name
gtk_requisition_new
gtk_requisition_copy
gtk_requisition_free
GtkSizeRequestMode
GtkRequestedSize
gtk_widget_get_request_mode
gtk_widget_get_preferred_size
gtk_distribute_natural_allocation
GtkAlign
gtk_widget_get_halign
gtk_widget_set_halign
gtk_widget_get_valign
gtk_widget_set_valign
gtk_widget_get_margin_start
gtk_widget_set_margin_start
gtk_widget_get_margin_end
gtk_widget_set_margin_end
gtk_widget_get_margin_top
gtk_widget_set_margin_top
gtk_widget_get_margin_bottom
gtk_widget_set_margin_bottom
gtk_widget_get_hexpand
gtk_widget_set_hexpand
gtk_widget_get_hexpand_set
gtk_widget_set_hexpand_set
gtk_widget_get_vexpand
gtk_widget_set_vexpand
gtk_widget_get_vexpand_set
gtk_widget_set_vexpand_set
gtk_widget_compute_expand
gtk_widget_init_template
gtk_widget_class_set_template
gtk_widget_class_set_template_from_resource
gtk_widget_get_template_child
gtk_widget_class_bind_template_child
gtk_widget_class_bind_template_child_internal
gtk_widget_class_bind_template_child_private
gtk_widget_class_bind_template_child_internal_private
gtk_widget_class_bind_template_child_full
gtk_widget_class_bind_template_callback
gtk_widget_class_bind_template_callback_full
gtk_widget_class_set_template_scope
gtk_widget_observe_children
gtk_widget_observe_controllers
gtk_widget_insert_action_group
gtk_widget_activate_action
gtk_widget_activate_action_variant
gtk_widget_activate_default
GtkWidgetActionActivateFunc
gtk_widget_class_install_action
gtk_widget_class_install_property_action
gtk_widget_class_query_action
gtk_widget_action_set_enabled
GTK_WIDGET
GTK_IS_WIDGET
GTK_TYPE_WIDGET
GTK_WIDGET_CLASS
GTK_IS_WIDGET_CLASS
GTK_WIDGET_GET_CLASS
GTK_TYPE_REQUISITION
GtkWidgetClassPrivate
GtkWidgetPrivate
gtk_widget_get_type
gtk_requisition_get_type
gtkwindow
GtkWindow
GtkWindow
GtkWindowClass
gtk_window_new
gtk_window_set_title
gtk_window_set_resizable
gtk_window_get_resizable
gtk_window_set_modal
gtk_window_set_default_size
gtk_window_set_hide_on_close
gtk_window_get_hide_on_close
gtk_window_set_transient_for
gtk_window_set_destroy_with_parent
gtk_window_set_display
gtk_window_is_active
gtk_window_is_maximized
gtk_window_get_toplevels
gtk_window_list_toplevels
gtk_window_get_focus
gtk_window_set_focus
gtk_window_get_default_widget
gtk_window_set_default_widget
gtk_window_present
gtk_window_present_with_time
gtk_window_close
gtk_window_minimize
gtk_window_unminimize
gtk_window_maximize
gtk_window_unmaximize
gtk_window_fullscreen
gtk_window_fullscreen_on_monitor
gtk_window_unfullscreen
gtk_window_set_decorated
gtk_window_set_deletable
gtk_window_set_startup_id
gtk_window_get_decorated
gtk_window_get_deletable
gtk_window_get_default_icon_name
gtk_window_get_default_size
gtk_window_get_destroy_with_parent
gtk_window_get_icon_name
gtk_window_get_modal
gtk_window_get_size
gtk_window_get_title
gtk_window_get_transient_for
gtk_window_get_group
gtk_window_has_group
gtk_window_resize
gtk_window_set_default_icon_name
gtk_window_set_icon_name
gtk_window_set_auto_startup_notification
gtk_window_get_mnemonics_visible
gtk_window_set_mnemonics_visible
gtk_window_get_focus_visible
gtk_window_set_focus_visible
gtk_window_get_application
gtk_window_set_application
gtk_window_set_has_user_ref_count
gtk_window_set_titlebar
gtk_window_get_titlebar
gtk_window_set_interactive_debugging
GTK_WINDOW
GTK_IS_WINDOW
GTK_TYPE_WINDOW
GTK_WINDOW_CLASS
GTK_IS_WINDOW_CLASS
GTK_WINDOW_GET_CLASS
GtkWindowPrivate
gtk_window_get_type
GtkWindowGeometryInfo
gtk_window_remove_embedded_xid
gtk_window_add_embedded_xid
GtkWindowKeysForeachFunc
gtkwindowgroup
GtkWindowGroup
GtkWindowGroup
gtk_window_group_new
gtk_window_group_add_window
gtk_window_group_remove_window
gtk_window_group_list_windows
GTK_IS_WINDOW_GROUP
GTK_IS_WINDOW_GROUP_CLASS
GTK_TYPE_WINDOW_GROUP
GTK_WINDOW_GROUP
GTK_WINDOW_GROUP_CLASS
GTK_WINDOW_GROUP_GET_CLASS
GtkWindowGroupPrivate
gtk_window_group_get_type
gtkmain
General
gtk_disable_setlocale
gtk_get_default_language
gtk_get_locale_direction
gtk_init
gtk_init_check
GTK_PRIORITY_RESIZE
gtk_get_current_event
gtk_get_current_event_time
gtk_get_current_event_state
gtk_get_current_event_device
gtk_init_abi_check
gtk_init_check_abi_check
GTKMAIN_C_VAR
gtkfeatures
Feature Test Macros
gtk_get_major_version
gtk_get_minor_version
gtk_get_micro_version
gtk_get_binary_age
gtk_get_interface_age
gtk_check_version
GTK_MAJOR_VERSION
GTK_MINOR_VERSION
GTK_MICRO_VERSION
GTK_BINARY_AGE
GTK_INTERFACE_AGE
GTK_CHECK_VERSION
gtkstyleprovider
GtkStyleProvider
GtkStyleProvider
GTK_STYLE_PROVIDER_PRIORITY_FALLBACK
GTK_STYLE_PROVIDER_PRIORITY_THEME
GTK_STYLE_PROVIDER_PRIORITY_SETTINGS
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
GTK_STYLE_PROVIDER_PRIORITY_USER
GTK_TYPE_STYLE_PROVIDER
GTK_STYLE_PROVIDER
GTK_IS_STYLE_PROVIDER
GTK_STYLE_PROVIDER_GET_IFACE
gtk_style_provider_get_type
gtkstylecontext
GtkStyleContext
GtkBorderStyle
GTK_STYLE_CLASS_ACCELERATOR
GTK_STYLE_CLASS_ARROW
GTK_STYLE_CLASS_BACKGROUND
GTK_STYLE_CLASS_BOTTOM
GTK_STYLE_CLASS_BUTTON
GTK_STYLE_CLASS_CALENDAR
GTK_STYLE_CLASS_CELL
GTK_STYLE_CLASS_COMBOBOX_ENTRY
GTK_STYLE_CLASS_CONTEXT_MENU
GTK_STYLE_CLASS_CHECK
GTK_STYLE_CLASS_CSD
GTK_STYLE_CLASS_CURSOR_HANDLE
GTK_STYLE_CLASS_DEFAULT
GTK_STYLE_CLASS_DESTRUCTIVE_ACTION
GTK_STYLE_CLASS_DIM_LABEL
GTK_STYLE_CLASS_DND
GTK_STYLE_CLASS_DOCK
GTK_STYLE_CLASS_ENTRY
GTK_STYLE_CLASS_ERROR
GTK_STYLE_CLASS_EXPANDER
GTK_STYLE_CLASS_FRAME
GTK_STYLE_CLASS_FLAT
GTK_STYLE_CLASS_HEADER
GTK_STYLE_CLASS_HIGHLIGHT
GTK_STYLE_CLASS_HORIZONTAL
GTK_STYLE_CLASS_IMAGE
GTK_STYLE_CLASS_INFO
GTK_STYLE_CLASS_INSERTION_CURSOR
GTK_STYLE_CLASS_LABEL
GTK_STYLE_CLASS_LEFT
GTK_STYLE_CLASS_LEVEL_BAR
GTK_STYLE_CLASS_LINKED
GTK_STYLE_CLASS_LIST
GTK_STYLE_CLASS_LIST_ROW
GTK_STYLE_CLASS_MARK
GTK_STYLE_CLASS_MENU
GTK_STYLE_CLASS_MENUBAR
GTK_STYLE_CLASS_MENUITEM
GTK_STYLE_CLASS_MESSAGE_DIALOG
GTK_STYLE_CLASS_MONOSPACE
GTK_STYLE_CLASS_NEEDS_ATTENTION
GTK_STYLE_CLASS_NOTEBOOK
GTK_STYLE_CLASS_OSD
GTK_STYLE_CLASS_OVERSHOOT
GTK_STYLE_CLASS_PANE_SEPARATOR
GTK_STYLE_CLASS_PAPER
GTK_STYLE_CLASS_POPUP
GTK_STYLE_CLASS_POPOVER
GTK_STYLE_CLASS_PROGRESSBAR
GTK_STYLE_CLASS_PULSE
GTK_STYLE_CLASS_QUESTION
GTK_STYLE_CLASS_RADIO
GTK_STYLE_CLASS_RAISED
GTK_STYLE_CLASS_READ_ONLY
GTK_STYLE_CLASS_RIGHT
GTK_STYLE_CLASS_RUBBERBAND
GTK_STYLE_CLASS_SCALE
GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE
GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW
GTK_STYLE_CLASS_SCROLLBAR
GTK_STYLE_CLASS_SCROLLBARS_JUNCTION
GTK_STYLE_CLASS_SEPARATOR
GTK_STYLE_CLASS_SIDEBAR
GTK_STYLE_CLASS_SLIDER
GTK_STYLE_CLASS_SPINBUTTON
GTK_STYLE_CLASS_SPINNER
GTK_STYLE_CLASS_STATUSBAR
GTK_STYLE_CLASS_SUBTITLE
GTK_STYLE_CLASS_SUGGESTED_ACTION
GTK_STYLE_CLASS_TITLE
GTK_STYLE_CLASS_TITLEBAR
GTK_STYLE_CLASS_TOOLBAR
GTK_STYLE_CLASS_TOOLTIP
GTK_STYLE_CLASS_TOUCH_SELECTION
GTK_STYLE_CLASS_TOP
GTK_STYLE_CLASS_TROUGH
GTK_STYLE_CLASS_UNDERSHOOT
GTK_STYLE_CLASS_VERTICAL
GTK_STYLE_CLASS_VIEW
GTK_STYLE_CLASS_WARNING
GTK_STYLE_CLASS_WIDE
GtkStyleContext
gtk_style_context_add_provider
gtk_style_context_add_provider_for_display
gtk_style_context_get_display
gtk_style_context_get_state
gtk_style_context_get_color
gtk_style_context_get_border
gtk_style_context_get_padding
gtk_style_context_get_margin
gtk_style_context_lookup_color
gtk_style_context_remove_provider
gtk_style_context_remove_provider_for_display
gtk_style_context_reset_widgets
gtk_style_context_restore
gtk_style_context_save
gtk_style_context_add_class
gtk_style_context_remove_class
gtk_style_context_has_class
gtk_style_context_list_classes
gtk_style_context_set_display
gtk_style_context_set_state
gtk_style_context_set_scale
gtk_style_context_get_scale
GtkStyleContextPrintFlags
gtk_style_context_to_string
GtkBorder
gtk_border_new
gtk_border_copy
gtk_border_free
gtk_render_arrow
gtk_render_background
gtk_render_check
gtk_render_expander
gtk_render_focus
gtk_render_frame
gtk_render_handle
gtk_render_layout
gtk_render_line
gtk_render_option
gtk_render_activity
gtk_render_icon
gtk_render_insertion_cursor
GTK_TYPE_STYLE_CONTEXT
GTK_STYLE_CONTEXT
GTK_STYLE_CONTEXT_CLASS
GTK_STYLE_CONTEXT_GET_CLASS
GTK_IS_STYLE_CONTEXT
GTK_IS_STYLE_CONTEXT_CLASS
GTK_TYPE_BORDER
GtkStyleContextPrivate
gtk_style_context_get_type
gtk_border_get_type
gtkcssprovider
GtkCssProvider
GtkCssProvider
gtk_css_provider_load_named
gtk_css_provider_load_from_data
gtk_css_provider_load_from_file
gtk_css_provider_load_from_path
gtk_css_provider_load_from_resource
gtk_css_provider_new
gtk_css_provider_to_string
GTK_CSS_PARSER_ERROR
GtkCssParserError
GtkCssParserWarning
GtkCssLocation
GtkCssSection
gtk_css_section_new
gtk_css_section_ref
gtk_css_section_unref
gtk_css_section_print
gtk_css_section_to_string
gtk_css_section_get_file
gtk_css_section_get_parent
gtk_css_section_get_start_location
gtk_css_section_get_end_location
GTK_TYPE_CSS_PROVIDER
GTK_CSS_PROVIDER
GTK_CSS_PROVIDER_CLASS
GTK_CSS_PROVIDER_GET_CLASS
GTK_IS_CSS_PROVIDER
GTK_IS_CSS_PROVIDER_CLASS
GTK_TYPE_CSS_SECTION
GtkCssProviderPrivate
gtk_css_provider_get_type
gtk_css_provider_error_quark
gtk_css_section_get_type
gtkenums
Standard Enumerations
GtkBaselinePosition
GtkDeleteType
GtkDirectionType
GtkJustification
GtkMovementStep
GtkOrientation
GtkPackType
GtkPositionType
GtkReliefStyle
GtkScrollStep
GtkScrollType
GtkSelectionMode
GtkShadowType
GtkStateFlags
GtkSortType
GtkIconSize
gtkicontheme
GtkIconTheme
GtkIconPaintable
GtkIconTheme
GtkIconLookupFlags
GTK_ICON_THEME_ERROR
GTK_TYPE_ICON_THEME_ERROR
GTK_TYPE_ICON_LOOKUP_FLAGS
GtkIconThemeError
gtk_icon_theme_new
gtk_icon_theme_get_for_display
gtk_icon_theme_set_search_path
gtk_icon_theme_get_search_path
gtk_icon_theme_add_search_path
gtk_icon_theme_set_resource_path
gtk_icon_theme_get_resource_path
gtk_icon_theme_add_resource_path
gtk_icon_theme_set_theme_name
gtk_icon_theme_get_theme_name
gtk_icon_theme_has_icon
gtk_icon_theme_lookup_icon
gtk_icon_theme_lookup_by_gicon
gtk_icon_theme_get_icon_names
gtk_icon_theme_get_icon_sizes
gtk_icon_paintable_new_for_file
gtk_icon_paintable_get_file
gtk_icon_paintable_get_icon_name
gtk_icon_paintable_is_symbolic
GtkIconClass
GTK_ICON_THEME
GTK_IS_ICON_THEME
GTK_TYPE_ICON_THEME
gtk_icon_theme_get_type
GTK_ICON_THEME_CLASS
GTK_IS_ICON_THEME_CLASS
GTK_ICON_THEME_GET_CLASS
gtk_icon_paintable_get_type
GTK_ICON_PAINTABLE
GTK_IS_ICON
GTK_TYPE_ICON
GTK_ICON_PAINTABLE_CLASS
GTK_ICON_PAINTABLE_GET_CLASS
GTK_IS_ICON_CLASS
GtkIconThemePrivate
gtk_icon_theme_error_quark
gtkprintoperation
High-level Printing API
GtkPrintOperation
GtkPrintOperationClass
GtkPrintStatus
GtkPrintOperationAction
GtkPrintOperationResult
GtkPrintError
GTK_PRINT_ERROR
gtk_print_operation_new
gtk_print_operation_set_allow_async
gtk_print_operation_get_error
gtk_print_operation_set_default_page_setup
gtk_print_operation_get_default_page_setup
gtk_print_operation_set_print_settings
gtk_print_operation_get_print_settings
gtk_print_operation_set_job_name
gtk_print_operation_set_n_pages
gtk_print_operation_get_n_pages_to_print
gtk_print_operation_set_current_page
gtk_print_operation_set_use_full_page
gtk_print_operation_set_unit
gtk_print_operation_set_export_filename
gtk_print_operation_set_show_progress
gtk_print_operation_set_track_print_status
gtk_print_operation_set_custom_tab_label
gtk_print_operation_run
gtk_print_operation_cancel
gtk_print_operation_draw_page_finish
gtk_print_operation_set_defer_drawing
gtk_print_operation_get_status
gtk_print_operation_get_status_string
gtk_print_operation_is_finished
gtk_print_operation_set_support_selection
gtk_print_operation_get_support_selection
gtk_print_operation_set_has_selection
gtk_print_operation_get_has_selection
gtk_print_operation_set_embed_page_setup
gtk_print_operation_get_embed_page_setup
gtk_print_run_page_setup_dialog
GtkPageSetupDoneFunc
gtk_print_run_page_setup_dialog_async
GtkPrintOperationPreview
gtk_print_operation_preview_end_preview
gtk_print_operation_preview_is_selected
gtk_print_operation_preview_render_page
GTK_TYPE_PRINT_OPERATION
GTK_PRINT_OPERATION
GTK_IS_PRINT_OPERATION
GTK_IS_PRINT_OPERATION_CLASS
GTK_PRINT_OPERATION_CLASS
GTK_PRINT_OPERATION_GET_CLASS
GTK_IS_PRINT_OPERATION_PREVIEW
GTK_PRINT_OPERATION_PREVIEW
GTK_PRINT_OPERATION_PREVIEW_GET_IFACE
GTK_TYPE_PRINT_OPERATION_PREVIEW
GtkPrintOperationPreviewIface
gtk_print_error_quark
gtk_print_operation_get_type
gtk_print_operation_preview_get_type
GtkPrintOperationPrivate
gtkprintunixdialog
GtkPrintUnixDialog
GtkPrintUnixDialog
gtk_print_unix_dialog_new
gtk_print_unix_dialog_set_page_setup
gtk_print_unix_dialog_get_page_setup
gtk_print_unix_dialog_set_current_page
gtk_print_unix_dialog_get_current_page
gtk_print_unix_dialog_set_settings
gtk_print_unix_dialog_get_settings
gtk_print_unix_dialog_get_selected_printer
gtk_print_unix_dialog_add_custom_tab
gtk_print_unix_dialog_set_support_selection
gtk_print_unix_dialog_get_support_selection
gtk_print_unix_dialog_set_has_selection
gtk_print_unix_dialog_get_has_selection
gtk_print_unix_dialog_set_embed_page_setup
gtk_print_unix_dialog_get_embed_page_setup
gtk_print_unix_dialog_get_page_setup_set
GtkPrintCapabilities
gtk_print_unix_dialog_set_manual_capabilities
gtk_print_unix_dialog_get_manual_capabilities
GTK_TYPE_PRINT_UNIX_DIALOG
GTK_PRINT_UNIX_DIALOG
GTK_PRINT_UNIX_DIALOG_CLASS
GTK_IS_PRINT_UNIX_DIALOG
GTK_IS_PRINT_UNIX_DIALOG_CLASS
GTK_PRINT_UNIX_DIALOG_GET_CLASS
GTK_TYPE_PRINT_CAPABILITIES
GtkPrintUnixDialogPrivate
gtk_print_unix_dialog_get_type
gtk_print_capabilities_get_type
gtkprinter
GtkPrinter
GtkPrinter
GtkPrintBackend
gtk_printer_new
gtk_printer_get_backend
gtk_printer_get_name
gtk_printer_get_state_message
gtk_printer_get_description
gtk_printer_get_location
gtk_printer_get_icon_name
gtk_printer_get_job_count
gtk_printer_is_active
gtk_printer_is_paused
gtk_printer_is_accepting_jobs
gtk_printer_is_virtual
gtk_printer_is_default
gtk_printer_accepts_ps
gtk_printer_accepts_pdf
gtk_printer_list_papers
gtk_printer_compare
gtk_printer_has_details
gtk_printer_request_details
gtk_printer_get_capabilities
gtk_printer_get_default_page_size
gtk_printer_get_hard_margins
gtk_printer_get_hard_margins_for_paper_size
GtkPrinterFunc
gtk_enumerate_printers
GTK_TYPE_PRINTER
GTK_PRINTER
GTK_PRINTER_CLASS
GTK_IS_PRINTER
GTK_IS_PRINTER_CLASS
GTK_PRINTER_GET_CLASS
GtkPrinterPrivate
gtk_printer_get_type
gtkprintsettings
GtkPrintSettings
GtkPrintSettings
GtkPrintSettingsFunc
gtk_print_settings_new
gtk_print_settings_copy
gtk_print_settings_has_key
gtk_print_settings_get
gtk_print_settings_set
gtk_print_settings_unset
gtk_print_settings_foreach
gtk_print_settings_get_bool
gtk_print_settings_set_bool
gtk_print_settings_get_double
gtk_print_settings_get_double_with_default
gtk_print_settings_set_double
gtk_print_settings_get_length
gtk_print_settings_set_length
gtk_print_settings_get_int
gtk_print_settings_get_int_with_default
gtk_print_settings_set_int
GTK_PRINT_SETTINGS_PRINTER
gtk_print_settings_get_printer
gtk_print_settings_set_printer
GtkPageOrientation
GTK_PRINT_SETTINGS_ORIENTATION
gtk_print_settings_get_orientation
gtk_print_settings_set_orientation
GTK_PRINT_SETTINGS_PAPER_FORMAT
gtk_print_settings_get_paper_size
gtk_print_settings_set_paper_size
GTK_PRINT_SETTINGS_PAPER_WIDTH
gtk_print_settings_get_paper_width
gtk_print_settings_set_paper_width
GTK_PRINT_SETTINGS_PAPER_HEIGHT
gtk_print_settings_get_paper_height
gtk_print_settings_set_paper_height
GTK_PRINT_SETTINGS_USE_COLOR
gtk_print_settings_get_use_color
gtk_print_settings_set_use_color
GTK_PRINT_SETTINGS_COLLATE
gtk_print_settings_get_collate
gtk_print_settings_set_collate
GTK_PRINT_SETTINGS_REVERSE
gtk_print_settings_get_reverse
gtk_print_settings_set_reverse
GtkPrintDuplex
GTK_PRINT_SETTINGS_DUPLEX
gtk_print_settings_get_duplex
gtk_print_settings_set_duplex
GtkPrintQuality
GTK_PRINT_SETTINGS_QUALITY
gtk_print_settings_get_quality
gtk_print_settings_set_quality
GTK_PRINT_SETTINGS_N_COPIES
gtk_print_settings_get_n_copies
gtk_print_settings_set_n_copies
GTK_PRINT_SETTINGS_NUMBER_UP
gtk_print_settings_get_number_up
gtk_print_settings_set_number_up
GtkNumberUpLayout
GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT
gtk_print_settings_get_number_up_layout
gtk_print_settings_set_number_up_layout
GTK_PRINT_SETTINGS_RESOLUTION
gtk_print_settings_get_resolution
gtk_print_settings_set_resolution
gtk_print_settings_set_resolution_xy
GTK_PRINT_SETTINGS_RESOLUTION_X
gtk_print_settings_get_resolution_x
GTK_PRINT_SETTINGS_RESOLUTION_Y
gtk_print_settings_get_resolution_y
GTK_PRINT_SETTINGS_PRINTER_LPI
gtk_print_settings_get_printer_lpi
gtk_print_settings_set_printer_lpi
GTK_PRINT_SETTINGS_SCALE
gtk_print_settings_get_scale
gtk_print_settings_set_scale
GtkPrintPages
GTK_PRINT_SETTINGS_PRINT_PAGES
gtk_print_settings_get_print_pages
gtk_print_settings_set_print_pages
GtkPageRange
GTK_PRINT_SETTINGS_PAGE_RANGES
gtk_print_settings_get_page_ranges
gtk_print_settings_set_page_ranges
GtkPageSet
GTK_PRINT_SETTINGS_PAGE_SET
gtk_print_settings_get_page_set
gtk_print_settings_set_page_set
GTK_PRINT_SETTINGS_DEFAULT_SOURCE
gtk_print_settings_get_default_source
gtk_print_settings_set_default_source
GTK_PRINT_SETTINGS_MEDIA_TYPE
gtk_print_settings_get_media_type
gtk_print_settings_set_media_type
GTK_PRINT_SETTINGS_DITHER
gtk_print_settings_get_dither
gtk_print_settings_set_dither
GTK_PRINT_SETTINGS_FINISHINGS
gtk_print_settings_get_finishings
gtk_print_settings_set_finishings
GTK_PRINT_SETTINGS_OUTPUT_BIN
gtk_print_settings_get_output_bin
gtk_print_settings_set_output_bin
GTK_PRINT_SETTINGS_OUTPUT_DIR
GTK_PRINT_SETTINGS_OUTPUT_BASENAME
GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT
GTK_PRINT_SETTINGS_OUTPUT_URI
GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA
GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION
gtk_print_settings_new_from_file
gtk_print_settings_new_from_key_file
gtk_print_settings_new_from_gvariant
gtk_print_settings_load_file
gtk_print_settings_load_key_file
gtk_print_settings_to_file
gtk_print_settings_to_key_file
gtk_print_settings_to_gvariant
GTK_TYPE_PRINT_SETTINGS
GTK_PRINT_SETTINGS
GTK_IS_PRINT_SETTINGS
gtk_print_settings_get_type
gtkpapersize
GtkPaperSize
GtkPaperSize
GtkUnit
GTK_UNIT_PIXEL
GTK_PAPER_NAME_A3
GTK_PAPER_NAME_A4
GTK_PAPER_NAME_A5
GTK_PAPER_NAME_B5
GTK_PAPER_NAME_LETTER
GTK_PAPER_NAME_EXECUTIVE
GTK_PAPER_NAME_LEGAL
gtk_paper_size_new
gtk_paper_size_new_from_ppd
gtk_paper_size_new_from_ipp
gtk_paper_size_new_custom
gtk_paper_size_copy
gtk_paper_size_free
gtk_paper_size_is_equal
gtk_paper_size_get_paper_sizes
gtk_paper_size_get_name
gtk_paper_size_get_display_name
gtk_paper_size_get_ppd_name
gtk_paper_size_get_width
gtk_paper_size_get_height
gtk_paper_size_is_ipp
gtk_paper_size_is_custom
gtk_paper_size_set_size
gtk_paper_size_get_default_top_margin
gtk_paper_size_get_default_bottom_margin
gtk_paper_size_get_default_left_margin
gtk_paper_size_get_default_right_margin
gtk_paper_size_get_default
gtk_paper_size_new_from_key_file
gtk_paper_size_new_from_gvariant
gtk_paper_size_to_key_file
gtk_paper_size_to_gvariant
GTK_TYPE_PAPER_SIZE
GTK_CUSTOM_PAPER_UNIX_DIALOG
GTK_CUSTOM_PAPER_UNIX_DIALOG_CLASS
GTK_CUSTOM_PAPER_UNIX_DIALOG_GET_CLASS
GTK_IS_CUSTOM_PAPER_UNIX_DIALOG
GTK_IS_CUSTOM_PAPER_UNIX_DIALOG_CLASS
GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG
GtkCustomPaperUnixDialog
GtkCustomPaperUnixDialogClass
gtk_paper_size_get_type
gtk_custom_paper_unix_dialog_get_type
GtkCustomPaperUnixDialogPrivate
gtkpagesetup
GtkPageSetup
GtkPageSetup
gtk_page_setup_new
gtk_page_setup_copy
gtk_page_setup_get_orientation
gtk_page_setup_set_orientation
gtk_page_setup_get_paper_size
gtk_page_setup_set_paper_size
gtk_page_setup_get_top_margin
gtk_page_setup_set_top_margin
gtk_page_setup_get_bottom_margin
gtk_page_setup_set_bottom_margin
gtk_page_setup_get_left_margin
gtk_page_setup_set_left_margin
gtk_page_setup_get_right_margin
gtk_page_setup_set_right_margin
gtk_page_setup_set_paper_size_and_default_margins
gtk_page_setup_get_paper_width
gtk_page_setup_get_paper_height
gtk_page_setup_get_page_width
gtk_page_setup_get_page_height
gtk_page_setup_new_from_file
gtk_page_setup_new_from_key_file
gtk_page_setup_new_from_gvariant
gtk_page_setup_load_file
gtk_page_setup_load_key_file
gtk_page_setup_to_file
gtk_page_setup_to_key_file
gtk_page_setup_to_gvariant
GTK_TYPE_PAGE_SETUP
GTK_PAGE_SETUP
GTK_IS_PAGE_SETUP
gtk_page_setup_get_type
gtkprintcontext
GtkPrintContext
GtkPrintContext
gtk_print_context_get_cairo_context
gtk_print_context_set_cairo_context
gtk_print_context_get_page_setup
gtk_print_context_get_width
gtk_print_context_get_height
gtk_print_context_get_dpi_x
gtk_print_context_get_dpi_y
gtk_print_context_get_pango_fontmap
gtk_print_context_create_pango_context
gtk_print_context_create_pango_layout
gtk_print_context_get_hard_margins
GTK_TYPE_PRINT_CONTEXT
GTK_PRINT_CONTEXT
GTK_IS_PRINT_CONTEXT
gtk_print_context_get_type
gtkprintjob
GtkPrintJob
GtkPrintJob
GtkPrintJobCompleteFunc
gtk_print_job_new
gtk_print_job_get_settings
gtk_print_job_get_printer
gtk_print_job_get_title
gtk_print_job_get_status
gtk_print_job_set_source_file
gtk_print_job_set_source_fd
gtk_print_job_get_surface
gtk_print_job_send
gtk_print_job_set_track_print_status
gtk_print_job_get_track_print_status
gtk_print_job_get_pages
gtk_print_job_set_pages
gtk_print_job_get_page_ranges
gtk_print_job_set_page_ranges
gtk_print_job_get_page_set
gtk_print_job_set_page_set
gtk_print_job_get_num_copies
gtk_print_job_set_num_copies
gtk_print_job_get_scale
gtk_print_job_set_scale
gtk_print_job_get_n_up
gtk_print_job_set_n_up
gtk_print_job_get_n_up_layout
gtk_print_job_set_n_up_layout
gtk_print_job_get_rotate
gtk_print_job_set_rotate
gtk_print_job_get_collate
gtk_print_job_set_collate
gtk_print_job_get_reverse
gtk_print_job_set_reverse
GTK_TYPE_PRINT_JOB
GTK_PRINT_JOB
GTK_PRINT_JOB_CLASS
GTK_IS_PRINT_JOB
GTK_IS_PRINT_JOB_CLASS
GTK_PRINT_JOB_GET_CLASS
GtkPrintJobPrivate
gtk_print_job_get_type
gtkpagesetupunixdialog
GtkPageSetupUnixDialog
GtkPageSetupUnixDialog
gtk_page_setup_unix_dialog_new
gtk_page_setup_unix_dialog_set_page_setup
gtk_page_setup_unix_dialog_get_page_setup
gtk_page_setup_unix_dialog_set_print_settings
gtk_page_setup_unix_dialog_get_print_settings
GTK_TYPE_PAGE_SETUP_UNIX_DIALOG
GTK_PAGE_SETUP_UNIX_DIALOG
GTK_PAGE_SETUP_UNIX_DIALOG_CLASS
GTK_IS_PAGE_SETUP_UNIX_DIALOG
GTK_IS_PAGE_SETUP_UNIX_DIALOG_CLASS
GTK_PAGE_SETUP_UNIX_DIALOG_GET_CLASS
GtkPageSetupUnixDialogPrivate
gtk_page_setup_unix_dialog_get_type
gtktesting
Testing
gtk_test_init
gtk_test_list_all_types
gtk_test_register_all_types
gtk_test_widget_wait_for_draw
filesystem
Filesystem utilities
GtkMountOperation
GtkMountOperationClass
gtk_mount_operation_new
gtk_mount_operation_is_showing
gtk_mount_operation_set_parent
gtk_mount_operation_get_parent
gtk_mount_operation_set_display
gtk_mount_operation_get_display
gtk_show_uri_on_window
GTK_IS_MOUNT_OPERATION
GTK_IS_MOUNT_OPERATION_CLASS
GTK_MOUNT_OPERATION
GTK_MOUNT_OPERATION_CLASS
GTK_MOUNT_OPERATION_GET_CLASS
GTK_TYPE_MOUNT_OPERATION
GtkMountOperationLookupContext
gtk_mount_operation_get_type
GtkMountOperationPrivate
gtkorientable
Orientable
GtkOrientable
gtk_orientable_get_orientation
gtk_orientable_set_orientation
GtkOrientableIface
GTK_IS_ORIENTABLE
GTK_IS_ORIENTABLE_CLASS
GTK_ORIENTABLE
GTK_ORIENTABLE_CLASS
GTK_ORIENTABLE_GET_IFACE
GTK_TYPE_ORIENTABLE
gtk_orientable_get_type
gtkapplication
GtkApplication
GtkApplication
GtkApplicationClass
gtk_application_new
gtk_application_add_window
gtk_application_remove_window
gtk_application_get_windows
gtk_application_get_window_by_id
gtk_application_get_active_window
GtkApplicationInhibitFlags
gtk_application_inhibit
gtk_application_uninhibit
gtk_application_prefers_app_menu
gtk_application_get_app_menu
gtk_application_set_app_menu
gtk_application_get_menubar
gtk_application_set_menubar
gtk_application_get_menu_by_id
gtk_application_list_action_descriptions
gtk_application_get_accels_for_action
gtk_application_set_accels_for_action
gtk_application_get_actions_for_accel
GTK_TYPE_APPLICATION
GTK_APPLICATION
GTK_APPLICATION_CLASS
GTK_IS_APPLICATION
GTK_IS_APPLICATION_CLASS
GTK_APPLICATION_GET_CLASS
gtk_application_get_type
GtkApplicationPrivate
gtkapplicationwindow
GtkApplicationWindow
GtkApplicationWindow
GtkApplicationWindowClass
gtk_application_window_new
gtk_application_window_set_show_menubar
gtk_application_window_get_show_menubar
gtk_application_window_get_id
gtk_application_window_set_help_overlay
gtk_application_window_get_help_overlay
GTK_TYPE_APPLICATION_WINDOW
GTK_APPLICATION_WINDOW
GTK_APPLICATION_WINDOW_CLASS
GTK_IS_APPLICATION_WINDOW
GTK_IS_APPLICATION_WINDOW_CLASS
GTK_APPLICATION_WINDOW_GET_CLASS
gtk_application_window_get_type
GtkApplicationWindowPrivate
gtkactionable
GtkActionable
GtkActionable
GtkActionableInterface
gtk_actionable_get_action_name
gtk_actionable_set_action_name
gtk_actionable_get_action_target_value
gtk_actionable_set_action_target_value
gtk_actionable_set_action_target
gtk_actionable_set_detailed_action_name
gtk_actionable_get_type
GTK_ACTIONABLE
GTK_ACTIONABLE_GET_IFACE
GTK_IS_ACTIONABLE
GTK_TYPE_ACTIONABLE
gtkgrid
GtkGrid
GtkGrid
GtkGridClass
gtk_grid_new
gtk_grid_attach
gtk_grid_attach_next_to
gtk_grid_get_child_at
gtk_grid_insert_row
gtk_grid_insert_column
gtk_grid_remove_row
gtk_grid_remove_column
gtk_grid_insert_next_to
gtk_grid_set_row_homogeneous
gtk_grid_get_row_homogeneous
gtk_grid_set_row_spacing
gtk_grid_get_row_spacing
gtk_grid_set_column_homogeneous
gtk_grid_get_column_homogeneous
gtk_grid_set_column_spacing
gtk_grid_get_column_spacing
gtk_grid_get_baseline_row
gtk_grid_set_baseline_row
gtk_grid_get_row_baseline_position
gtk_grid_set_row_baseline_position
GTK_TYPE_GRID
GTK_GRID
GTK_GRID_CLASS
GTK_IS_GRID
GTK_IS_GRID_CLASS
GTK_GRID_GET_CLASS
GtkGridPrivate
gtk_grid_get_type
gtkswitch
GtkSwitch
gtk_switch_new
gtk_switch_set_active
gtk_switch_get_active
gtk_switch_set_state
gtk_switch_get_state
GTK_TYPE_SWITCH
GTK_SWITCH
GTK_SWITCH_CLASS
GTK_IS_SWITCH
GTK_IS_SWITCH_CLASS
GTK_SWITCH_GET_CLASS
GtkSwitchPrivate
gtk_switch_get_type
gtkappchooser
GtkAppChooser
GtkAppChooser
gtk_app_chooser_get_app_info
gtk_app_chooser_get_content_type
gtk_app_chooser_refresh
GTK_TYPE_APP_CHOOSER
GTK_APP_CHOOSER
GTK_IS_APP_CHOOSER
GTK_APP_CHOOSER_GET_IFACE
gtk_app_chooser_get_type
GTK_APP_CHOOSER_ONLINE
GTK_APP_CHOOSER_ONLINE_GET_IFACE
GTK_APP_CHOOSER_ONLINE_PK
GTK_APP_CHOOSER_ONLINE_PK_CLASS
GTK_APP_CHOOSER_ONLINE_PK_GET_CLASS
GTK_IS_APP_CHOOSER_ONLINE
GTK_IS_APP_CHOOSER_ONLINE_PK
GTK_IS_APP_CHOOSER_ONLINE_PK_CLASS
gtkappchooserbutton
GtkAppChooserButton
GtkAppChooserButton
gtk_app_chooser_button_new
gtk_app_chooser_button_append_custom_item
gtk_app_chooser_button_append_separator
gtk_app_chooser_button_set_active_custom_item
gtk_app_chooser_button_get_show_default_item
gtk_app_chooser_button_set_show_default_item
gtk_app_chooser_button_get_show_dialog_item
gtk_app_chooser_button_set_show_dialog_item
gtk_app_chooser_button_get_heading
gtk_app_chooser_button_set_heading
GTK_TYPE_APP_CHOOSER_BUTTON
GTK_APP_CHOOSER_BUTTON
GTK_APP_CHOOSER_BUTTON_CLASS
GTK_IS_APP_CHOOSER_BUTTON
GTK_IS_APP_CHOOSER_BUTTON_CLASS
GTK_APP_CHOOSER_BUTTON_GET_CLASS
GtkAppChooserButtonPrivate
gtk_app_chooser_button_get_type
gtkappchooserdialog
GtkAppChooserDialog
GtkAppChooserDialog
gtk_app_chooser_dialog_new
gtk_app_chooser_dialog_new_for_content_type
gtk_app_chooser_dialog_get_widget
gtk_app_chooser_dialog_set_heading
gtk_app_chooser_dialog_get_heading
GTK_TYPE_APP_CHOOSER_DIALOG
GTK_APP_CHOOSER_DIALOG
GTK_APP_CHOOSER_DIALOG_CLASS
GTK_IS_APP_CHOOSER_DIALOG
GTK_IS_APP_CHOOSER_DIALOG_CLASS
GTK_APP_CHOOSER_DIALOG_GET_CLASS
GtkAppChooserDialogPrivate
gtk_app_chooser_dialog_get_type
gtkappchooserwidget
GtkAppChooserWidget
GtkAppChooserWidget
gtk_app_chooser_widget_new
gtk_app_chooser_widget_set_show_default
gtk_app_chooser_widget_get_show_default
gtk_app_chooser_widget_set_show_recommended
gtk_app_chooser_widget_get_show_recommended
gtk_app_chooser_widget_set_show_fallback
gtk_app_chooser_widget_get_show_fallback
gtk_app_chooser_widget_set_show_other
gtk_app_chooser_widget_get_show_other
gtk_app_chooser_widget_set_show_all
gtk_app_chooser_widget_get_show_all
gtk_app_chooser_widget_set_default_text
gtk_app_chooser_widget_get_default_text
GTK_TYPE_APP_CHOOSER_WIDGET
GTK_APP_CHOOSER_WIDGET
GTK_APP_CHOOSER_WIDGET_CLASS
GTK_IS_APP_CHOOSER_WIDGET
GTK_IS_APP_CHOOSER_WIDGET_CLASS
GTK_APP_CHOOSER_WIDGET_GET_CLASS
GtkAppChooserWidgetPrivate
gtk_app_chooser_widget_get_type
gtklockbutton
GtkLockButton
GtkLockButton
gtk_lock_button_new
gtk_lock_button_get_permission
gtk_lock_button_set_permission
GTK_TYPE_LOCK_BUTTON
GTK_LOCK_BUTTON
GTK_IS_LOCK_BUTTON
GTK_LOCK_BUTTON_CLASS
GTK_IS_LOCK_BUTTON_CLASS
GTK_LOCK_BUTTON_GET_CLASS
gtk_lock_button_get_type
GtkLockButtonPrivate
gtkoverlay
GtkOverlay
GtkOverlay
gtk_overlay_new
gtk_overlay_add_overlay
gtk_overlay_get_measure_overlay
gtk_overlay_set_measure_overlay
gtk_overlay_get_clip_overlay
gtk_overlay_set_clip_overlay
GTK_TYPE_OVERLAY
GTK_OVERLAY
GTK_OVERLAY_CLASS
GTK_IS_OVERLAY
GTK_IS_OVERLAY_CLASS
GTK_OVERLAY_GET_CLASS
gtk_overlay_get_type
GtkOverlayPrivate
gtkcolorchooser
GtkColorChooser
GtkColorChooser
gtk_color_chooser_get_rgba
gtk_color_chooser_set_rgba
gtk_color_chooser_get_use_alpha
gtk_color_chooser_set_use_alpha
gtk_color_chooser_add_palette
gtk_hsv_to_rgb
gtk_rgb_to_hsv
GTK_TYPE_COLOR_CHOOSER
GTK_COLOR_CHOOSER
GTK_IS_COLOR_CHOOSER
GTK_COLOR_CHOOSER_GET_IFACE
gtk_color_chooser_get_type
gtkcolorchooserwidget
GtkColorChooserWidget
GtkColorChooserWidget
gtk_color_chooser_widget_new
GTK_TYPE_COLOR_CHOOSER_WIDGET
GTK_COLOR_CHOOSER_WIDGET
GTK_COLOR_CHOOSER_WIDGET_CLASS
GTK_IS_COLOR_CHOOSER_WIDGET
GTK_IS_COLOR_CHOOSER_WIDGET_CLASS
GTK_COLOR_CHOOSER_WIDGET_GET_CLASS
gtk_color_chooser_widget_get_type
GtkColorChooserWidgetPrivate
gtkcolorchooserdialog
GtkColorChooserDialog
GtkColorChooserDialog
gtk_color_chooser_dialog_new
GTK_TYPE_COLOR_CHOOSER_DIALOG
GTK_COLOR_CHOOSER_DIALOG
GTK_COLOR_CHOOSER_DIALOG_CLASS
GTK_IS_COLOR_CHOOSER_DIALOG
GTK_IS_COLOR_CHOOSER_DIALOG_CLASS
GTK_COLOR_CHOOSER_DIALOG_GET_CLASS
GtkColorChooserDialogPrivate
gtk_color_chooser_dialog_get_type
gtkactionbar
GtkActionBar
GtkActionBar
gtk_action_bar_new
gtk_action_bar_pack_start
gtk_action_bar_pack_end
gtk_action_bar_get_center_widget
gtk_action_bar_set_center_widget
gtk_action_bar_get_revealed
gtk_action_bar_set_revealed
GTK_TYPE_ACTION_BAR
GTK_ACTION_BAR
GTK_ACTION_BAR_CLASS
GTK_IS_ACTION_BAR
GTK_IS_ACTION_BAR_CLASS
GTK_ACTION_BAR_GET_CLASS
GtkActionBarPrivate
gtk_action_bar_get_type
gtkheaderbar
GtkHeaderBar
GtkHeaderBar
gtk_header_bar_new
gtk_header_bar_set_title
gtk_header_bar_get_title
gtk_header_bar_set_subtitle
gtk_header_bar_get_subtitle
gtk_header_bar_set_has_subtitle
gtk_header_bar_get_has_subtitle
gtk_header_bar_set_custom_title
gtk_header_bar_get_custom_title
gtk_header_bar_pack_start
gtk_header_bar_pack_end
gtk_header_bar_set_show_title_buttons
gtk_header_bar_get_show_title_buttons
gtk_header_bar_set_decoration_layout
gtk_header_bar_get_decoration_layout
GTK_TYPE_HEADER_BAR
GTK_HEADER_BAR
GTK_HEADER_BAR_CLASS
GTK_IS_HEADER_BAR
GTK_IS_HEADER_BAR_CLASS
GTK_HEADER_BAR_GET_CLASS
GtkHeaderBarPrivate
gtk_header_bar_get_type
gtkstack
GtkStack
GtkStackPage
gtk_stack_page_get_visible
gtk_stack_page_set_visible
gtk_stack_page_get_child
GtkStack
gtk_stack_new
gtk_stack_add_named
gtk_stack_add_titled
gtk_stack_get_child_by_name
gtk_stack_get_page
gtk_stack_get_pages
gtk_stack_set_visible_child
gtk_stack_get_visible_child
gtk_stack_set_visible_child_name
gtk_stack_get_visible_child_name
gtk_stack_set_visible_child_full
gtk_stack_set_homogeneous
gtk_stack_get_homogeneous
gtk_stack_set_hhomogeneous
gtk_stack_get_hhomogeneous
gtk_stack_set_vhomogeneous
gtk_stack_get_vhomogeneous
gtk_stack_set_transition_duration
gtk_stack_get_transition_duration
GtkStackTransitionType
gtk_stack_set_transition_type
gtk_stack_get_transition_type
gtk_stack_get_transition_running
gtk_stack_get_interpolate_size
gtk_stack_set_interpolate_size
GTK_TYPE_STACK
GTK_IS_STACK
GTK_IS_STACK_CLASS
GTK_STACK
GTK_STACK_CLASS
GTK_STACK_GET_CLASS
gtk_stack_get_type
gtk_stack_page_get_type
gtkstackswitcher
GtkStackSwitcher
GtkStackSwitcher
gtk_stack_switcher_new
gtk_stack_switcher_set_stack
gtk_stack_switcher_get_stack
GTK_TYPE_STACK_SWITCHER
GTK_IS_STACK_SWITCHER
GTK_IS_STACK_SWITCHER_CLASS
GTK_STACK_SWITCHER
GTK_STACK_SWITCHER_CLASS
GTK_STACK_SWITCHER_GET_CLASS
gtk_stack_switcher_get_type
gtkrevealer
GtkRevealer
GtkRevealer
gtk_revealer_new
gtk_revealer_get_reveal_child
gtk_revealer_set_reveal_child
gtk_revealer_get_child_revealed
gtk_revealer_get_transition_duration
gtk_revealer_set_transition_duration
GtkRevealerTransitionType
gtk_revealer_get_transition_type
gtk_revealer_set_transition_type
GTK_TYPE_REVEALER
GTK_IS_REVEALER
GTK_IS_REVEALER_CLASS
GTK_REVEALER
GTK_REVEALER_CLASS
GTK_REVEALER_GET_CLASS
gtk_revealer_get_type
gtkflowbox
GtkFlowBox
GtkFlowBox
gtk_flow_box_new
gtk_flow_box_insert
gtk_flow_box_get_child_at_index
gtk_flow_box_get_child_at_pos
gtk_flow_box_set_hadjustment
gtk_flow_box_set_vadjustment
gtk_flow_box_set_homogeneous
gtk_flow_box_get_homogeneous
gtk_flow_box_set_row_spacing
gtk_flow_box_get_row_spacing
gtk_flow_box_set_column_spacing
gtk_flow_box_get_column_spacing
gtk_flow_box_set_min_children_per_line
gtk_flow_box_get_min_children_per_line
gtk_flow_box_set_max_children_per_line
gtk_flow_box_get_max_children_per_line
gtk_flow_box_set_activate_on_single_click
gtk_flow_box_get_activate_on_single_click
GtkFlowBoxForeachFunc
gtk_flow_box_selected_foreach
gtk_flow_box_get_selected_children
gtk_flow_box_select_child
gtk_flow_box_unselect_child
gtk_flow_box_select_all
gtk_flow_box_unselect_all
gtk_flow_box_set_selection_mode
gtk_flow_box_get_selection_mode
GtkFlowBoxFilterFunc
gtk_flow_box_set_filter_func
gtk_flow_box_invalidate_filter
GtkFlowBoxSortFunc
gtk_flow_box_set_sort_func
gtk_flow_box_invalidate_sort
GtkFlowBoxCreateWidgetFunc
gtk_flow_box_bind_model
GtkFlowBoxChild
gtk_flow_box_child_new
gtk_flow_box_child_get_index
gtk_flow_box_child_is_selected
gtk_flow_box_child_changed
GtkFlowBoxChildClass
GTK_TYPE_FLOW_BOX
GTK_TYPE_FLOW_BOX_CHILD
GTK_FLOW_BOX
GTK_FLOW_BOX_CLASS
GTK_FLOW_BOX_GET_CLASS
GTK_IS_FLOW_BOX
GTK_IS_FLOW_BOX_CLASS
GTK_FLOW_BOX_CHILD
GTK_FLOW_BOX_CHILD_CLASS
GTK_FLOW_BOX_CHILD_GET_CLASS
GTK_IS_FLOW_BOX_CHILD
GTK_IS_FLOW_BOX_CHILD_CLASS
gtk_flow_box_get_type
gtk_flow_box_child_get_type
gtkpopover
GtkPopover
GtkPopover
gtk_popover_new
gtk_popover_popup
gtk_popover_popdown
gtk_popover_set_pointing_to
gtk_popover_get_pointing_to
gtk_popover_set_position
gtk_popover_get_position
gtk_popover_set_autohide
gtk_popover_get_autohide
gtk_popover_set_has_arrow
gtk_popover_get_has_arrow
gtk_popover_set_default_widget
GTK_TYPE_POPOVER
GTK_IS_POPOVER
GTK_IS_POPOVER_CLASS
GTK_IS_POPOVER_MENU
GTK_IS_POPOVER_MENU_CLASS
GTK_POPOVER
GTK_POPOVER_CLASS
GTK_POPOVER_GET_CLASS
GtkPopoverPrivate
gtk_popover_get_type
gtkpopovermenu
GtkPopoverMenu
GtkPopoverMenu
gtk_popover_menu_new_from_model
gtk_popover_menu_set_menu_model
gtk_popover_menu_get_menu_model
GTK_TYPE_POPOVER_MENU
GTK_IS_POPOVER_MENU
GTK_POPOVER_MENU
gtk_popover_menu_get_type
gtkpopovermenubar
GtkPopoverMenuBar
GtkPopoverMenuBar
gtk_popover_menu_bar_new_from_model
gtk_popover_menu_bar_set_menu_model
gtk_popover_menu_bar_get_menu_model
GTK_TYPE_POPOVER_MENU_BAR
GTK_IS_POPOVER_MENU_BAR
GTK_POPOVER_MENU_BAR
gtk_popover_menu_bar_get_type
gtkeventcontroller
GtkEventController
GtkEventController
GtkPropagationPhase
gtk_event_controller_get_propagation_phase
gtk_event_controller_set_propagation_phase
GtkPropagationLimit
gtk_event_controller_get_propagation_limit
gtk_event_controller_set_propagation_limit
gtk_event_controller_get_widget
gtk_event_controller_reset
GTK_TYPE_EVENT_CONTROLLER
GTK_EVENT_CONTROLLER
GTK_EVENT_CONTROLLER_CLASS
GTK_IS_EVENT_CONTROLLER
GTK_EVENT_CONTROLLER_GET_CLASS
GTK_IS_EVENT_CONTROLLER_CLASS
GtkEventControllerPriv
gtk_event_controller_get_type
gtkgesture
GtkGesture
GtkGesture
gtk_gesture_get_device
gtk_gesture_is_active
gtk_gesture_is_recognized
GtkEventSequenceState
gtk_gesture_get_sequence_state
gtk_gesture_set_sequence_state
gtk_gesture_set_state
gtk_gesture_get_sequences
gtk_gesture_handles_sequence
gtk_gesture_get_last_updated_sequence
gtk_gesture_get_last_event
gtk_gesture_get_point
gtk_gesture_get_bounding_box
gtk_gesture_get_bounding_box_center
gtk_gesture_group
gtk_gesture_ungroup
gtk_gesture_get_group
gtk_gesture_is_grouped_with
GTK_TYPE_GESTURE
GTK_GESTURE
GTK_GESTURE_CLASS
GTK_IS_GESTURE
GTK_IS_GESTURE_CLASS
GTK_GESTURE_GET_CLASS
gtk_gesture_get_type
gtkgesturesingle
GtkGestureSingle
GtkGestureSingle
gtk_gesture_single_get_exclusive
gtk_gesture_single_set_exclusive
gtk_gesture_single_get_touch_only
gtk_gesture_single_set_touch_only
gtk_gesture_single_get_button
gtk_gesture_single_set_button
gtk_gesture_single_get_current_button
gtk_gesture_single_get_current_sequence
GTK_TYPE_GESTURE_SINGLE
GTK_GESTURE_SINGLE
GTK_GESTURE_SINGLE_CLASS
GTK_IS_GESTURE_SINGLE
GTK_IS_GESTURE_SINGLE_CLASS
GTK_GESTURE_SINGLE_GET_CLASS
gtk_gesture_single_get_type
gtkeventcontrollerlegacy
GtkEventControllerLegacy
GtkEventControllerLegacy
gtk_event_controller_legacy_new
GTK_TYPE_EVENT_CONTROLLER_LEGACY
GTK_EVENT_CONTROLLER_LEGACY
GTK_EVENT_CONTROLLER_LEGACY_CLASS
GTK_IS_EVENT_CONTROLLER_LEGACY
GTK_IS_EVENT_CONTROLLER_LEGACY_CLASS
GTK_EVENT_CONTROLLER_LEGACY_GET_CLASS
gtk_event_controller_legacy_get_type
gtkeventcontrollerscroll
GtkEventControllerScroll
GtkEventControllerScroll
GtkEventControllerScrollFlags
gtk_event_controller_scroll_new
gtk_event_controller_scroll_set_flags
gtk_event_controller_scroll_get_flags
GTK_TYPE_EVENT_CONTROLLER_SCROLL
GTK_EVENT_CONTROLLER_SCROLL
GTK_EVENT_CONTROLLER_SCROLL_CLASS
GTK_IS_EVENT_CONTROLLER_SCROLL
GTK_IS_EVENT_CONTROLLER_SCROLL_CLASS
GTK_EVENT_CONTROLLER_SCROLL_GET_CLASS
gtk_event_controller_scroll_get_type
gtkeventcontrollermotion
GtkEventControllerMotion
GtkEventControllerMotion
gtk_event_controller_motion_new
gtk_event_controller_motion_contains_pointer
gtk_event_controller_motion_is_pointer
GTK_TYPE_EVENT_CONTROLLER_MOTION
GTK_EVENT_CONTROLLER_MOTION
GTK_EVENT_CONTROLLER_MOTION_CLASS
GTK_IS_EVENT_CONTROLLER_MOTION
GTK_IS_EVENT_CONTROLLER_MOTION_CLASS
GTK_EVENT_CONTROLLER_MOTION_GET_CLASS
gtk_event_controller_motion_get_type
gtkshortcuttrigger
GtkShortcutTrigger
GtkShortcutTrigger
gtk_shortcut_trigger_ref
gtk_shortcut_trigger_unref
GtkShortcutTriggerType
gtk_shortcut_trigger_get_trigger_type
gtk_shortcut_trigger_parse_string
gtk_shortcut_trigger_trigger
gtk_shortcut_trigger_hash
gtk_shortcut_trigger_equal
gtk_shortcut_trigger_compare
gtk_shortcut_trigger_to_string
gtk_shortcut_trigger_print
gtk_shortcut_trigger_to_label
gtk_shortcut_trigger_print_label
gtk_keyval_trigger_new
gtk_keyval_trigger_get_modifiers
gtk_keyval_trigger_get_keyval
gtk_mnemonic_trigger_new
gtk_mnemonic_trigger_get_keyval
gtk_shortcut_trigger_get_type
gtkshortcutaction
GtkShortcutAction
GtkShortcutAction
gtk_shortcut_action_ref
gtk_shortcut_action_unref
GtkShortcutActionType
gtk_shortcut_action_get_action_type
gtk_shortcut_action_to_string
gtk_shortcut_action_print
gtk_shortcut_action_activate
gtk_nothing_action_new
gtk_callback_action_new
gtk_mnemonic_action_new
gtk_activate_action_new
gtk_signal_action_new
gtk_signal_action_get_signal_name
gtk_named_action_new
gtk_named_action_get_name
gtk_shortcut_action_get_type
gtkshortcut
GtkShortcut
GtkShortcut
gtk_shortcut_new
gtk_shortcut_new_with_arguments
gtk_shortcut_get_trigger
gtk_shortcut_set_trigger
gtk_shortcut_get_action
gtk_shortcut_set_action
gtk_shortcut_get_arguments
gtk_shortcut_set_arguments
GTK_TYPE_SHORTCUT
GTK_SHORTCUT
GTK_SHORTCUT_CLASS
GTK_IS_SHORTCUT
GTK_IS_SHORTCUT_CLASS
GTK_SHORTCUT_GET_CLASS
gtk_shortcut_get_type
gtkshortcutmanager
GtkShortcutManager
GtkShortcutManager
GtkShortcutManagerInterface
gtkshortcutcontroller
GtkShortcutController
GtkShortcutController
gtk_shortcut_controller_new
gtk_shortcut_controller_new_with_model
GtkShortcutScope
GtkShortcutManager
GtkShortcutManagerInterface
gtk_shortcut_controller_set_mnemonics_modifiers
gtk_shortcut_controller_get_mnemonics_modifiers
gtk_shortcut_controller_set_scope
gtk_shortcut_controller_get_scope
gtk_shortcut_controller_add_shortcut
gtk_shortcut_controller_remove_shortcut
GTK_TYPE_SHORTCUT_CONTROLLER
GTK_SHORTCUT_CONTROLLER
GTK_SHORTCUT_CONTROLLER_CLASS
GTK_IS_SHORTCUT_CONTROLLER
GTK_IS_SHORTCUT_CONTROLLER_CLASS
GTK_SHORTCUT_CONTROLLER_GET_CLASS
GTK_TYPE_SHORTCUT_MANAGER
GTK_SHORTCUT_MANAGER
GTK_SHORTCUT_MANAGER_CLASS
GTK_IS_SHORTCUT_MANAGER
GTK_IS_SHORTCUT_MANAGER_CLASS
GTK_SHORTCUT_MANAGER_GET_CLASS
gtk_shortcut_controller_get_type
gtk_shortcut_manager_get_type
gtkeventcontrollerkey
GtkEventControllerKey
GtkEventControllerKey
gtk_event_controller_key_new
gtk_event_controller_key_set_im_context
gtk_event_controller_key_get_im_context
gtk_event_controller_key_forward
gtk_event_controller_key_get_group
GTK_TYPE_EVENT_CONTROLLER_KEY
GTK_EVENT_CONTROLLER_KEY
GTK_EVENT_CONTROLLER_KEY_CLASS
GTK_IS_EVENT_CONTROLLER_KEY
GTK_IS_EVENT_CONTROLLER_KEY_CLASS
GTK_EVENT_CONTROLLER_KEY_GET_CLASS
gtk_event_controller_key_get_type
gtkeventcontrollerfocus
GtkEventControllerFocus
GtkEventControllerFocus
gtk_event_controller_focus_new
gtk_event_controller_focus_contains_focus
gtk_event_controller_focus_is_focus
GTK_TYPE_EVENT_CONTROLLER_FOCUS
GTK_EVENT_CONTROLLER_FOCUS
GTK_EVENT_CONTROLLER_FOCUS_CLASS
GTK_IS_EVENT_CONTROLL_FOCUS
GTK_IS_EVENT_CONTROLLER_FOCUS_CLASS
GTK_EVENT_CONTROLLER_FOCUS_GET_CLASS
gtk_event_controller_focus_get_type
gtkgesturedrag
GtkGestureDrag
GtkGestureDrag
gtk_gesture_drag_new
gtk_gesture_drag_get_start_point
gtk_gesture_drag_get_offset
GTK_TYPE_GESTURE_DRAG
GTK_GESTURE_DRAG
GTK_GESTURE_DRAG_CLASS
GTK_IS_GESTURE_DRAG
GTK_IS_GESTURE_DRAG_CLASS
GTK_GESTURE_DRAG_GET_CLASS
gtk_gesture_drag_get_type
gtkgesturelongpress
GtkGestureLongPress
GtkGestureLongPress
gtk_gesture_long_press_new
gtk_gesture_long_press_set_delay_factor
gtk_gesture_long_press_get_delay_factor
GTK_TYPE_GESTURE_LONG_PRESS
GTK_GESTURE_LONG_PRESS
GTK_GESTURE_LONG_PRESS_CLASS
GTK_IS_GESTURE_LONG_PRESS
GTK_IS_GESTURE_LONG_PRESS_CLASS
GTK_GESTURE_LONG_PRESS_GET_CLASS
gtk_gesture_long_press_get_type
gtkgestureclick
GtkGestureClick
GtkGestureClick
gtk_gesture_click_new
gtk_gesture_click_set_area
gtk_gesture_click_get_area
GTK_TYPE_GESTURE_CLICK
GTK_GESTURE_CLICK
GTK_GESTURE_CLICK_CLASS
GTK_IS_GESTURE_CLICK
GTK_IS_GESTURE_CLICK_CLASS
GTK_GESTURE_CLICK_GET_CLASS
gtk_gesture_click_get_type
gtkgesturepan
GtkGesturePan
GtkGesturePan
GtkPanDirection
gtk_gesture_pan_new
gtk_gesture_pan_get_orientation
gtk_gesture_pan_set_orientation
GTK_TYPE_GESTURE_PAN
GTK_GESTURE_PAN
GTK_GESTURE_PAN_CLASS
GTK_IS_GESTURE_PAN
GTK_IS_GESTURE_PAN_CLASS
GTK_GESTURE_PAN_GET_CLASS
gtk_gesture_pan_get_type
gtkgestureswipe
GtkGestureSwipe
GtkGestureSwipe
gtk_gesture_swipe_new
gtk_gesture_swipe_get_velocity
GTK_TYPE_GESTURE_SWIPE
GTK_GESTURE_SWIPE
GTK_GESTURE_SWIPE_CLASS
GTK_IS_GESTURE_SWIPE
GTK_IS_GESTURE_SWIPE_CLASS
GTK_GESTURE_SWIPE_GET_CLASS
gtk_gesture_swipe_get_type
gtkgesturerotate
GtkGestureRotate
GtkGestureRotate
gtk_gesture_rotate_new
gtk_gesture_rotate_get_angle_delta
GTK_TYPE_GESTURE_ROTATE
GTK_GESTURE_ROTATE
GTK_GESTURE_ROTATE_CLASS
GTK_IS_GESTURE_ROTATE
GTK_IS_GESTURE_ROTATE_CLASS
GTK_GESTURE_ROTATE_GET_CLASS
gtk_gesture_rotate_get_type
gtkgesturezoom
GtkGestureZoom
GtkGestureZoom
gtk_gesture_zoom_new
gtk_gesture_zoom_get_scale_delta
GTK_TYPE_GESTURE_ZOOM
GTK_GESTURE_ZOOM
GTK_GESTURE_ZOOM_CLASS
GTK_IS_GESTURE_ZOOM
GTK_IS_GESTURE_ZOOM_CLASS
GTK_GESTURE_ZOOM_GET_CLASS
gtk_gesture_zoom_get_type
gtkpadcontroller
GtkPadController
GtkPadController
gtk_pad_controller_new
gtk_pad_controller_set_action_entries
gtk_pad_controller_set_action
GtkPadActionType
GtkPadActionEntry
GTK_TYPE_PAD_CONTROLLER
GTK_PAD_CONTROLLER
GTK_PAD_CONTROLLER_CLASS
GTK_IS_PAD_CONTROLLER
GTK_IS_PAD_CONTROLLER_CLASS
GTK_PAD_CONTROLLER_GET_CLASS
gtk_pad_controller_get_type
gtkgesturestylus
GtkGestureStylus
GtkGestureStylus
gtk_gesture_stylus_new
gtk_gesture_stylus_get_axis
gtk_gesture_stylus_get_axes
gtk_gesture_stylus_get_backlog
gtk_gesture_stylus_get_device_tool
GTK_TYPE_GESTURE_STYLUS
GTK_GESTURE_STYLUS
GTK_GESTURE_STYLUS_CLASS
GTK_IS_GESTURE_STYLUS
GTK_IS_GESTURE_STYLUS_CLASS
GTK_GESTURE_STYLUS_GET_CLASS
GtkGestureStylusClass
gtk_gesture_stylus_get_type
gtkstacksidebar
GtkStackSidebar
gtk_stack_sidebar_new
gtk_stack_sidebar_set_stack
gtk_stack_sidebar_get_stack
GtkStackSidebarClass
GTK_TYPE_STACK_SIDEBAR
GTK_STACK_SIDEBAR
GTK_STACK_SIDEBAR_CLASS
GTK_IS_STACK_SIDEBAR
GTK_IS_STACK_SIDEBAR_CLASS
GTK_STACK_SIDEBAR_GET_CLASS
GtkStackSidebarPrivate
gtk_stack_sidebar_get_type
gtkglarea
GtkGLArea
GtkGLAreaClass
gtk_gl_area_new
gtk_gl_area_get_context
gtk_gl_area_make_current
gtk_gl_area_queue_render
gtk_gl_area_attach_buffers
gtk_gl_area_set_error
gtk_gl_area_get_error
gtk_gl_area_set_has_depth_buffer
gtk_gl_area_get_has_depth_buffer
gtk_gl_area_set_has_stencil_buffer
gtk_gl_area_get_has_stencil_buffer
gtk_gl_area_set_auto_render
gtk_gl_area_get_auto_render
gtk_gl_area_get_required_version
gtk_gl_area_set_required_version
gtk_gl_area_set_use_es
gtk_gl_area_get_use_es
GTK_TYPE_GL_AREA
GTK_GL_AREA
GTK_GL_AREA_CLASS
GTK_GL_AREA_GET_CLASS
GTK_IS_GL_AREA
GTK_IS_GL_AREA_CLASS
gtk_gl_area_get_type
gtkshortcutswindow
GtkShortcutsWindow
GTK_TYPE_SHORTCUTS_WINDOW
GTK_SHORTCUTS_WINDOW
GTK_IS_SHORTCUTS_WINDOW
GTK_SHORTCUTS_WINDOW_CLASS
GTK_IS_SHORTCUTS_WINDOW_CLASS
GTK_GET_SHORTCUTS_WINDOW_CLASS
GtkShortcutsWindowClass
gtk_shortcuts_window_get_type
GTK_SHORTCUTS_WINDOW_GET_CLASS
gtkshortcutssection
GtkShortcutsSection
GTK_TYPE_SHORTCUTS_SECTION
GTK_SHORTCUTS_SECTION
GTK_IS_SHORTCUTS_SECTION
GTK_SHORTCUTS_SECTION_CLASS
GTK_IS_SHORTCUTS_SECTION_CLASS
GTK_GET_SHORTCUTS_SECTION_CLASS
GtkShortcutsSectionClass
gtk_shortcuts_section_get_type
GTK_SHORTCUTS_SECTION_GET_CLASS
gtkshortcutsgroup
GtkShortcutsGroup
GTK_TYPE_SHORTCUTS_GROUP
GTK_SHORTCUTS_GROUP
GTK_IS_SHORTCUTS_GROUP
GTK_SHORTCUTS_GROUP_CLASS
GTK_IS_SHORTCUTS_GROUP_CLASS
GTK_GET_SHORTCUTS_GROUP_CLASS
GtkShortcutsGroupClass
gtk_shortcuts_group_get_type
GTK_SHORTCUTS_GROUP_GET_CLASS
gtkshortcutsshortcut
GtkShortcutsShortcut
GtkShortcutType
GTK_TYPE_SHORTCUTS_SHORTCUT
GTK_SHORTCUTS_SHORTCUT
GTK_IS_SHORTCUTS_SHORTCUT
GTK_SHORTCUTS_SHORTCUT_CLASS
GTK_IS_SHORTCUTS_SHORTCUT_CLASS
GTK_GET_SHORTCUTS_SHORTCUT_CLASS
GtkShortcutsShortcutClass
gtk_shortcuts_shortcut_get_type
gtk_shortcuts_shortcut_update_accel
GTK_SHORTCUTS_SHORTCUT_GET_CLASS
gtkshortcutlabel
GtkShortcutLabel
gtk_shortcut_label_new
gtk_shortcut_label_get_accelerator
gtk_shortcut_label_get_disabled_text
gtk_shortcut_label_set_accelerator
gtk_shortcut_label_set_disabled_text
GtkShortcutLabelClass
gtk_shortcut_label_get_type
GTK_TYPE_SHORTCUT_LABEL
GTK_SHORTCUT_LABEL
GTK_SHORTCUT_LABEL_CLASS
GTK_SHORTCUT_LABEL_GET_CLASS
GTK_IS_SHORTCUT_LABEL
GTK_IS_SHORTCUT_LABEL_CLASS
gtkvideo
GtkVideo
gtk_video_new
gtk_video_new_for_media_stream
gtk_video_new_for_file
gtk_video_new_for_filename
gtk_video_new_for_resource
gtk_video_get_media_stream
gtk_video_set_media_stream
gtk_video_get_file
gtk_video_set_file
gtk_video_set_filename
gtk_video_set_resource
gtk_video_get_autoplay
gtk_video_set_autoplay
gtk_video_get_loop
gtk_video_set_loop
gtk_video_get_type
gtkmediacontrols
GtkMediaControls
gtk_media_controls_new
gtk_media_controls_get_media_stream
gtk_media_controls_set_media_stream
gtk_media_controls_get_type
gtkmediafile
GtkMediaFile
gtk_media_file_new
gtk_media_file_new_for_filename
gtk_media_file_new_for_resource
gtk_media_file_new_for_file
gtk_media_file_new_for_input_stream
gtk_media_file_clear
gtk_media_file_set_filename
gtk_media_file_set_resource
gtk_media_file_set_file
gtk_media_file_get_file
gtk_media_file_set_input_stream
gtk_media_file_get_input_stream
GTK_TYPE_MEDIA_FILE
gtk_media_file_get_type
gtkmediastream
GtkMediaStream
GtkMediaStreamClass
gtk_media_stream_is_prepared
gtk_media_stream_get_error
gtk_media_stream_has_audio
gtk_media_stream_has_video
gtk_media_stream_play
gtk_media_stream_pause
gtk_media_stream_get_playing
gtk_media_stream_set_playing
gtk_media_stream_get_ended
gtk_media_stream_get_timestamp
gtk_media_stream_get_duration
gtk_media_stream_is_seekable
gtk_media_stream_is_seeking
gtk_media_stream_seek
gtk_media_stream_get_loop
gtk_media_stream_set_loop
gtk_media_stream_get_muted
gtk_media_stream_set_muted
gtk_media_stream_get_volume
gtk_media_stream_set_volume
gtk_media_stream_realize
gtk_media_stream_unrealize
gtk_media_stream_prepared
gtk_media_stream_unprepared
gtk_media_stream_update
gtk_media_stream_ended
gtk_media_stream_seek_success
gtk_media_stream_seek_failed
gtk_media_stream_gerror
gtk_media_stream_error
gtk_media_stream_error_valist
GTK_TYPE_MEDIA_STREAM
gtk_media_stream_get_type
gtkroot
GtkRoot
GtkRoot
gtk_root_get_display
gtk_root_get_focus
gtk_root_set_focus
gtk_root_get_type
gtknative
GtkNative
gtk_native_get_for_surface
gtk_native_get_surface
gtk_native_get_renderer
gtk_native_check_resize
gtk_native_get_type
gtklayoutmanager
GtkLayoutManager
GtkLayoutManagerClass
gtk_layout_manager_measure
gtk_layout_manager_allocate
gtk_layout_manager_get_request_mode
gtk_layout_manager_get_widget
gtk_layout_manager_get_layout_child
gtk_layout_manager_layout_changed
GTK_TYPE_LAYOUT_MANAGER
gtk_layout_manager_get_type
gtklayoutchild
GtkLayoutChild
GtkLayoutChildClass
gtk_layout_child_get_layout_manager
gtk_layout_child_get_child_widget
GTK_TYPE_LAYOUT_CHILD
gtk_layout_child_get_type
gtkboxlayout
GtkBoxLayout
gtk_box_layout_new
gtk_box_layout_set_homogeneous
gtk_box_layout_get_homogeneous
gtk_box_layout_set_spacing
gtk_box_layout_get_spacing
gtk_box_layout_set_baseline_position
gtk_box_layout_get_baseline_position
GTK_TYPE_BOX_LAYOUT
gtk_box_layout_get_type
gtkcustomlayout
GtkCustomLayout
GtkCustomRequestModeFunc
GtkCustomMeasureFunc
GtkCustomAllocateFunc
gtk_custom_layout_new
GTK_TYPE_CUSTOM_LAYOUT
gtk_custom_layout_get_type
gtkbinlayout
GtkBinLayout
gtk_bin_layout_new
GTK_TYPE_BIN_LAYOUT
gtk_bin_layout_get_type
gtkfixedlayout
GtkFixedLayout
gtk_fixed_layout_new
GtkFixedLayoutChild
gtk_fixed_layout_child_set_transform
gtk_fixed_layout_child_get_transform
GTK_TYPE_FIXED_LAYOUT
gtk_fixed_layout_get_type
GTK_TYPE_FIXED_LAYOUT_CHILD
gtk_fixed_layout_child_get_type
gtkgridlayout
GtkGridLayout
gtk_grid_layout_new
gtk_grid_layout_set_row_homogeneous
gtk_grid_layout_get_row_homogeneous
gtk_grid_layout_set_row_spacing
gtk_grid_layout_get_row_spacing
gtk_grid_layout_set_column_homogeneous
gtk_grid_layout_get_column_homogeneous
gtk_grid_layout_set_column_spacing
gtk_grid_layout_get_column_spacing
gtk_grid_layout_set_row_baseline_position
gtk_grid_layout_get_row_baseline_position
gtk_grid_layout_set_baseline_row
gtk_grid_layout_get_baseline_row
GtkGridLayoutChild
gtk_grid_layout_child_set_top_attach
gtk_grid_layout_child_get_top_attach
gtk_grid_layout_child_set_left_attach
gtk_grid_layout_child_get_left_attach
gtk_grid_layout_child_set_column_span
gtk_grid_layout_child_get_column_span
gtk_grid_layout_child_set_row_span
gtk_grid_layout_child_get_row_span
GTK_TYPE_GRID_LAYOUT
gtk_grid_layout_get_type
GTK_TYPE_GRID_LAYOUT_CHILD
gtk_grid_layout_child_get_type
gtkconstraint
GtkConstraint
GtkConstraintTarget
gtk_constraint_new
gtk_constraint_new_constant
gtk_constraint_get_target
GtkConstraintAttribute
gtk_constraint_get_target_attribute
GtkConstraintRelation
gtk_constraint_get_relation
gtk_constraint_get_source
gtk_constraint_get_source_attribute
gtk_constraint_get_multiplier
gtk_constraint_get_constant
GtkConstraintStrength
gtk_constraint_get_strength
gtk_constraint_is_required
gtk_constraint_is_attached
gtk_constraint_is_constant
GTK_TYPE_CONSTRAINT
gtk_constraint_get_type
GTK_TYPE_CONSTRAINT_TARGET
gtk_constraint_target_get_type
gtkconstraintlayout
GtkConstraintLayout
GtkConstraintLayoutChild
GtkConstraintVflParserError
gtk_constraint_layout_new
gtk_constraint_layout_add_constraint
gtk_constraint_layout_remove_constraint
gtk_constraint_layout_remove_all_constraints
gtk_constraint_layout_add_guide
gtk_constraint_layout_remove_guide
gtk_constraint_layout_add_constraints_from_description
gtk_constraint_layout_add_constraints_from_descriptionv
gtk_constraint_layout_observe_constraints
gtk_constraint_layout_observe_guides
GTK_TYPE_CONSTRAINT_LAYOUT
gtk_constraint_layout_get_type
GTK_TYPE_CONSTRAINT_LAYOUT_CHILD
gtk_constraint_layout_child_get_type
GTK_CONSTRAINT_VFL_PARSER_ERROR
gtk_constraint_vfl_parser_error_quark
gtkconstraintguide
GtkConstraintGuide
gtk_constraint_guide_new
gtk_constraint_guide_set_name
gtk_constraint_guide_get_name
gtk_constraint_guide_set_strength
gtk_constraint_guide_get_strength
gtk_constraint_guide_set_min_size
gtk_constraint_guide_get_min_size
gtk_constraint_guide_set_nat_size
gtk_constraint_guide_get_nat_size
gtk_constraint_guide_set_max_size
gtk_constraint_guide_get_max_size
GTK_TYPE_CONSTRAINT_GUIDE
gtk_constraint_guide_get_tyoe
gtkdragsource
GtkDragSource
gtk_drag_source_new
gtk_drag_source_set_content
gtk_drag_source_get_content
gtk_drag_source_set_actions
gtk_drag_source_get_actions
gtk_drag_source_set_icon
gtk_drag_source_drag_cancel
gtk_drag_source_get_drag
gtk_drag_check_threshold
GTK_TYPE_DRAG_SOURCE
GTK_DRAG_SOURCE
GTK_DRAG_SOURCE_CLASS
GTK_IS_DRAG_SOURCE
GTK_IS_DRAG_SOURCE_CLASS
GTK_DRAG_SOURCE_GET_CLASS
gtk_drag_source_get_type
gtkdroptarget
GtkDropTarget
gtk_drop_target_new
gtk_drop_target_set_gtypes
gtk_drop_target_get_gtypes
gtk_drop_target_get_formats
gtk_drop_target_set_actions
gtk_drop_target_get_actions
gtk_drop_target_set_preload
gtk_drop_target_get_preload
gtk_drop_target_get_drop
gtk_drop_target_get_value
gtk_drop_target_reject
GTK_TYPE_DROP_TARGET
GTK_DROP_TARGET
GTK_DROP_TARGET_CLASS
GTK_IS_DROP_TARGET
GTK_IS_DROP_TARGET_CLASS
GTK_DROP_TARGET_GET_CLASS
gtk_drop_target_get_type
gtkdroptargetasync
GtkDropTargetAsync
gtk_drop_target_async_new
gtk_drop_target_async_set_formats
gtk_drop_target_async_get_formats
gtk_drop_target_async_set_actions
gtk_drop_target_async_get_actions
gtk_drop_target_async_reject_drop
GTK_TYPE_DROP_TARGET_ASYNC
GTK_DROP_TARGET_ASYNC
GTK_DROP_TARGET_ASYNC_CLASS
GTK_IS_DROP_TARGET_ASYNC
GTK_IS_DROP_TARGET_ASYNC_CLASS
GTK_DROP_TARGET_ASYNC_GET_CLASS
gtk_drop_target_async_get_type
gtkdropcontrollermotion
GtkDropControllerMotion
GtkDropControllerMotion
gtk_drop_controller_motion_new
gtk_drop_controller_motion_contains_pointer
gtk_drop_controller_motion_is_pointer
gtk_drop_controller_motion_get_drop
GTK_TYPE_DROP_CONTROLLER_MOTION
GTK_DROP_CONTROLLER_MOTION
GTK_DROP_CONTROLLER_MOTION_CLASS
GTK_IS_DROP_CONTROLLER_MOTION
GTK_IS_DROP_CONTROLLER_MOTION_CLASS
GTK_DROP_CONTROLLER_MOTION_GET_CLASS
gtk_drop_controller_motion_get_type
gtkdragicon
GtkDragIcon
gtk_drag_icon_get_for_drag
gtk_drag_icon_set_child
gtk_drag_icon_get_child
gtk_drag_icon_set_from_paintable
gtk_drag_icon_create_widget_for_value
GTK_TYPE_DRAG_ICON
GTK_DRAG_ICON
GTK_DRAG_ICON_CLASS
GTK_IS_DRAG_ICON
GTK_IS_DRAG_ICON_CLASS
GTK_DRAG_ICON_GET_CLASS
gtk_drag_icon_get_type
gtkemojichooser
GtkEmojiChooser
gtk_emoji_chooser_new
GTK_TYPE_EMOJI_CHOOSER
GTK_EMOJI_CHOOSER
GTK_EMOJI_CHOOSER_CLASS
GTK_IS_EMOJI_CHOOSER
GTK_IS_EMOJI_CHOOSER_CLASS
GTK_EMOJI_CHOOSER_GET_CLASS
gtk_emoji_chooser_get_type
docs/reference/gtk/gtk4-overrides.txt 0000664 0001750 0001750 00000000000 13640771677 020003 0 ustar mclasen mclasen docs/reference/gtk/html/ 0000775 0001750 0001750 00000000000 13640772051 015332 5 ustar mclasen mclasen docs/reference/gtk/html/aboutdialog.png 0000664 0001750 0001750 00000050640 13640771677 020354 0 ustar mclasen mclasen PNG
IHDR O g sBIT|d IDATxw|e̶$EE,Գg~gEQ+{ogw RDNMef$lBIv7y-;;33 """""""""""""""""""""""""""""""""""""""""""""maĺ͈zȎŎu&1""";xxHX\v,Cu+ED35qر
ŦUhHgjm8_Z4v՞i)XpKC(Ӏ3g4~Ā%zȡlܸBk/v
#-lp8tP`W06mM7mI;tTg٧ǷS=DDD?UmB!]Y[Eal2hKj7vǏ7nqP6rȴ^o@w иMuHpG&MQg?#'mwEDDp9]?~0ЃP˹[ulds+CGWP7"Z:iYYYCi""""+3dlsnhF玲KYE|VYMeUe#s)ۏ>`qd
8qd i}ձIeNς_A(݅}9K,pIuuvZmc6thӫej*Ĕt?`$OljOTKk|tO`GPGZ
-]\JR
NWּm˲XWg04YsfAHLLu5PP:K)|zqb\ѲCQ7'/fuoZeYx<زm`0Yvɖd{| ]y?O'NdsK:|ºCtQYjQ LTPX;DWp@tǨozZ80q ($$^ A%g
sKz4FчJצ/jQ۶1c-|>_Wfۦ%VQ@3'Ԣ.(;E
3l,}ǖw8F~L0Il_M^5_[50;ϫ'0p>E{g*TNAyL&"*ZS[֝yz҇Jק`c-̝5p?ĬPZiF]1^~
:>Fk}u/c^Nꎜ^/=}G{