gtk_tut.txt

来自「gtk1.2的教程」· 文本 代码 · 共 2,235 行 · 第 1/5 页

  /* example-start base base.c */

  #include <gtk/gtk.h>

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

      gtk_init (&argc, &argv);

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_widget_show  (window);

      gtk_main ();

      return(0);
  }
  /* example-end */




  You can compile the above program with gcc using:


       gcc base.c -o base `gtk-config --cflags --libs`




  The meaning of the unusual compilation options is explained below in
  ``Compiling Hello World''.

  All programs will of course include gtk/gtk.h which declares the
  variables, functions, structures, etc. that will be used in your GTK
  application.

  The next line:



       gtk_init (&argc, &argv);




  calls the function gtk_init(gint *argc, gchar ***argv) which will be
  called in all GTK applications. This sets up a few things for us such
  as the default visual and color map and then proceeds to call
  gdk_init(gint *argc, gchar ***argv). This function initializes the
  library for use, sets up default signal handlers, and checks the
  arguments passed to your application on the command line, looking for
  one of the following:


  o  --gtk-module

  o  --g-fatal-warnings

  o  --gtk-debug

  o  --gtk-no-debug

  o  --gdk-debug

  o  --gdk-no-debug

  o  --display

  o  --sync

  o  --no-xshm

  o  --name

  o  --class

  It removes these from the argument list, leaving anything it does not
  recognize for your application to parse or ignore. This creates a set
  of standard arguments accepted by all GTK applications.

  The next two lines of code create and display a window.



         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
         gtk_widget_show (window);




  The GTK_WINDOW_TOPLEVEL argument specifies that we want the window to
  undergo window manager decoration and placement. Rather than create a
  window of 0x0 size, a window without children is set to 200x200 by
  default so you can still manipulate it.

  The gtk_widget_show() function lets GTK know that we are done setting
  the attributes of this widget, and that it can display it.

  The last line enters the GTK main processing loop.



         gtk_main ();




  gtk_main() is another call you will see in every GTK application.
  When control reaches this point, GTK will sleep waiting for X events
  (such as button or key presses), timeouts, or file IO notifications to
  occur. In our simple example, however, events are ignored.


  2.1.  Hello World in GTK

  Now for a program with a widget (a button).  It's the classic hello
  world a la GTK.













  /* example-start helloworld helloworld.c */

  #include <gtk/gtk.h>

  /* This is a callback function. The data arguments are ignored
   * in this example. More on callbacks below. */
  void hello( GtkWidget *widget,
              gpointer   data )
  {
      g_print ("Hello World\n");
  }

  gint delete_event( GtkWidget *widget,
                     GdkEvent  *event,
                     gpointer   data )
  {
      /* If you return FALSE in the "delete_event" signal handler,
       * GTK will emit the "destroy" signal. Returning TRUE means
       * you don't want the window to be destroyed.
       * This is useful for popping up 'are you sure you want to quit?'
       * type dialogs. */

      g_print ("delete event occurred\n");

      /* Change TRUE to FALSE and the main window will be destroyed with
       * a "delete_event". */

      return(TRUE);
  }

  /* Another callback */
  void destroy( GtkWidget *widget,
                gpointer   data )
  {
      gtk_main_quit();
  }

  int main( int   argc,
            char *argv[] )
  {
      /* GtkWidget is the storage type for widgets */
      GtkWidget *window;
      GtkWidget *button;

      /* This is called in all GTK applications. Arguments are parsed
       * from the command line and are returned to the application. */
      gtk_init(&argc, &argv);

      /* create a new window */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      /* When the window is given the "delete_event" signal (this is given
       * by the window manager, usually by the "close" option, or on the
       * titlebar), we ask it to call the delete_event () function
       * as defined above. The data passed to the callback
       * function is NULL and is ignored in the callback function. */
      gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                          GTK_SIGNAL_FUNC (delete_event), NULL);

      /* Here we connect the "destroy" event to a signal handler.
       * This event occurs when we call gtk_widget_destroy() on the window,
       * or if we return FALSE in the "delete_event" callback. */
      gtk_signal_connect (GTK_OBJECT (window), "destroy",
                          GTK_SIGNAL_FUNC (destroy), NULL);

      /* Sets the border width of the window. */
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);

      /* Creates a new button with the label "Hello World". */
      button = gtk_button_new_with_label ("Hello World");

      /* When the button receives the "clicked" signal, it will call the
       * function hello() passing it NULL as its argument.  The hello()
       * function is defined above. */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (hello), NULL);

      /* This will cause the window to be destroyed by calling
       * gtk_widget_destroy(window) when "clicked".  Again, the destroy
       * signal could come from here, or the window manager. */
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                                 GTK_SIGNAL_FUNC (gtk_widget_destroy),
                                 GTK_OBJECT (window));

      /* This packs the button into the window (a gtk container). */
      gtk_container_add (GTK_CONTAINER (window), button);

      /* The final step is to display this newly created widget. */
      gtk_widget_show (button);

      /* and the window */
      gtk_widget_show (window);

      /* All GTK applications must have a gtk_main(). Control ends here
       * and waits for an event to occur (like a key press or
       * mouse event). */
      gtk_main ();

      return(0);
  }
  /* example-end */





  2.2.  Compiling Hello World

  To compile use:



       gcc -Wall -g helloworld.c -o helloworld `gtk-config --cflags` \
           `gtk-config --libs`




  This uses the program gtk-config, which comes with GTK. This program
  "knows" what compiler switches are needed to compile programs that use
  GTK. gtk-config --cflags will output a list of include directories for
  the compiler to look in, and gtk-config --libs will output the list of
  libraries for the compiler to link with and the directories to find
  them in. In the above example they could have been combined into a
  single instance, such as `gtk-config --cflags --libs`.

  Note that the type of single quote used in the compile command above
  is significant.

  The libraries that are usually linked in are:


  o  The GTK library (-lgtk), the widget library, based on top of GDK.

  o  The GDK library (-lgdk), the Xlib wrapper.

  o  The gmodule library (-lgmodule), which is used to load run time
     extensions.

  o  The GLib library (-lglib), containing miscellaneous functions; only
     g_print() is used in this particular example. GTK is built on top
     of glib so you will always require this library. See the section on
     ``GLib'' for details.

  o  The Xlib library (-lX11) which is used by GDK.

  o  The Xext library (-lXext). This contains code for shared memory
     pixmaps and other X extensions.

  o  The math library (-lm). This is used by GTK for various purposes.


  2.3.  Theory of Signals and Callbacks

  Before we look in detail at helloworld, we'll discuss signals and
  callbacks. GTK is an event driven toolkit, which means it will sleep
  in gtk_main until an event occurs and control is passed to the
  appropriate function.

  This passing of control is done using the idea of "signals". (Note
  that these signals are not the same as the Unix system signals, and
  are not implemented using them, although the terminology is almost
  identical.) When an event occurs, such as the press of a mouse button,
  the appropriate signal will be "emitted" by the widget that was
  pressed.  This is how GTK does most of its useful work. There are
  signals that all widgets inherit, such as "destroy", and there are
  signals that are widget specific, such as "toggled" on a toggle
  button.

  To make a button perform an action, we set up a signal handler to
  catch these signals and call the appropriate function. This is done by
  using a function such as:



       gint gtk_signal_connect( GtkObject     *object,
                                gchar         *name,
                                GtkSignalFunc  func,
                                gpointer       func_data );




  where the first argument is the widget which will be emitting the
  signal, and the second the name of the signal you wish to catch. The
  third is the function you wish to be called when it is caught, and the
  fourth, the data you wish to have passed to this function.

  The function specified in the third argument is called a "callback
  function", and should generally be of the form



       void callback_func( GtkWidget *widget,
                           gpointer   callback_data );



  where the first argument will be a pointer to the widget that emitted
  the signal, and the second a pointer to the data given as the last
  argument to the gtk_signal_connect() function as shown above.

  Note that the above form for a signal callback function declaration is
  only a general guide, as some widget specific signals generate
  different calling parameters. For example, the CList "select_row"
  signal provides both row and column parameters.

  Another call used in the helloworld example, is:



       gint gtk_signal_connect_object( GtkObject     *object,
                                       gchar         *name,
                                       GtkSignalFunc  func,
                                       GtkObject     *slot_object );




  gtk_signal_connect_object() is the same as gtk_signal_connect() except
  that the callback function only uses one argument, a pointer to a GTK
  object. So when using this function to connect signals, the callback
  should be of the form



       void callback_func( GtkObject *object );




  where the object is usually a widget. We usually don't setup callbacks
  for gtk_signal_connect_object however. They are usually used to call a
  GTK function that accepts a single widget or object as an argument, as
  is the case in our helloworld example.

  The purpose of having two functions to connect signals is simply to
  allow the callbacks to have a different number of arguments. Many
  functions in the GTK library accept only a single GtkWidget pointer as
  an argument, so you want to use the gtk_signal_connect_object() for
  these, whereas for your functions, you may need to have additional
  data supplied to the callbacks.


  2.4.  Events

  In addition to the signal mechanism described above, there is a set of
  events that reflect the X event mechanism. Callbacks may also be
  attached to these events. These events are:


  o  event

  o  button_press_event

  o  button_release_event

  o  motion_notify_event

  o  delete_event

  o  destroy_event


  o  expose_event

  o  key_press_event

  o  key_release_event

  o  enter_notify_event

  o  leave_notify_event

  o  configure_event

  o  focus_in_event

  o  focus_out_event

  o  map_event

  o  unmap_event

  o  property_notify_event

  o  selection_clear_event

  o  selection_request_event

  o  selection_notify_event

  o  proximity_in_event

  o  proximity_out_event

  o  drag_begin_event

  o  drag_request_event