GTK 3

https://docs.gtk.org/gtk3/
Admin
GTK 3 is a multi-platform toolkit for creating graphical user interfaces, providing a comprehensive...
Tokens:1,278,123
Snippets:14,975
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Displaying a Page Setup Dialog

Source: https://docs.gtk.org/gtk3/class.PageSetup.html

Example of how to invoke the page setup dialog and update the current page setup object.

```C
static GtkPrintSettings *settings = NULL;
static GtkPageSetup *page_setup = NULL;

static void
do_page_setup (void)
{
  GtkPageSetup *new_page_setup;

  if (settings == NULL)
    settings = gtk_print_settings_new ();

  new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
                                                    page_setup, settings);

  if (page_setup)
    g_object_unref (page_setup);

  page_setup = new_page_setup;
}
```

--------------------------------

### Conditional File Chooser Setup

Source: https://docs.gtk.org/gtk3/method.FileChooser.set_file.html

Example demonstrating how to choose between setting a default folder/name for new documents or setting an existing file for editing.

```c
if (document_is_new)
  {
    // the user just created a new document
    gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
    gtk_file_chooser_set_current_name (chooser, "Untitled document");
  }
else
  {
    // the user edited an existing document
    gtk_file_chooser_set_file (chooser, existing_file);
  }
```

--------------------------------

### Build and install GTK

Source: https://docs.gtk.org/gtk3/building.html

Execute the make command to compile the source and install the resulting binaries and libraries.

```bash
make
make install
```

--------------------------------

### Adding a Key Binding

Source: https://docs.gtk.org/gtk3/type_func.BindingEntry.add_signal.html

Example of installing a key binding that triggers the 'move-cursor' signal with multiple arguments.

```c
GtkBindingSet *binding_set;
GdkModifierType modmask = GDK_CONTROL_MASK;
int count = 1;
gtk_binding_entry_add_signal (binding_set,
                              GDK_KEY_space,
                              modmask,
                              "move-cursor", 2,
                              GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_PAGES,
                              G_TYPE_INT, count,
                              G_TYPE_BOOLEAN, FALSE);
```

--------------------------------

### ready (GtkPrintOperationPreview* self, GtkPrintContext* context, gpointer user_data)

Source: https://docs.gtk.org/gtk3/signal.PrintOperationPreview.ready.html

The ::ready signal gets emitted once per preview operation, before the first page is rendered. A handler for this signal can be used for setup tasks.

```APIDOC
## Signal: ready

### Description
The ::ready signal gets emitted once per preview operation, before the first page is rendered. A handler for this signal can be used for setup tasks.

### Signature
void ready (GtkPrintOperationPreview* self, GtkPrintContext* context, gpointer user_data)

### Parameters
- **self** (GtkPrintOperationPreview*) - The instance the signal is emitted on.
- **context** (GtkPrintContext*) - The current GtkPrintContext. The data is owned by the caller of the function.
- **user_data** (gpointer) - User data passed to the signal handler.
```

--------------------------------

### Handle editing-started signal

Source: https://docs.gtk.org/gtk3/signal.CellRenderer.editing-started.html

Example callback function demonstrating how to safely check the type of the editable widget before performing setup.

```c
static void
text_editing_started (GtkCellRenderer *cell,
                      GtkCellEditable *editable,
                      const gchar     *path,
                      gpointer         data)
{
  if (GTK_IS_ENTRY (editable))
    {
      GtkEntry *entry = GTK_ENTRY (editable);
      
      // ... create a GtkEntryCompletion
      
      gtk_entry_set_completion (entry, completion);
    }
}
```

--------------------------------

### gtk_page_setup_new_from_key_file

Source: https://docs.gtk.org/gtk3/ctor.PageSetup.new_from_key_file.html

Reads the page setup from the group group_name in the key file key_file. Returns a new GtkPageSetup object with the restored page setup, or NULL if an error occurred.

```APIDOC
## gtk_page_setup_new_from_key_file

### Description
Reads the page setup from the group group_name in the key file key_file. Returns a new GtkPageSetup object with the restored page setup, or NULL if an error occurred.

### Signature
GtkPageSetup* gtk_page_setup_new_from_key_file (GKeyFile* key_file, const gchar* group_name, GError** error)

### Parameters
- **key_file** (GKeyFile*) - The GKeyFile to retrieve the page_setup from.
- **group_name** (const gchar*) - The name of the group in the key_file to read, or NULL to use the default name “Page Setup”.
- **error** (GError**) - The return location for a recoverable error.

### Return Value
- **GtkPageSetup*** - The restored GtkPageSetup object. The caller takes ownership of the data.
```

--------------------------------

### Set environment variables for custom installation

Source: https://docs.gtk.org/gtk3/building.html

Configure preprocessor, linker, and pkg-config paths to point to a custom installation directory.

```bash
CPPFLAGS="-I/opt/gtk/include"
LDFLAGS="-L/opt/gtk/lib"
PKG_CONFIG_PATH="/opt/gtk/lib/pkgconfig"
export CPPFLAGS LDFLAGS PKG_CONFIG_PATH
```

