org.gnome.gtk

## Class Gtk

- Object
- - org.gnome.glib.Glib
  - - org.gnome.gtk.Gtk

-     public final class Gtk
      extends Glib

  The GTK widget toolkit initialization and main loop entry point. A typical program written with java-gnome will boil down to this:

       public class ComeOnBabyLightMyFire
       {
           public static void main(String[] args) {
               Gtk.init(args);

               // build user interface

               Gtk.main();
           }
       }

  There. Now you know everything you need to know. `:)` In due course we will write some tutorials to help you along.
  Since:
    4.0.0
  Author:
    Andrew Cowie

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | `eventsPending()` Are there any internal Events queued up waiting to be processed?
    `static Settings` | `getSettings()` Get the Settings object for the default Screen.
    `static void` | `init(String[] args)` Initialize the GTK libraries.
    `static boolean` | `isInitialized()` Has GTK been initialized yet?
    `static void` | `main()` This method blocks, ie, it does not return until the GTK main loop is terminated.
    `static boolean` | `mainIterationDo(boolean block)` Run a single iteration of the GTK main loop.
    `static void` | `mainQuit()` Exit the main loop.
    `static Pixbuf` | `renderIcon(Widget source, Stock stock, IconSize size)` Lookup the Pixbuf corresponding to a stock icon of a certain size.
    `static void` | `setDefaultIcon(Pixbuf icon)` Set the icon that will be used for all Windows in this application that do not have an one explicitly set.
    `static boolean` | `showURI(URI uri)` Launch the user's preferred application to handle (display) the the supplied URI.

    - ### Methods inherited from class org.gnome.glib.Glib

      `formatSize, formatSize, getProgramName, getRealName, getSystemConfigDirs, getSystemDataDirs, getUserCacheDir, getUserConfigDir, getUserDataDir, getUserName, getUserSpecialDir, idleAdd, markupEscapeText, reloadUserSpecialDirsCache, setProgramName`

    - ### Methods inherited from class Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### eventsPending

          public static boolean eventsPending()

      Are there any internal Events queued up waiting to be processed? Use this in conjunction with `Gtk.mainIterationDo()`.
      Since:
        4.0.19

    - #### getSettings

          public static Settings getSettings()

      Get the Settings object for the default Screen.
      Since:
        4.0.14

    - #### init

          public static void init(String[] args)

      Initialize the GTK libraries. This must be called before any other org.gnome.* classes are used.
      Parameters:
        `args` - The command line arguments array. This is passed to the underlying library to allowing user (or window manager) to alter GTK's behaviour.
      Since:
        4.0.0

    - #### isInitialized

          public static boolean isInitialized()

      Has GTK been initialized yet?
      Since:
        4.0.15

    - #### main

          public static void main()

      This method blocks, ie, it does not return until the GTK main loop is terminated.

      You can nest calls to `Gtk.main()`! If you do, then calling `mainQuit()` will make the innermost invocation of the main loop return. (This is how modal Dialog boxes run and block the rest of the application while still accepting events themselves)

      Since:
        4.0.0

    - #### mainIterationDo

          public static boolean mainIterationDo(boolean block)

      Run a single iteration of the GTK main loop.

      In GUI programming we work extremely hard not to block the main loop since this will cause the user interface to "freeze"; ordinarily we do intensive computations in a worker thread and since java-gnome is thread safe you can simply call your GUI updates from there.

      Occasionally, however, there is a circumstance where you are in the midst of a busy computation and need to explicitly let the GUI update itself and to let other idle handlers run. If so you can use the following idiom:

           while (Gtk.eventsPending()) {
               Gtk.mainIterationDo(false);
           }

      This function is not a replacement for using `Gtk.main()` to initiate event handling in your program.

      Because we have worker threads you really should not need it in normal work. We have exposed it as we found it a workaround for TextView not doing its vertical size allocation until after the current signal handlers have run.

      Returns:
        `true` if `Gtk.mainQuit()` was called inside the inner-most main loop.
      Since:
        4.0.19

    - #### mainQuit

          public static void mainQuit()

      Exit the main loop. Since main loops can be nested, this does not necessarily imply application termination, but if you have a typical GTK program with a single call to `Gtk.main()` at the end of your Java `main()` function, then calling `Gtk.mainQuit()` in a signal handler somewhere will return the program flow to `main()` on your way exiting.
      Since:
        4.0.0

    - #### renderIcon

          public static Pixbuf renderIcon(Widget source,
                          Stock stock,
                          IconSize size)

      Lookup the Pixbuf corresponding to a stock icon of a certain size.

      You need to specify a Widget in order that the most correct theme engine and Style are employed to pick the appropriate image. This is redundant in most programs where we don't interfere with the theming or styling; just pass in your top level Window (or for that matter, any other Widget you have handy).

      Since:
        4.0.9

    - #### setDefaultIcon

          public static void setDefaultIcon(Pixbuf icon)

      Set the icon that will be used for all Windows in this application that do not have an one explicitly set. See the documentation for Window's `setIcon()` for further details about how to specify icons.
      Since:
        4.0.5

    - #### showURI

          public static boolean showURI(URI uri)

      Launch the user's preferred application to handle (display) the the supplied URI. This is most commonly used for raising URLs in the user's web browser, but the capability is more general than that; any URI conveying a MIME type that the desktop knows how to interpret will be handled.

      Typical examples for URIs understood by GNOME are:
      `file:///home/george/Desktop/image.png`
      `http://java-gnome.sourceforge.net/`
      `mailto:george@example.com`

      The launching will take appreciable real time, but this call does not block on the application being launched terminating. Think fork+exec.

      This function will return `true` if the call succeeds, and `false` otherwise.

      Since:
        4.0.9