Glade FAQ

This is not a bug in Glade! In GTK+ you use containers to lay out your widgets. The commonly-used containers are at the bottom of the main page on the palette. Try adding a vertical box to a window in Glade. Now add a table to one of the positions in the vertical box. Do you get the idea now?

If you really want to position widgets at specific coordinates, try the Fixed container. However, this isn't recommended since your windows/dialogs will not look good when resized, and if you translate the text in the labels and buttons into other languages they may not fit.

Styles are not supported yet. You can, however, use standard GTK+ rc files to set the colours/fonts of your widgets. If you turn on the Set Widget Names project option in Glade, that may make it easier. See the Resource Files section of the documentation at developer.gnome.org/doc/API/gtk/index.html.

(I have actually taken out the unfinished styles code in 0.5.2 so hopefully no one will ask me this ever again!)

Create a button and select Remove Label from the popup menu. You can then add any widgets you like to the button, e.g. a horizontal box with a pixmap and a label inside it. (Glade may make this even easier in future.)

Hold the 'Control' key when you select the widget in the Palette. It will then stay selected until you select another widget or the Selector.

You can safely ignore this warning. It is output by GTK+ to remind people to update their code, since the behaviour of scrolled windows changed quite a bit between GTK+ 1.0 and GTK+ 1.2. But the Glade code is OK. The warning should not appear in your final application.

You need automake >= 1.4 & autoconf >= 2.13 to build the generated C code. You also need gettext >= 0.10.35 if you enabled gettext support. See the Requirements section in the README file for links to these.

Run ./autogen.sh in the toplevel directory of the project to run automake, autoconf and the related utilities to build the Makefile's. Pass it any options you want passed to configure, e.g. ./autogen.sh --prefix /usr/local/gnome.

Then run make to build your application.

Note that for GNOME applications, you must also do a make install so that the pixmaps are installed properly. If you don't do that, it will still run, but you won't see the pixmaps.

This means that the gtk.m4 file cannot be found. (gtk.m4 is a set of m4 macros which is installed as part of GTK+ and is used to build programs which use GTK+.) aclocal (part of automake) searches for these macros to add to aclocal.m4 in your program's root directory.

To find out where GTK+ is installed, run gtk-config --prefix. The gtk.m4 file should be in the share/aclocal subdirectory. To find out the directory that aclocal is using, run aclocal --print-ac-dir.

You should add the directory that the GTK+ m4 file is installed to the ACLOCAL_FLAGS environment variable, e.g. if the GTK+ m4 files are in /usr/local/share/aclocal, then add this to your $HOME/.profile: export ACLOCAL_FLAGS="-I /usr/local/share/aclocal/".

You are trying to use Gnome stock menu items in a GTK+-only app. Edit any menus you have and make sure the "Stock" property is set to "None" for every item.

These are the default output files, but some of your file names may differ if you have changed the project options.

If gettext support is enable, the po directory is created, with POTFILES.in and a separate ChangeLog. POTFILES.in lists the source files which contain translatable strings, and you should add any source files you create here.

For GNOME projects the macros directory is also added, containing all the m4 macros used to build the project. (These should really have been installed as part of GNOME, but unfortunately this wasn't done in GNOME 1.0.X. Hopefully this will be fixed in a future version of GNOME, and so this directory will not be needed.)

Changing the GNOME and Gettext Support Options

If you change the Gnome Support or Gettext Support project options after building the project, you will need to update some of the build files such as configure.in and Makefile.am. The best solution may be to change the project directory in the Project Options dialog, and to rebuild the project from scratch. However, you would have to copy over any code you have added to signal handlers. An alternative would be to delete autogen.sh, configure.in, Makefile.am, src/Makefile.am, and src/main.c and use Glade to recreate them. But if you have changed these files you will need to add the changes back in. (Hopefully Glade will deal with this better in future.)

Glade will not overwrite most of the files. It will recreate the build files if they don't exist (and the corresponding project option is set.)

The files which Glade overwrites are: interface.h, interface.c, support.h, and support.c. (Though you may have named them differently in your project, if you changed them in the Project Options dialog.)

These files all have a warning at the top saying "DO NOT EDIT".

If you have added or updated any signal handlers, then these are appended to the callbacks.h and callbacks.c files. So any code you have already added for callbacks is completely safe! If you have renamed a handler function then it is up to you to remove the old version and copy any code to the new function.

Add the source file (and any header file) to src/Makefile.am, in the project1_SOURCES variable (where project1 is the name of your project).

If you are using gettext, you may also want to add the source file to po/POTFILES.in so that the strings can be translated.

Use the lookup_widget() function provided. (It can be found in support.c.)

You pass it a pointer to any widget in a window, and the name of the widget that you want to get. Usually in signal handlers you can use the first argument to the signal handler as the first parameter to lookup_widget(), e.g.

void
on_button1_clicked                     (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *entry1;

  entry1 = lookup_widget (GTK_WIDGET (button), "entry1");

  ...
}
      

Call gtk_menu_get_active() with the GtkOptionMenu's menu to get the currently selected menu item. You can use g_list_index() to find its index in the menu:

void
on_button1_clicked                     (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *option_menu, *menu, *active_item;
  gint active_index;

  option_menu = lookup_widget (GTK_WIDGET (button), "optionmenu1");
  menu = GTK_OPTION_MENU (option_menu)->menu;
  active_item = gtk_menu_get_active (GTK_MENU (menu));
  active_index = g_list_index (GTK_MENU_SHELL (menu)->children, active_item);

  g_print ("Active index: %i\n", active_index);
}

Glade doesn't support this at present, but you can set it up manually.

When you create the window, get the option menu and connect to the "deactivate" signal emitted by its menu:

  window1 = create_window1 ();
  option_menu = lookup_widget (window1, "optionmenu1");
  gtk_signal_connect (GTK_OBJECT (GTK_OPTION_MENU (option_menu)->menu),
                      "deactivate", GTK_SIGNAL_FUNC (on_option_selected),
                      NULL);

Then add a handler to callbacks.c. You can get the index of the selected item just like the previous answer:

static void
on_option_selected (GtkMenuShell *menu_shell,
                    gpointer data)
{
  GtkWidget *active_item;
  gint item_index;

  active_item = gtk_menu_get_active (GTK_MENU (menu_shell));
  item_index = g_list_index (menu_shell->children, active_item);

  g_print ("In on_option_selected active: %i\n", item_index);
}

Glade doesn't support this at present, but you can set it up manually, in a similar way to question 3.6.

When you create the window, get a pointer to the widget containing the adjustment, and connect to the "changed" or "value_changed" signals:

  window1 = create_window1 ();
  hscale = lookup_widget (window1, "hscale1");
  gtk_signal_connect (GTK_OBJECT (GTK_RANGE (hscale)->adjustment),
                      "changed", GTK_SIGNAL_FUNC (on_adjustment_changed),
                      NULL);