--------------------------------

### Initialize GtkTextView

Source: https://docs.gtk.org/gtk3/text-widget-overview.html

Demonstrates the basic setup of a GtkTextView and its associated GtkTextBuffer.

```c
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.
 */
```

--------------------------------

### Complete GTK3 TreeView Example

Source: https://docs.gtk.org/gtk3/treeview-tutorial.html

This example demonstrates the full lifecycle of a GtkTreeView, including model creation, column configuration, custom cell data functions, and main application loop.

```c
#include <gtk/gtk.h>

enum
{
  COL_FIRST_NAME = 0,
  COL_LAST_NAME,
  COL_YEAR_BORN,
  NUM_COLS
} ;

static GtkTreeModel *
create_and_fill_model (void)
{
  GtkTreeStore  *treestore;
  GtkTreeIter    toplevel, child;

  treestore = gtk_tree_store_new(NUM_COLS,
                                 G_TYPE_STRING,
                                 G_TYPE_STRING,
                                 G_TYPE_UINT);

  /* Append a top level row and leave it empty */
  gtk_tree_store_append(treestore, &toplevel, NULL);
  gtk_tree_store_set(treestore, &toplevel,
                     COL_FIRST_NAME, "Maria",
                     COL_LAST_NAME, "Incognito",
                     -1);

  /* Append a second top level row, and fill it with some data */
  gtk_tree_store_append(treestore, &toplevel, NULL);
  gtk_tree_store_set(treestore, &toplevel,
                     COL_FIRST_NAME, "Jane",
                     COL_LAST_NAME, "Average",
                     COL_YEAR_BORN, (guint) 1962,
                     -1);

  /* Append a child to the second top level row, and fill in some data */
  gtk_tree_store_append(treestore, &child, &toplevel);
  gtk_tree_store_set(treestore, &child,
                     COL_FIRST_NAME, "Janinita",
                     COL_LAST_NAME, "Average",
                     COL_YEAR_BORN, (guint) 1985,
                     -1);

  return GTK_TREE_MODEL(treestore);
}

void
age_cell_data_func (GtkTreeViewColumn *col,
                    GtkCellRenderer   *renderer,
                    GtkTreeModel      *model,
                    GtkTreeIter       *iter,
                    gpointer           user_data)
{
  guint  year_born;
  guint  year_now = 2003; /* to save code not relevant for the example */
  gchar  buf[64];

  gtk_tree_model_get(model, iter, COL_YEAR_BORN, &year_born, -1);

  if (year_born <= year_now && year_born > 0)
  {
    guint age = year_now - year_born;

    g_snprintf(buf, sizeof(buf), "%u years old", age);

    g_object_set(renderer, "foreground-set", FALSE, NULL); /* print this normal */
  }
  else
  {
    g_snprintf(buf, sizeof(buf), "age unknown");

    /* make red */
    g_object_set(renderer, "foreground", "Red", "foreground-set", TRUE, NULL);
  }

  g_object_set(renderer, "text", buf, NULL);
}

static GtkWidget *
create_view_and_model (void)
{
  GtkTreeViewColumn   *col;
  GtkCellRenderer     *renderer;
  GtkWidget           *view;
  GtkTreeModel        *model;

  view = gtk_tree_view_new();

  /* --- Column #1 --- */

  col = gtk_tree_view_column_new();

  gtk_tree_view_column_set_title(col, "First Name");

  /* pack tree view column into tree view */
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);

  renderer = gtk_cell_renderer_text_new();

  /* pack cell renderer into tree view column */
  gtk_tree_view_column_pack_start(col, renderer, TRUE);

  /* connect 'text' property of the cell renderer to
   *  model column that contains the first name */
  gtk_tree_view_column_add_attribute(col, renderer, "text", COL_FIRST_NAME);


  /* --- Column #2 --- */

  col = gtk_tree_view_column_new();

  gtk_tree_view_column_set_title(col, "Last Name");

  /* pack tree view column into tree view */
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);

  renderer = gtk_cell_renderer_text_new();

  /* pack cell renderer into tree view column */
  gtk_tree_view_column_pack_start(col, renderer, TRUE);

  /* connect 'text' property of the cell renderer to
   *  model column that contains the last name */
  gtk_tree_view_column_add_attribute(col, renderer, "text", COL_LAST_NAME);

  /* set 'weight' property of the cell renderer to
   *  bold print (we want all last names in bold) */
  g_object_set(renderer,
               "weight", PANGO_WEIGHT_BOLD,
               "weight-set", TRUE,
               NULL);


  /* --- Column #3 --- */

  col = gtk_tree_view_column_new();

  gtk_tree_view_column_set_title(col, "Age");

  /* pack tree view column into tree view */
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);

  renderer = gtk_cell_renderer_text_new();

  /* pack cell renderer into tree view column */
  gtk_tree_view_column_pack_start(col, renderer, TRUE);

  /* connect a cell data function */
  gtk_tree_view_column_set_cell_data_func(col, renderer, age_cell_data_func, NULL, NULL);


  model = create_and_fill_model();

  gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);

  g_object_unref(model); /* destroy model automatically with view */

  gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
                              GTK_SELECTION_NONE);

  return view;
}


int
main (int argc, char **argv)
{
  GtkWidget *window;
  GtkWidget *view;

  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  g_signal_connect(window, "delete_event", gtk_main_quit, NULL); /* dirty */

  view = create_view_and_model();

  gtk_container_add(GTK_CONTAINER(window), view);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
```

