## Changes from 1.0 to 1.2

Changes from 1.0 to 1.2 — Incompatible changes made between version 1.0 and version 1.2

## Incompatible changes from 1.0 to 1.2

- GtkAcceleratorTable has been replaced with GtkAccelGroup.

- GtkMenuFactory has been replaced with GtkItemFactory, although a version of GtkMenuFactory is currently still provided to ease the migration phase.

- The GtkTypeInfo structures used in the `gtk_*_type_init()` functions have changed a bit, the old format:

            GtkTypeInfo bin_info =
            {
              "GtkBin",
              sizeof (GtkBin),
              sizeof (GtkBinClass),
              (GtkClassInitFunc) gtk_bin_class_init,
              (GtkObjectInitFunc) gtk_bin_init,
              (GtkArgSetFunc) NULL,
              (GtkArgGetFunc) NULL,
            };

  needs to be converted to:

            static const GtkTypeInfo bin_info =
            {
              "GtkBin",
              sizeof (GtkBin),
              sizeof (GtkBinClass),
              (GtkClassInitFunc) gtk_bin_class_init,
              (GtkObjectInitFunc) gtk_bin_init,
              /* reserved_1 */ NULL,
              /* reserved_2 */ NULL,
              (GtkClassInitFunc) NULL,
            };

  the `GtkArgSetFunc` and `GtkArgGetFunc` functions are not supported from the type system anymore, and you should make sure that your code only fills in these fields with `NULL` and doesn't use the deprecated function typedefs `(GtkArgSetFunc)` and `(GtkArgGetFunc)` anymore.

- A number of GTK+ functions were renamed. For compatibility, `gtkcompat.h` #define's the old 1.0.x function names in terms of the new names. To assure your GTK+ program doesn't rely on outdated function variants, compile your program with `-DGTK_DISABLE_COMPAT_H` to disable the compatibility aliases. Here is the list of the old names and replacements:

  Old | Replacement
  --- | ---
  `gtk_accel_label_accelerator_width` | `gtk_accel_label_get_accel_width`
  `gtk_check_menu_item_set_state` | `gtk_check_menu_item_set_active`
  `gtk_container_border_width` | `gtk_container_set_border_width`
  `gtk_label_set` | `gtk_label_set_text`
  `gtk_notebook_current_page` | `gtk_notebook_get_current_page`
  `gtk_packer_configure` | `gtk_packer_set_child_packing`
  `gtk_paned_gutter_size` | `gtk_paned_set_gutter_size`
  `gtk_paned_handle_size` | `gtk_paned_set_handle_size`
  `gtk_scale_value_width` | `gtk_scale_get_value_width`
  `gtk_style_apply_default_pixmap` | `gtk_style_apply_default_background`
  `gtk_toggle_button_set_state` | `gtk_toggle_button_set_active`
  `gtk_window_position` | `gtk_window_set_position`

  Note that `gtk_style_apply_default_background()` has an additional argument, `set_bg`. This parameter should be `FALSE` if the background is being set for a `NO_WINDOW` widget, otherwise `TRUE`.

- During the development phase of the 1.1.x line of GTK+ certain functions were deprecated and later removed. Functions affected are:

  Removed | Replacement
  --- | ---
  `gtk_clist_set_border` | `gtk_clist_set_shadow_type`
  `gtk_container_block_resize` | `gtk_container_set_resize_mode`
  `gtk_container_unblock_resize` | `gtk_container_set_resize_mode`
  `gtk_container_need_resize` | `gtk_container_check_resize`
  `gtk_ctree_show_stub` | `gtk_ctree_set_show_stub`
  `gtk_ctree_set_reorderable` | `gtk_clist_set_reorderable`
  `gtk_ctree_set_use_drag_icons` | `gtk_clist_set_use_drag_icons`
  `gtk_entry_adjust_scroll` | `-`
  `gtk_object_class_add_user_signal` | `gtk_object_class_user_signal_new`
  `gtk_preview_put_row` | `gtk_preview_put`
  `gtk_progress_bar_construct` | `gtk_progress_set_adjustment`
  `gtk_scrolled_window_construct` | `gtk_scrolled_window_set_{h|v}adjustment`
  `gtk_spin_button_construct` | `gtk_spin_button_configure`
  `gtk_widget_thaw_accelerators` | `gtk_widget_unlock_accelerators`
  `gtk_widget_freeze_accelerators` | `gtk_widget_lock_accelerators`

  Note that `gtk_entry_adjust_scroll()` is no longer needed as GtkEntry should automatically keep the scroll adjusted properly.

- Additionally, all `gtk_*_interp()` functions were removed. `gtk_*_full()` versions were provided as of GTK+ 1.0 and should be used instead.

- GtkButton has been changed to derive from GtkBin. To access a button's child, use `GTK_BIN (button)->child`, instead of the old `GTK_BUTTON (button)->child`.

