gtk_tut.txt

gtk是linux一款强大的夸平台的图形化开发工具

  /* example-start helloworld2 helloworld2.c */

  #include <gtk/gtk.h>

  /* Our new improved callback.  The data passed to this function
   * is printed to stdout. */
  void callback( GtkWidget *widget,
                 gpointer   data )
  {
      g_print ("Hello again - %s was pressed\n", (char *) data);
  }

  /* another callback */
  void delete_event( GtkWidget *widget,
                     GdkEvent  *event,
                     gpointer   data )
  {
      gtk_main_quit ();
  }

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

      /* 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);

      /* This is a new call, this just sets the title of our
       * new window to "Hello Buttons!" */
      gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");

      /* Here we just set a handler for delete_event that immediately
       * exits GTK. */
      gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                          GTK_SIGNAL_FUNC (delete_event), NULL);

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

      /* We create a box to pack widgets into.  This is described in detail
       * in the "packing" section. The box is not really visible, it
       * is just used as a tool to arrange widgets. */
      box1 = gtk_hbox_new(FALSE, 0);

      /* Put the box into the main window. */
      gtk_container_add (GTK_CONTAINER (window), box1);

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

      /* Now when the button is clicked, we call the "callback" function
       * with a pointer to "button 1" as its argument */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");

      /* Instead of gtk_container_add, we pack this button into the invisible
       * box, which has been packed into the window. */
      gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
      /* Always remember this step, this tells GTK that our preparation for
       * this button is complete, and it can now be displayed. */
      gtk_widget_show(button);

      /* Do these same steps again to create a second button */
      button = gtk_button_new_with_label ("Button 2");

      /* Call the same callback function with a different argument,
       * passing a pointer to "button 2" instead. */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");

      gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);

      /* The order in which we show the buttons is not really important, but I
       * recommend showing the window last, so it all pops up at once. */
      gtk_widget_show(button);

      gtk_widget_show(box1);

      gtk_widget_show (window);

      /* Rest in gtk_main and wait for the fun to begin! */
      gtk_main ();

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




  Compile this program using the same linking arguments as our first
  example.  You'll notice this time there is no easy way to exit the
  program, you have to use your window manager or command line to kill
  it. A good exercise for the reader would be to insert a third "Quit"
  button that will exit the program. You may also wish to play with the
  options to gtk_box_pack_start() while reading the next section.  Try
  resizing the window, and observe the behavior.

  Just as a side note, there is another useful define for
  gtk_window_new() - GTK_WINDOW_DIALOG. This interacts with the window
  manager a little differently and should be used for transient windows.


  44..  PPaacckkiinngg WWiiddggeettss

  When creating an application, you'll want to put more than one widget
  inside a window. Our first _h_e_l_l_o_w_o_r_l_d example only used one widget so
  we could simply use a gtk_container_add call to "pack" the widget into
  the window. But when you want to put more than one widget into a
  window, how do you control where that widget is positioned?  This is
  where packing comes in.


  44..11..  TThheeoorryy ooff PPaacckkiinngg BBooxxeess

  Most packing is done by creating boxes as in the example above. These
  are invisible widget containers that we can pack our widgets into
  which come in two forms, a horizontal box, and a vertical box. When
  packing widgets into a horizontal box, the objects are inserted
  horizontally from left to right or right to left depending on the call
  used. In a vertical box, widgets are packed from top to bottom or vice
  versa. You may use any combination of boxes inside or beside other
  boxes to create the desired effect.

  To create a new horizontal box, we use a call to gtk_hbox_new(), and
  for vertical boxes, gtk_vbox_new().The gtk_box_pack_start() and
  gtk_box_pack_end() functions are used to place objects inside of these
  containers. The gtk_box_pack_start() function will start at the top
  and work its way down in a vbox, and pack left to right in an hbox.
  gtk_box_pack_end() will do the opposite, packing from bottom to top in
  a vbox, and right to left in an hbox. Using these functions allow us
  to right justify or left justify our widgets and may be mixed in any
  way to achieve the desired effect. We will use gtk_box_pack_start() in
  most of our examples. An object may be another container or a widget.
  In fact, many widgets are actually containers themselves, including
  the button, but we usually only use a label inside a button.

  By using these calls, GTK knows where you want to place your widgets
  so it can do automatic resizing and other nifty things. There's also a
  number of options as to how your widgets should be packed. As you can
  imagine, this method gives us a quite a bit of flexibility when
  placing and creating widgets.


  44..22..  DDeettaaiillss ooff BBooxxeess

  Because of this flexibility, packing boxes in GTK can be confusing at
  first. There are a lot of options, and it's not immediately obvious
  how they all fit together. In the end however, there are basically
  five different styles.

  <CENTER > <IMG SRC="gtk_tut_packbox1.gif" VSPACE="15" HSPACE="10"
  WIDTH="528" HEIGHT="235" ALT="Box Packing Example Image" > </CENTER >

  Each line contains one horizontal box (hbox) with several buttons. The
  call to gtk_box_pack is shorthand for the call to pack each of the
  buttons into the hbox. Each of the buttons is packed into the hbox the
  same way (i.e. same arguments to the gtk_box_pack_start() function).

  This is the declaration of the gtk_box_pack_start function.



       void gtk_box_pack_start( GtkBox    *box,
                                GtkWidget *child,
                                gint       expand,
                                gint       fill,
                                gint       padding );




  The first argument is the box you are packing the object into, the
  second is the object. The objects will all be buttons for now, so
  we'll be packing buttons into boxes.

  The expand argument to gtk_box_pack_start() and gtk_box_pack_end()
  controls whether the widgets are laid out in the box to fill in all
  the extra space in the box so the box is expanded to fill the area
  alloted to it (TRUE).  Or the box is shrunk to just fit the widgets
  (FALSE). Setting expand to FALSE will allow you to do right and left
  justification of your widgets.  Otherwise, they will all expand to fit
  into the box, and the same effect could be achieved by using only one
  of gtk_box_pack_start or gtk_box_pack_end.

  The fill argument to the gtk_box_pack functions control whether the
  extra space is allocated to the objects themselves (TRUE), or as extra
  padding in the box around these objects (FALSE). It only has an effect
  if the expand argument is also TRUE.

  When creating a new box, the function looks like this:



       GtkWidget *gtk_hbox_new (gint homogeneous,
                                gint spacing);




  The homogeneous argument to gtk_hbox_new (and the same for
  gtk_vbox_new) controls whether each object in the box has the same
  size (i.e. the same width in an hbox, or the same height in a vbox).
  If it is set, the expand argument to the gtk_box_pack routines is
  always turned on.

  What's the difference between spacing (set when the box is created)
  and padding (set when elements are packed)? Spacing is added between
  objects, and padding is added on either side of an object. The
  following figure should make it clearer:

  <CENTER > <IMG ALIGN="center" SRC="gtk_tut_packbox2.gif" WIDTH="509"
  HEIGHT="213" VSPACE="15" HSPACE="10" ALT="Box Packing Example Image" >
  </CENTER >

  Here is the code used to create the above images. I've commented it
  fairly heavily so hopefully you won't have any problems following it.
  Compile it yourself and play with it.


  44..33..  PPaacckkiinngg DDeemmoonnssttrraattiioonn PPrrooggrraamm



































  /* example-start packbox packbox.c */

  #include <stdio.h>
  #include "gtk/gtk.h"

  void delete_event( GtkWidget *widget,
                     GdkEvent  *event,
                     gpointer   data )
  {
      gtk_main_quit ();
  }

  /* Make a new hbox filled with button-labels. Arguments for the
   * variables we're interested are passed in to this function.
   * We do not show the box, but do show everything inside. */
  GtkWidget *make_box( gint homogeneous,
                       gint spacing,
                       gint expand,
                       gint fill,
                       gint padding )
  {
      GtkWidget *box;
      GtkWidget *button;
      char padstr[80];

      /* Create a new hbox with the appropriate homogeneous
       * and spacing settings */
      box = gtk_hbox_new (homogeneous, spacing);

      /* Create a series of buttons with the appropriate settings */
      button = gtk_button_new_with_label ("gtk_box_pack");
      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      button = gtk_button_new_with_label ("(box,");
      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      button = gtk_button_new_with_label ("button,");
      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      /* Create a button with the label depending on the value of
       * expand. */
      if (expand == TRUE)
              button = gtk_button_new_with_label ("TRUE,");
      else
              button = gtk_button_new_with_label ("FALSE,");

      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      /* This is the same as the button creation for "expand"
       * above, but uses the shorthand form. */
      button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      sprintf (padstr, "%d);", padding);

      button = gtk_button_new_with_label (padstr);
      gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
      gtk_widget_show (button);

      return box;
  }
  int main( int   argc,
            char *argv[])
  {
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *box1;
      GtkWidget *box2;
      GtkWidget *separator;
      GtkWidget *label;
      GtkWidget *quitbox;
      int which;

      /* Our init, don't forget this! :) */
      gtk_init (&argc, &argv);

      if (argc != 2) {
          fprintf (stderr, "usage: packbox num, where num is 1, 2, or 3.\n");
          /* This just does cleanup in GTK and exits with an exit status of 1. */
          gtk_exit (1);
      }

      which = atoi (argv[1]);

      /* Create our window */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      /* You should always remember to connect the destroy signal to the
       * main window. This is very important for proper intuitive
       * behavior */
      gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                          GTK_SIGNAL_FUNC (delete_event), NULL);
      gtk_container_set_border_width (GTK_CONTAINER (window), 10);

      /* We create a vertical box (vbox) to pack the horizontal boxes into.
       * This allows us to stack the horizontal boxes filled with buttons one
       * on top of the other in this vbox. */
      box1 = gtk_vbox_new (FALSE, 0);

      /* which example to show. These correspond to the pictures above. */
      switch (which) {
      case 1:
          /* create a new label. */
          label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");

          /* Align the label to the left side.  We'll discuss this function and
           * others in the section on Widget Attributes. */
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);

          /* Pack the label into the vertical box (vbox box1).  Remember that
           * widgets added to a vbox will be packed one on top of the other in
           * order. */
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);

          /* Show the label */
          gtk_widget_show (label);

          /* Call our make box function - homogeneous = FALSE, spacing = 0,
           * expand = FALSE, fill = FALSE, padding = 0 */
          box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Call our make box function - homogeneous = FALSE, spacing = 0,
           * expand = FALSE, fill = FALSE, padding = 0 */
          box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Args are: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);