--------------------------------

### gtk_page_setup_load_file

Source: https://docs.gtk.org/gtk3/method.PageSetup.load_file.html

Reads the page setup from the file specified by file_name.

```APIDOC
## gtk_page_setup_load_file

### Description
Reads the page setup from the file `file_name`. This method is available since version 2.14.

### Signature
`gboolean gtk_page_setup_load_file (GtkPageSetup* setup, const char* file_name, GError** error)`

### Parameters
- **setup** (GtkPageSetup*) - The GtkPageSetup object.
- **file_name** (const char*) - The filename to read the page setup from.
- **error** (GError**) - The return location for a recoverable error, or NULL.

### Return Value
- **gboolean** - Returns TRUE on success.
```

--------------------------------

### gtk_page_setup_new_from_gvariant

Source: https://docs.gtk.org/gtk3/ctor.PageSetup.new_from_gvariant.html

Deserializes a page setup from an a{sv} variant.

```APIDOC
## gtk_page_setup_new_from_gvariant

### Description
Deserializes a page setup from an a{sv} variant in the format produced by gtk_page_setup_to_gvariant(). Available since: 3.22.

### Signature
GtkPageSetup* gtk_page_setup_new_from_gvariant (GVariant* variant)

### Parameters
- **variant** (GVariant*) - Required - An a{sv} GVariant. The data is owned by the caller of the function.

### Return Value
- **Type**: GtkPageSetup*
- **Description**: A new GtkPageSetup object. The caller of the function takes ownership of the data and is responsible for freeing it.
```

--------------------------------

### Create a basic GTK window

Source: https://docs.gtk.org/gtk3/getting_started.html

A minimal example demonstrating how to initialize a GtkApplication and display a window.

```c
#include <gtk/gtk.h>

static void
activate (GtkApplication* app,
          gpointer        user_data)
{
  GtkWidget *window;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
  gtk_widget_show_all (window);
}

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

  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);

  return status;
}
```

--------------------------------

### gtk_text_view_get_line_at_y

Source: https://docs.gtk.org/gtk3/class.TextView.html

Gets the GtkTextIter at the start of the line containing the coordinate y.

```APIDOC
## gtk_text_view_get_line_at_y

### Description
Gets the GtkTextIter at the start of the line containing the coordinate y. y is in buffer coordinates.
```

--------------------------------

### Create a Hello World GTK Application

Source: https://docs.gtk.org/gtk3/getting_started.html

A complete C example demonstrating window creation, button layout, and signal connection to handle user clicks.

```c
#include <gtk/gtk.h>

static void
print_hello (GtkWidget *widget,
             gpointer   data)
{
  g_print ("Hello World\n");
}

static void
activate (GtkApplication *app,
          gpointer        user_data)
{
  GtkWidget *window;
  GtkWidget *button;
  GtkWidget *button_box;

  window = gtk_application_window_new (app);
  gtk_window_set_title (GTK_WINDOW (window), "Window");
  gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);

  button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
  gtk_container_add (GTK_CONTAINER (window), button_box);

  button = gtk_button_new_with_label ("Hello World");
  g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
  gtk_container_add (GTK_CONTAINER (button_box), button);

  gtk_widget_show_all (window);
}

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

  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);

  return status;
}
```

--------------------------------

### gtk_icon_view_get_item_row

Source: https://docs.gtk.org/gtk3/method.IconView.get_item_row.html

Gets the row in which the item path is currently displayed. Row numbers start at 0.

```APIDOC
## gtk_icon_view_get_item_row

### Description
Gets the row in which the item `path` is currently displayed. Row numbers start at 0.

### Signature
`gint gtk_icon_view_get_item_row (GtkIconView* icon_view, GtkTreePath* path)`

### Parameters
- **icon_view** (GtkIconView*) - The GtkIconView widget.
- **path** (GtkTreePath*) - The GtkTreePath of the item.

### Return Value
- **gint** - The row in which the item is displayed.
```

--------------------------------

### Implementing a GtkInfoBar

Source: https://docs.gtk.org/gtk3/class.InfoBar.html

Example showing how to initialize a GtkInfoBar, add content, and handle response signals.

```C
GtkWidget *widget, *message_label, *content_area;
GtkWidget *grid;
GtkInfoBar *bar;

// set up info bar
widget = gtk_info_bar_new ();
bar = GTK_INFO_BAR (widget);
grid = gtk_grid_new ();

gtk_widget_set_no_show_all (widget, TRUE);
message_label = gtk_label_new ("");
content_area = gtk_info_bar_get_content_area (bar);
gtk_container_add (GTK_CONTAINER (content_area),
                   message_label);
gtk_info_bar_add_button (bar,
                         _("_OK"),
                         GTK_RESPONSE_OK);
g_signal_connect (bar,
                  "response",
                  G_CALLBACK (gtk_widget_hide),
                  NULL);
gtk_grid_attach (GTK_GRID (grid),
                 widget,
                 0, 2, 1, 1);

// ...

// show an error message
gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
gtk_info_bar_set_message_type (bar,
                               GTK_MESSAGE_ERROR);
gtk_widget_show (bar);
```