- The selection API has been slightly modified: `gtk_selection_add_handler()` and `gtk_selection_add_handler_full()` have been removed. To supply the selection, one now registers the targets one is interested in with:

        void gtk_selection_add_target (GtkWidget           *widget,
      	  	                 GdkAtom              selection,
      			         GdkAtom              target,
      			         guint                info);

  or:

        void gtk_selection_add_targets (GtkWidget           *widget,
      	  			  GdkAtom              selection,
      				  GtkTargetEntry      *targets,
      				  guint                ntargets);

  When a request for a selection is received, the new "selection_get" signal will be called:

         void  "selection_get"           (GtkWidget          *widget,
      				    GtkSelectionData   *selection_data,
      				    guint               info,
      				    guint               time);

  A "time" parameter has also been added to the "selection_received" signal.

        void  "selection_received"       (GtkWidget          *widget,
      				    GtkSelectionData   *selection_data,
      				    guint               time);

- The old drag and drop API has been completely removed and replaced. See the reference documentation for details on the new API.

- Support for Themes has been added. In general, this does not affect application code, however, a few new rules should be observed:

  - To set a shape for a window, you must use `gtk_widget_shape_combine_mask()` instead of `gdk_window_shape_combine_mask()`, or the shape will be reset when switching themes.

  - It is no longer permissable to draw directly on an arbitrary widget, or to set an arbitrary widget's background pixmap. If you need to do that, use a GtkDrawingArea or (for a toplevel) a GtkWindow where `gtk_widget_set_app_paintable()` has been called.

- The GtkScrolledWindow widget no longer creates a GtkViewport automatically. Instead, it has been generalized to accept any "self-scrolling" widget.

  The self-scrolling widgets in the GTK+ core are GtkViewport, GtkCList, GtkCTree, GtkText, and GtkLayout. All of these widgets can be added to a scrolled window as normal children with `gtk_container_add()` and scrollbars will be set up automatically.

  To add scrollbars to a non self-scrolling widget, (such as a GtkList), first add it to a viewport, then add the viewport to a scrolled window. The scrolled window code provides a convenience function to do this:

        void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrollwin,
      					      GtkWidget         *child);

  This does exactly what it says - it creates a viewport, adds the child widget to it, then adds the viewport to the scrolled window.

  The scrollbars have been removed from the GtkCList and GtkCTree, because they are now scrolled by simply adding them to a scrolled window. The scrollbar policy is set on the scrolled window with `gtk_scrolled_window_set_policy()` and not on the child widgets (e.g. GtkCList's `gtk_clist_set_policy()` was removed).

- The "main loop" of GTK+ has been moved to GLib. This should not affect existing programs, since compatibility functions have been provided. However, you may want to consider migrating your code to use the GLib main loop directly.

- the `GTK_BASIC` flag was removed, and with it the corresponding macro and function `GTK_WIDGET_BASIC()` and `gtk_widget_basic()`.

- All freeze/thaw methods are now recursive - that is, if you freeze a widget n times, you must also thaw it n times. Therefore, if you have code like:

      1
      2
      3
      4
      5
      6
      gboolean frozen;
      frozen = GTK_CLIST_FROZEN (clist);
      gtk_clist_freeze (clist);
      [...]
      if (!frozen)
        gtk_clist_thaw (clist);

  it will not work anymore. It must be, simply:

      1
      2
      3
      gtk_clist_freeze (clist);
      [...]
      gtk_clist_thaw (clist);

- The thread safety in GTK+ 1.2 is slightly different than that which appeared in early versions in the 1.1 development track. The main difference is that it relies on the thread primitives in GLib, and on the thread-safe GLib main loop.

  This means:

  - You must call `g_thread_init()` before executing any other GTK+ or GDK functions in a threaded GTK+ program.

  - Idles, timeouts, and input functions are executed outside of the main GTK+ lock. So, if you need to call GTK+ inside of such a callback, you must surround the callback with a `gdk_threads_enter()`/`gdk_threads_leave()` pair.

    However, signals are still executed within the main GTK+ lock.

    In particular, this means, if you are writing widgets that might be used in threaded programs, you must surround timeouts and idle functions in this matter.

    As always, you must also surround any calls to GTK+ not made within a signal handler with a `gdk_threads_enter()`/`gdk_threads_leave()` pair.

  - There is no longer a special `--with-threads` configure option for GTK+. To use threads in a GTK+ program, you must:

    1. If you want to use the native thread implementation, make sure GLib found this in configuration, otherwise, call you must provide a thread implementation to `g_thread_init()`.

    2. Link with the libraries returned by gtk-config --libs gthread and use the cflags from gtk-config --cflags gthread. You can get these `CFLAGS` and `LIBS` by passing `gthread` as the fourth parameter to the `AM_PATH_GTK` automake macro.

- Prior to GTK+ 1.2, there were two conflicting interpretations of `widget->requisition`. It was either taken to be the size that the widget requested, or that size modified by calls to `gtk_widget_set_usize()`. In GTK+ 1.2, it is always interpreted the first way.

  Container widgets are affected in two ways by this:

  1. Container widgets should not pass `widget->requisition` as the second parameter to `gtk_widget_size_request()`. Instead they should call it like:

                   GtkRequisition child_requisition;
                   gtk_widget_size_request (widget, &child_requisition);

  2. Container widgets should not access `child->requisition` directly. Either they should use the values returned by `gtk_widget_size_request()`, or they should call the new function:

             void gtk_widget_get_child_requisition (GtkWidget      *widget,
         					   GtkRequisition *requisition);

     which returns the requisition of the given widget, modified by calls to `gtk_widget_set_usize()`.