## GtkApplication

GtkApplication — Application class

## Synopsis

    #include <gtk/gtk.h>

    struct              GtkApplication;
    GtkApplication *    gtk_application_new                 (const gchar *application_id,
                                                             GApplicationFlags flags);
    void                gtk_application_add_window          (GtkApplication *application,
                                                             GtkWindow *window);
    void                gtk_application_remove_window       (GtkApplication *application,
                                                             GtkWindow *window);
    GList *             gtk_application_get_windows         (GtkApplication *application);

## Object Hierarchy

      GObject
       +----GApplication
             +----GtkApplication

## Implemented Interfaces

GtkApplication implements GActionGroup.

## Signals

      "window-added"                                   : Run First
      "window-removed"                                 : Run First

## Description

GtkApplication is a class that handles many important aspects of a GTK+ application in a convenient fashion, without enforcing a one-size-fits-all application model.

Currently, GtkApplication handles GTK+ initialization, application uniqueness, provides some basic scriptability by exporting 'actions', and manages a list of toplevel windows whose life-cycle is automatically tied to the life-cycle of your application.

Example 110. A simple application

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100

    #include <gtk/gtk.h>

    static void
    new_window (GApplication *app,
                GFile        *file)
    {
      GtkWidget *window, *scrolled, *view;

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app));
      gtk_window_set_title (GTK_WINDOW (window), "Bloatpad");
      scrolled = gtk_scrolled_window_new (NULL, NULL);
      view = gtk_text_view_new ();
      gtk_container_add (GTK_CONTAINER (scrolled), view);
      gtk_container_add (GTK_CONTAINER (window), scrolled);

      if (file != NULL)
        {
          gchar *contents;
          gsize length;

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

      gtk_widget_show_all (GTK_WIDGET (window));
    }

    static void
    bloat_pad_activate (GApplication *application)
    {
      new_window (application, NULL);
    }

    static void
    bloat_pad_open (GApplication  *application,
                    GFile        **files,
                    gint           n_files,
                    const gchar   *hint)
    {
      gint i;

      for (i = 0; i < n_files; i++)
        new_window (application, files[i]);
    }

    typedef GtkApplication BloatPad;
    typedef GtkApplicationClass BloatPadClass;

    G_DEFINE_TYPE (BloatPad, bloat_pad, GTK_TYPE_APPLICATION)

    static void
    bloat_pad_finalize (GObject *object)
    {
      G_OBJECT_CLASS (bloat_pad_parent_class)->finalize (object);
    }

    static void
    bloat_pad_init (BloatPad *app)
    {
    }

    static void
    bloat_pad_class_init (BloatPadClass *class)
    {
      G_OBJECT_CLASS (class)->finalize= bloat_pad_finalize;

      G_APPLICATION_CLASS (class)->activate = bloat_pad_activate;
      G_APPLICATION_CLASS (class)->open = bloat_pad_open;
    }

    BloatPad *
    bloat_pad_new (void)
    {
      g_type_init ();

      return g_object_new (bloat_pad_get_type (),
                           "application-id", "org.gtk.Test.bloatpad",
                           "flags", G_APPLICATION_HANDLES_OPEN,
                           NULL);
    }

    int
    main (int argc, char **argv)
    {
      BloatPad *bloat_pad;
      int status;

      bloat_pad = bloat_pad_new ();
      status = g_application_run (G_APPLICATION (bloat_pad), argc, argv);
      g_object_unref (bloat_pad);

      return status;
    }

## Details

### struct GtkApplication

    struct GtkApplication;

### gtk_application_new ()

    GtkApplication *    gtk_application_new                 (const gchar *application_id,
                                                             GApplicationFlags flags);

Creates a new GtkApplication instance.

This function calls `g_type_init()` for you. `gtk_init()` is called as soon as the application gets registered as the primary instance.

The application id must be valid. See `g_application_id_is_valid()`.

`application_id` : | the application id
`flags` : | the application flags
Returns : | a new GtkApplication instance

### gtk_application_add_window ()

    void                gtk_application_add_window          (GtkApplication *application,
                                                             GtkWindow *window);

Adds a window from `application`.

This call is equivalent to setting the "application" property of `window` to `application`.

Normally, the connection between the application and the window will remain until the window is destroyed, but you can explicitly remove it with `gtk_application_remove_window()`.

GTK+ will keep the application running as long as it has any windows.

`application` : | a GtkApplication
`window` : | a GtkWindow

Since 3.0

### gtk_application_remove_window ()

    void                gtk_application_remove_window       (GtkApplication *application,
                                                             GtkWindow *window);

Remove a window from `application`.

If `window` belongs to `application` then this call is equivalent to setting the "application" property of `window` to `NULL`.

The application may stop running as a result of a call to this function.

`application` : | a GtkApplication
`window` : | a GtkWindow

Since 3.0

### gtk_application_get_windows ()

    GList *             gtk_application_get_windows         (GtkApplication *application);

Gets a list of the GtkWindows associated with `application`.

The list is sorted by most recently focused window, such that the first element is the currently focused window. (Useful for choosing a parent for a transient window.)

The list that is returned should not be modified in any way. It will only remain valid until the next focus change or window creation or deletion.

`application` : | a GtkApplication
Returns : | a GList of GtkWindow. [element-type GtkWindow][transfer none]

Since 3.0

## Signal Details

### The `"window-added"` signal

    void                user_function                      (GtkApplication *application,
                                                            GtkWindow      *window,
                                                            gpointer        user_data)        : Run First

Emitted when a GtkWindow is added to `application` through gtk_application_add_wi!`ndow()`.

`application` : | the GtkApplication which emitted the signal
`window` : | the newly-added GtkWindow
`user_data` : | user data set when the signal handler was connected.

Since 3.2

### The `"window-removed"` signal

    void                user_function                      (GtkApplication *application,
                                                            GtkWindow      *window,
                                                            gpointer        user_data)        : Run First

Emitted when a GtkWindow is removed from `application`, either as a side-effect of being destroyed or explicitly through `gtk_application_remove_window()`.

`application` : | the GtkApplication which emitted the signal
`window` : | the GtkWindow that is being removed
`user_data` : | user data set when the signal handler was connected.

Since 3.2