--------------------------------

### Create a basic GtkTreeView Hello World application

Source: https://docs.gtk.org/gtk3/treeview-tutorial.html

A complete example demonstrating the creation of a GtkListStore model, configuring columns with text renderers, and displaying the view in a top-level window.

```c
#include <gtk/gtk.h>

enum
{
  COL_NAME = 0,
  COL_AGE,
  NUM_COLS
} ;


static GtkTreeModel *
create_and_fill_model (void)
{
  GtkListStore *store = gtk_list_store_new (NUM_COLS,
                                            G_TYPE_STRING,
                                            G_TYPE_UINT);

  /* Append a row and fill in some data */
  GtkTreeIter iter;
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Heinz El-Mann",
                      COL_AGE, 51,
                      -1);

  /* append another row and fill in some data */
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Jane Doe",
                      COL_AGE, 23,
                      -1);

  /* ... and a third row */
  gtk_list_store_append (store, &iter);
  gtk_list_store_set (store, &iter,
                      COL_NAME, "Joe Bungop",
                      COL_AGE, 91,
                      -1);

  return GTK_TREE_MODEL (store);
}

static GtkWidget *
create_view_and_model (void)
{
  GtkWidget *view = gtk_tree_view_new ();

  GtkCellRenderer *renderer;

  /* --- Column #1 --- */
  renderer = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
                                               -1,      
                                               "Name",  
                                               renderer,
                                               "text", COL_NAME,
                                               NULL);

  /* --- Column #2 --- */
  renderer = gtk_cell_renderer_text_new ();
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
                                               -1,      
                                               "Age",  
                                               renderer,
                                               "text", COL_AGE,
                                               NULL);

  GtkTreeModel *model = create_and_fill_model ();

  gtk_tree_view_set_model (GTK_TREE_VIEW (view), model);

  /* The tree view has acquired its own reference to the
   *  model, so we can drop ours. That way the model will
   *  be freed automatically when the tree view is destroyed
   */
  g_object_unref (model);

  return view;
}

int
main (int argc, char **argv)
{
  gtk_init (&argc, &argv);

  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (window, "destroy", gtk_main_quit, NULL);

  GtkWidget *view = create_view_and_model ();

  gtk_container_add (GTK_CONTAINER (window), view);

  gtk_widget_show_all (window);

  gtk_main ();

  return 0;
}
```

--------------------------------

### Define and initialize the preference dialog

Source: https://docs.gtk.org/gtk3/getting_started.html

Defines the ExampleAppPrefs structure and initializes it with GSettings bindings and UI template resources.

```c
#include <gtk/gtk.h>

#include "exampleapp.h"
#include "exampleappwin.h"
#include "exampleappprefs.h"

struct _ExampleAppPrefs
{
  GtkDialog parent;
};

typedef struct _ExampleAppPrefsPrivate ExampleAppPrefsPrivate;

struct _ExampleAppPrefsPrivate
{
  GSettings *settings;
  GtkWidget *font;
  GtkWidget *transition;
};

G_DEFINE_TYPE_WITH_PRIVATE(ExampleAppPrefs, example_app_prefs, GTK_TYPE_DIALOG)

static void
example_app_prefs_init (ExampleAppPrefs *prefs)
{
  ExampleAppPrefsPrivate *priv;

  priv = example_app_prefs_get_instance_private (prefs);
  gtk_widget_init_template (GTK_WIDGET (prefs));
  priv->settings = g_settings_new ("org.gtk.exampleapp");

  g_settings_bind (priv->settings, "font",
                   priv->font, "font",
                   G_SETTINGS_BIND_DEFAULT);
  g_settings_bind (priv->settings, "transition",
                   priv->transition, "active-id",
                   G_SETTINGS_BIND_DEFAULT);
}

static void
example_app_prefs_dispose (GObject *object)
{
  ExampleAppPrefsPrivate *priv;

  priv = example_app_prefs_get_instance_private (EXAMPLE_APP_PREFS (object));
  g_clear_object (&priv->settings);

  G_OBJECT_CLASS (example_app_prefs_parent_class)->dispose (object);
}

static void
example_app_prefs_class_init (ExampleAppPrefsClass *class)
{
  G_OBJECT_CLASS (class)->dispose = example_app_prefs_dispose;

  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (class),
                                               "/org/gtk/exampleapp/prefs.ui");
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), ExampleAppPrefs, font);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (class), ExampleAppPrefs, transition);
}

ExampleAppPrefs *
example_app_prefs_new (ExampleAppWindow *win)
{
  return g_object_new (EXAMPLE_APP_PREFS_TYPE, "transient-for", win, "use-header-bar", TRUE, NULL);
}
```

