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.

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 that is returned should not be modified in any way.

application :

 a GtkApplication

Returns :

 a GList of GtkWindow. [element-type GtkWindow][transfer none]

Since 3.0

Generated by GTK-Doc V1.17