1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
Incompatible Changes from GTK+-1.0 to GTK+-1.2:
* GtkAcceleratorTable has been replaced with GtkAccelGroup
* GtkMenuFactory has been replaced with GtkItemFactory, although
a version of GtkMenuFactory is provided to ease compatibility.
* 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 register
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) the new GtkDrawWindow widget.
* The ScrolledWindow widget no longer creates a Viewport
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.
Minor known incompatibilities:
- gtk_idle_remove_by_data() and gtk_timeout_remove_by_data() now
work from a common pool of "input sources", so
gtk_idle_remove_by_data() will remove timeouts and
vice-versa.
* 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:
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:
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(), then gtk_thread_init()
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 gtk_thread_enter()/gtk_thread_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.
- There is no longer a special --with-threads configure
option for GTK+. To use threads in a GTK+ program, you
must:
a) 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().
b) Link with the libraries returned by:
gtk-config --libs gthread
* All functions matching g_message* are deprecated
* Functions *_interp are deprecated, *_full variants are available
instead
|