--------------------------------

### GtkCellRenderer::editing-started

Source: https://docs.gtk.org/gtk3/signal.CellRenderer.editing-started.html

This signal is emitted when a cell starts to be edited. It is used to perform special setup on the editable widget, such as adding completion or configuring additional properties.

```APIDOC
## Signal: editing-started

### Description
This signal gets emitted when a cell starts to be edited. The intended use of this signal is to do special setup on `editable`, e.g. adding a `GtkEntryCompletion` or setting up additional columns in a `GtkComboBox`.

### Signature
```c
void editing_started (GtkCellRenderer* self, GtkCellEditable* editable, gchar* path, gpointer user_data)
```

### Parameters
- **self** (GtkCellRenderer*) - The object which received the signal.
- **editable** (GtkCellEditable*) - The GtkCellEditable widget used for editing.
- **path** (gchar*) - The path identifying the edited cell.
- **user_data** (gpointer) - User data passed to the signal handler.

### Example
```c
static void
text_editing_started (GtkCellRenderer *cell,
                      GtkCellEditable *editable,
                      const gchar     *path,
                      gpointer         data)
{
  if (GTK_IS_ENTRY (editable))
    {
      GtkEntry *entry = GTK_ENTRY (editable);
      // ... perform setup
    }
}
```
```

--------------------------------

### Setting up a radio group

Source: https://docs.gtk.org/gtk3/method.RadioAction.get_group.html

Example demonstrating how to initialize and manage a group of radio actions using get_group and set_group.

```C
  GSList *group = NULL;
  GtkRadioAction *action;
 
  while ( ...more actions to add... /)
    {
       action = gtk_radio_action_new (...);
       
       gtk_radio_action_set_group (action, group);
       group = gtk_radio_action_get_group (action);
    }
```

--------------------------------

### CSS Usage Example

Source: https://docs.gtk.org/gtk3/type_func.ThemingEngine.register_property.html

Example of how a custom registered property is referenced within a CSS file.

```css
* {
    engine: someengine;
    -SomeEngine-custom-property: 2;
}
```

--------------------------------

### CSS Reference Example

Source: https://docs.gtk.org/gtk3/property.ThemingEngine.name.html

Example of how a custom property registered by a theming engine is referenced in a CSS file.

```css
-Clearlooks-glossy: true;
```

--------------------------------

### Creating and Populating a GtkListStore

Source: https://docs.gtk.org/gtk3/class.ListStore.html

Example demonstrating how to initialize a GtkListStore, append rows, and modify existing data.

```C
enum {
  COLUMN_STRING,
  COLUMN_INT,
  COLUMN_BOOLEAN,
  N_COLUMNS
};

{
  GtkListStore *list_store;
  GtkTreePath *path;
  GtkTreeIter iter;
  gint i;

  list_store = gtk_list_store_new (N_COLUMNS,
                                   G_TYPE_STRING,
                                   G_TYPE_INT,
                                   G_TYPE_BOOLEAN);

  for (i = 0; i < 10; i++)
    {
      gchar *some_data;

      some_data = get_some_data (i);

      // Add a new row to the model
      gtk_list_store_append (list_store, &iter);
      gtk_list_store_set (list_store, &iter,
                          COLUMN_STRING, some_data,
                          COLUMN_INT, i,
                          COLUMN_BOOLEAN,  FALSE,
                          -1);

      // As the store will keep a copy of the string internally,
      // we free some_data.
      g_free (some_data);
    }

  // Modify a particular row
  path = gtk_tree_path_new_from_string ("4");
  gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
                           &iter,
                           path);
  gtk_tree_path_free (path);
  gtk_list_store_set (list_store, &iter,
                      COLUMN_BOOLEAN, TRUE,
                      -1);
}
```

--------------------------------

### gtk_text_iter_set_offset

Source: https://docs.gtk.org/gtk3/method.TextIter.set_offset.html

Sets the GtkTextIter to point to a specific character offset, counting from the start of the text buffer (starting at 0).

```APIDOC
## void gtk_text_iter_set_offset (GtkTextIter* iter, gint char_offset)

### Description
Sets `iter` to point to `char_offset`. `char_offset` counts from the start of the entire text buffer, starting with 0.

### Parameters
- **iter** (GtkTextIter*) - The iterator to modify.
- **char_offset** (gint) - A character number representing the position to set.
```

--------------------------------

### Initialize and Run GTK3 Application

Source: https://docs.gtk.org/gtk3/getting_started.html

Standard main function boilerplate to create and execute a GtkApplication instance.

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

  app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
  g_object_unref (app);

  return status;
}
```

--------------------------------

### Create a GtkApplicationWindow with a menubar

Source: https://docs.gtk.org/gtk3/class.ApplicationWindow.html

Demonstrates initializing a GtkApplication and setting a menubar using GtkBuilder and GMenuModel.

```c
GtkApplication *app = gtk_application_new ("org.gtk.test", 0);

GtkBuilder *builder = gtk_builder_new_from_string (
    "<interface>"
    "  <menu id='menubar'>"
    "    <submenu label='_Edit'>"
    "      <item label='_Copy' action='win.copy'/>"
    "      <item label='_Paste' action='win.paste'/>"
    "    </submenu>"
    "  </menu>"
    "</interface>",
    -1);

GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder,
                                                            "menubar"));
gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
g_object_unref (builder);

// ...

GtkWidget *window = gtk_application_window_new (app);
```

--------------------------------

### gtk_text_iter_backward_line

Source: https://docs.gtk.org/gtk3/method.TextIter.backward_line.html

Moves the iterator to the start of the previous line. Returns TRUE if the iterator was moved, or if it was snapped to the start of the current line.

```APIDOC
## gtk_text_iter_backward_line

### Description
Moves `iter` to the start of the previous line. If `iter` is already on line 0 but not at the start, it snaps to the start of the line and returns TRUE. If `iter` is already at character offset 0, it returns FALSE.

### Signature
`gboolean gtk_text_iter_backward_line (GtkTextIter* iter)`

### Parameters
- **iter** (GtkTextIter*) - The iterator to move.

### Return Value
- **gboolean** - TRUE if the iterator was moved or snapped to the start of the line, FALSE if it was already at the beginning of the buffer.
```

--------------------------------

### Initialize Application Window with Menu and Settings

Source: https://docs.gtk.org/gtk3/getting_started.html

Configures the application window by loading a menu from a resource file and adding a settings-based action.

```c
static void
example_app_window_init (ExampleAppWindow *win)
{
  // ...

  builder = gtk_builder_new_from_resource ("/org/gtk/exampleapp/gears-menu.ui");
  menu = G_MENU_MODEL (gtk_builder_get_object (builder, "menu"));
  gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (priv->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);
}

// ...
```

--------------------------------

### Implement application startup and actions

Source: https://docs.gtk.org/gtk3/getting_started.html

Register GAction entries and set the application menu within the startup virtual function.

```c
// ...

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;
}

// ...
```

--------------------------------

### gtk_text_iter_set_line

Source: https://docs.gtk.org/gtk3/method.TextIter.set_line.html

Moves the provided GtkTextIter to the start of the specified line number. If the line number is out of bounds, it defaults to the start of the last line.

```APIDOC
## gtk_text_iter_set_line

### Description
Moves iterator `iter` to the start of the line `line_number`. If `line_number` is negative or larger than the number of lines in the buffer, moves `iter` to the start of the last line in the buffer.

### Signature
`void gtk_text_iter_set_line (GtkTextIter* iter, gint line_number)`

### Parameters
- **iter** (GtkTextIter*) - Required - The iterator to move.
- **line_number** (gint) - Required - Line number (counted from 0).
```

--------------------------------

### gtk_text_iter_in_range

Source: https://docs.gtk.org/gtk3/method.TextIter.in_range.html

Checks whether the provided iter falls in the range [start, end). The start and end iterators must be in ascending order.

```APIDOC
## gtk_text_iter_in_range

### Description
Checks whether `iter` falls in the range [`start`, `end`). `start` and `end` must be in ascending order.

### Signature
`gboolean gtk_text_iter_in_range (const GtkTextIter* iter, const GtkTextIter* start, const GtkTextIter* end)`

### Parameters
- **iter** (const GtkTextIter*) - The iterator to check.
- **start** (const GtkTextIter*) - Start of range.
- **end** (const GtkTextIter*) - End of range.

### Return Value
- **gboolean** - `TRUE` if `iter` is in the range.
```

--------------------------------

### gtk_text_iter_backward_word_start

Source: https://docs.gtk.org/gtk3/method.TextIter.backward_word_start.html

Moves the iterator backward to the start of the previous word. If the iterator is already at a word start, it moves to the next one further back.

```APIDOC
## gboolean gtk_text_iter_backward_word_start (GtkTextIter* iter)

### Description
Moves backward to the previous word start. If the iterator is currently on a word start, it moves backward to the next one after that. Word breaks are determined by Pango.

### Parameters
- **iter** (GtkTextIter*) - Required - The GtkTextIter to move.

### Return Value
- **gboolean** - Returns TRUE if the iterator moved and is not the end iterator.
```

--------------------------------

### gtk_page_setup_load_key_file

Source: https://docs.gtk.org/gtk3/method.PageSetup.load_key_file.html

Reads the page setup from the group group_name in the key file key_file.

```APIDOC
## gtk_page_setup_load_key_file

### Description
Reads the page setup from the group `group_name` in the key file `key_file`.

### Signature
`gboolean gtk_page_setup_load_key_file (GtkPageSetup* setup, GKeyFile* key_file, const gchar* group_name, GError** error)`

### Parameters
- **setup** (GtkPageSetup*) - The GtkPageSetup object.
- **key_file** (GKeyFile*) - The GKeyFile to retrieve the page_setup from.
- **group_name** (const gchar*) - The name of the group in the key_file to read, or NULL to use the default name “Page Setup”.
- **error** (GError**) - The return location for a recoverable error.

### Return Value
- **Type**: gboolean
- **Description**: TRUE on success.
```

--------------------------------

### Implement high-level printing

Source: https://docs.gtk.org/gtk3/class.PrintOperation.html

Example showing the typical workflow for creating a print operation, setting signals, and running the print dialog.

```C
static GtkPrintSettings *settings = NULL;

static void
do_print (void)
{
  GtkPrintOperation *print;
  GtkPrintOperationResult res;

  print = gtk_print_operation_new ();

  if (settings != NULL)
    gtk_print_operation_set_print_settings (print, settings);

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

  res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
                                 GTK_WINDOW (main_window), NULL);

  if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
    {
      if (settings != NULL)
        g_object_unref (settings);
      settings = g_object_ref (gtk_print_operation_get_print_settings (print));
    }

  g_object_unref (print);
}
```

--------------------------------

### gtk_text_iter_backward_visible_line

Source: https://docs.gtk.org/gtk3/method.TextIter.backward_visible_line.html

Moves the iterator to the start of the previous visible line. Returns TRUE if the iterator was moved, or if it was snapped to the start of the current line.

```APIDOC
## gtk_text_iter_backward_visible_line

### Description
Moves `iter` to the start of the previous visible line. If `iter` is at character offset 0, the function returns `FALSE`. If `iter` is on line 0 but not at the start, it snaps to the start of the line and returns `TRUE`.

### Signature
`gboolean gtk_text_iter_backward_visible_line (GtkTextIter* iter)`

### Parameters
- **iter** (GtkTextIter*) - The iterator to move.

### Return Value
- **gboolean** - `TRUE` if `iter` moved or was snapped to the start of the line, `FALSE` if already at the beginning of the buffer.
```

--------------------------------

### GtkPadController Usage Example

Source: https://docs.gtk.org/gtk3/class.PadController.html

Demonstrates setting up a GtkPadController to map a tablet button to an action.

```c
  GtkPadActionEntry *pad_actions[] = {
    { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
    …
  };

  …
  action_group = g_simple_action_group_new ();
  action = g_simple_action_new ("pad-actions.invert-selection", NULL);
  g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
  g_action_map_add_action (G_ACTION_MAP (action_group), action);
  …
  pad_controller = gtk_pad_controller_new (window, action_group, NULL);
```

--------------------------------

### gtk_text_iter_backward_visible_word_start

Source: https://docs.gtk.org/gtk3/method.TextIter.backward_visible_word_start.html

Moves the iterator backward to the previous visible word start. If the iterator is currently at a word start, it moves to the next one preceding it.

```APIDOC
## gtk_text_iter_backward_visible_word_start

### Description
Moves the iterator backward to the previous visible word start. If the iterator is currently on a word start, it moves backward to the next one after that. Word breaks are determined by Pango.

### Signature
`gboolean gtk_text_iter_backward_visible_word_start (GtkTextIter* iter)`

### Parameters
- **iter** (GtkTextIter*) - Required - The iterator to move.

### Return Value
- **gboolean** - Returns TRUE if the iterator moved and is not the end iterator.
```

--------------------------------

### Implement example_app_window_open

Source: https://docs.gtk.org/gtk3/getting_started.html

Constructs a GtkTextView inside a scrolled window and adds it as a page to the GtkStack when a file is opened.

```c
// ...

void
example_app_window_open (ExampleAppWindow *win,
                         GFile            *file)
{
  ExampleAppWindowPrivate *priv;
  gchar *basename;
  GtkWidget *scrolled, *view;
  gchar *contents;
  gsize length;

  priv = example_app_window_get_instance_private (win);
  basename = g_file_get_basename (file);

  scrolled = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scrolled);
  gtk_widget_set_hexpand (scrolled, TRUE);
  gtk_widget_set_vexpand (scrolled, TRUE);
  view = gtk_text_view_new ();
  gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
  gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
  gtk_widget_show (view);
  gtk_container_add (GTK_CONTAINER (scrolled), view);
  gtk_stack_add_titled (GTK_STACK (priv->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);
}

// ...
```

--------------------------------

### gtk_print_operation_set_embed_page_setup

Source: https://docs.gtk.org/gtk3/method.PrintOperation.set_embed_page_setup.html

Embeds the page size and orientation combo boxes into the page setup page of the print dialog. The selected page setup is stored as the default for the GtkPrintOperation.

```APIDOC
## gtk_print_operation_set_embed_page_setup

### Description
Embeds page size and orientation combo boxes into the page setup page. The selected page setup is stored as the default page setup in the GtkPrintOperation.

### Signature
void gtk_print_operation_set_embed_page_setup (GtkPrintOperation* op, gboolean embed)

### Parameters
- **op** (GtkPrintOperation*) - The GtkPrintOperation object.
- **embed** (gboolean) - TRUE to embed page setup selection in the GtkPrintUnixDialog.

### Since
2.18
```

--------------------------------

### Creating a GtkDialog with Buttons

Source: https://docs.gtk.org/gtk3/ctor.Dialog.new_with_buttons.html

Example showing how to initialize a modal dialog with OK and Cancel buttons.

```C
 GtkWidget *main_app_window; // Window the dialog should show up on
 GtkWidget *dialog;
 GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
 dialog = gtk_dialog_new_with_buttons ("My dialog",
                                       main_app_window,
                                       flags,
                                       _("_OK"),
                                       GTK_RESPONSE_ACCEPT,
                                       _("_Cancel"),
                                       GTK_RESPONSE_REJECT,
                                       NULL);
```

--------------------------------

### void remove_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start, const GtkTextIter* end)

Source: https://docs.gtk.org/gtk3/vfunc.TextBuffer.remove_tag.html

Removes all occurrences of the specified tag from the range defined by start and end iterators.

```APIDOC
## void remove_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start, const GtkTextIter* end)

### Description
Emits the “remove-tag” signal. The default handler for the signal removes all occurrences of `tag` from the given range. `start` and `end` do not have to be in order.

### Parameters
- **buffer** (GtkTextBuffer*) - The text buffer instance.
- **tag** (GtkTextTag*) - The tag to be removed.
- **start** (const GtkTextIter*) - One bound of the range to be untagged.
- **end** (const GtkTextIter*) - The other bound of the range to be untagged.
```

--------------------------------

### Usage Example

Source: https://docs.gtk.org/gtk3/func.rc_get_style_by_paths.html

Demonstrates how the function relates to standard widget path retrieval.

```C
 gtk_widget_path (widget, NULL, &path, NULL);
 gtk_widget_class_path (widget, NULL, &class_path, NULL);
 gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
                            path, class_path,
                            G_OBJECT_TYPE (widget));
```

--------------------------------

### void drag_begin (GtkGestureDrag* self, gdouble start_x, gdouble start_y, gpointer user_data)

Source: https://docs.gtk.org/gtk3/signal.GestureDrag.drag-begin.html

Signal emitted when dragging starts. The handler receives the starting X and Y coordinates relative to the widget allocation.

```APIDOC
## Signal: GtkGestureDrag::drag-begin

### Description
This signal is emitted whenever dragging starts. The default handler is called after handlers added via g_signal_connect().

### Signature
void drag_begin (GtkGestureDrag* self, gdouble start_x, gdouble start_y, gpointer user_data)

### Parameters
- **self** (GtkGestureDrag*) - The object which received the signal.
- **start_x** (gdouble) - X coordinate, relative to the widget allocation.
- **start_y** (gdouble) - Y coordinate, relative to the widget allocation.
- **user_data** (gpointer) - User data passed to the signal handler.

### Since
3.14
```

--------------------------------

### gtk_revealer_get_transition_duration

Source: https://docs.gtk.org/gtk3/class.Revealer.html

Gets the transition duration.

```APIDOC
## gtk_revealer_get_transition_duration

### Description
Returns the amount of time (in milliseconds) that transitions will take.

### Signature
guint gtk_revealer_get_transition_duration(GtkRevealer *revealer);
```

--------------------------------

### Initialize GtkTreeView with Model and Columns

Source: https://docs.gtk.org/gtk3/tree-widget-overview.html

Demonstrates creating a GtkTreeStore, defining columns, and attaching cell renderers to a GtkTreeView. Requires a custom populate_tree_model function to provide data.

```c
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... */
}
```

--------------------------------

### gtk_assistant_get_page_title

Source: https://docs.gtk.org/gtk3/class.Assistant.html

Gets the title for page.

```APIDOC
## gtk_assistant_get_page_title

### Description
Gets the title for page.

### Since
2.10
```

--------------------------------

### Implement binding-set rules

Source: https://docs.gtk.org/gtk3/css-overview.html

Example showing the definition of two binding sets and their application to an entry widget using the -gtk-key-bindings property.

```css
@binding-set binding-set1 {
  bind "<alt>Left" { "move-cursor" (visual-positions, -3, 0) };
  unbind "End";
};

@binding-set binding-set2 {
  bind "<alt>Right" { "move-cursor" (visual-positions, 3, 0) };
  bind "<alt>KP_space" { "delete-from-cursor" (whitespace, 1)
                         "insert-at-cursor" (" ") };
};

entry {
  -gtk-key-bindings: binding-set1, binding-set2;
}
```

--------------------------------

### void apply_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start, const GtkTextIter* end)

Source: https://docs.gtk.org/gtk3/vfunc.TextBuffer.apply_tag.html

Applies a tag to a range of text within the buffer. The start and end iterators do not need to be in any specific order.

```APIDOC
## void apply_tag (GtkTextBuffer* buffer, GtkTextTag* tag, const GtkTextIter* start, const GtkTextIter* end)

### Description
Emits the “apply-tag” signal on the buffer. The default handler for the signal applies the specified tag to the range defined by start and end.

### Parameters
- **buffer** (GtkTextBuffer*) - The buffer to apply the tag to.
- **tag** (GtkTextTag*) - The tag to be applied.
- **start** (GtkTextIter*) - One bound of the range to be tagged.
- **end** (GtkTextIter*) - The other bound of the range to be tagged.
```
Tokens:
Raw