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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/*
* Miscellaneous GTK helper functions.
*/
#include <assert.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>
#include <gtk/gtk.h>
#if !GTK_CHECK_VERSION(3,0,0)
#include <gdk/gdkkeysyms.h>
#endif
#include "putty.h"
#include "gtkcompat.h"
#ifndef NOT_X_WINDOWS
#include <gdk/gdkx.h>
#include <X11/Xlib.h>
#endif
void get_label_text_dimensions(const char *text, int *width, int *height)
{
/*
* Determine the dimensions of a piece of text in the standard
* font used in GTK interface elements like labels. We do this by
* instantiating an actual GtkLabel, and then querying its size.
*
* But GTK2 and GTK3 require us to query the size completely
* differently. I'm sure there ought to be an easier approach than
* the way I'm doing this in GTK3, too!
*/
GtkWidget *label = gtk_label_new(text);
#if GTK_CHECK_VERSION(3,0,0)
PangoLayout *layout = gtk_label_get_layout(GTK_LABEL(label));
PangoRectangle logrect;
pango_layout_get_extents(layout, NULL, &logrect);
if (width)
*width = logrect.width / PANGO_SCALE;
if (height)
*height = logrect.height / PANGO_SCALE;
#else
GtkRequisition req;
gtk_widget_size_request(label, &req);
if (width)
*width = req.width;
if (height)
*height = req.height;
#endif
g_object_ref_sink(G_OBJECT(label));
#if GTK_CHECK_VERSION(2,10,0)
g_object_unref(label);
#endif
}
int string_width(const char *text)
{
int ret;
get_label_text_dimensions(text, &ret, NULL);
return ret;
}
void align_label_left(GtkLabel *label)
{
#if GTK_CHECK_VERSION(3,16,0)
gtk_label_set_xalign(label, 0.0);
#elif GTK_CHECK_VERSION(3,14,0)
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
#else
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
#endif
}
/* ----------------------------------------------------------------------
* Functions to arrange controls in a basically dialog-like window.
*
* The best method for doing this has varied wildly with versions of
* GTK, hence the set of wrapper functions here.
*
* In GTK 1, a GtkDialog has an 'action_area' at the bottom, which is
* a GtkHBox which stretches to cover the full width of the dialog. So
* we can either add buttons or other widgets to that box directly, or
* alternatively we can fill the hbox with some layout class of our
* own such as a Columns widget.
*
* In GTK 2, the action area has become a GtkHButtonBox, and its
* layout behaviour seems to be different and not what we want. So
* instead we abandon the dialog's action area completely: we
* gtk_widget_hide() it in the below code, and we also call
* gtk_dialog_set_has_separator() to remove the separator above it. We
* then insert our own action area into the end of the dialog's main
* vbox, and add our own separator above that.
*
* In GTK 3, we typically don't even want to use GtkDialog at all,
* because GTK 3 has become a lot more restrictive about what you can
* sensibly use GtkDialog for - it deprecates direct access to the
* action area in favour of making you provide nothing but
* dialog-ending buttons in the form of (text, response code) pairs,
* so you can't put any other kind of control in there, or fiddle with
* alignment and positioning, or even have a button that _doesn't_ end
* the dialog (e.g. 'View Licence' in our About box). So instead of
* GtkDialog, we use a straight-up GtkWindow and have it contain a
* vbox as its (unique) child widget; and we implement the action area
* by adding a separator and another widget at the bottom of that
* vbox.
*/
GtkWidget *our_dialog_new(void)
{
#if GTK_CHECK_VERSION(3,0,0)
/*
* See comment in our_dialog_set_action_area(): in GTK 3, we use
* GtkWindow in place of GtkDialog for most purposes.
*/
GtkWidget *w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add(GTK_CONTAINER(w), vbox);
gtk_widget_show(vbox);
return w;
#else
return gtk_dialog_new();
#endif
}
void our_dialog_set_action_area(GtkWindow *dlg, GtkWidget *w)
{
#if !GTK_CHECK_VERSION(2,0,0)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area),
w, true, true, 0);
#elif !GTK_CHECK_VERSION(3,0,0)
GtkWidget *align;
align = gtk_alignment_new(0, 0, 1, 1);
gtk_container_add(GTK_CONTAINER(align), w);
/*
* The purpose of this GtkAlignment is to provide padding
* around the buttons. The padding we use is twice the padding
* used in our GtkColumns, because we nest two GtkColumns most
* of the time (one separating the tree view from the main
* controls, and another for the main controls themselves).
*/
#if GTK_CHECK_VERSION(2,4,0)
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 8, 8);
#endif
gtk_widget_show(align);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
align, false, true, 0);
w = gtk_hseparator_new();
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
w, false, true, 0);
gtk_widget_show(w);
gtk_widget_hide(gtk_dialog_get_action_area(GTK_DIALOG(dlg)));
g_object_set(G_OBJECT(dlg), "has-separator", true, (const char *)NULL);
#else /* GTK 3 */
/* GtkWindow is a GtkBin, hence contains exactly one child, which
* here we always expect to be a vbox */
GtkBox *vbox = GTK_BOX(gtk_bin_get_child(GTK_BIN(dlg)));
GtkWidget *sep;
g_object_set(G_OBJECT(w), "margin", 8, (const char *)NULL);
gtk_box_pack_end(vbox, w, false, true, 0);
sep = gtk_hseparator_new();
gtk_box_pack_end(vbox, sep, false, true, 0);
gtk_widget_show(sep);
#endif
}
GtkBox *our_dialog_make_action_hbox(GtkWindow *dlg)
{
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
our_dialog_set_action_area(dlg, hbox);
g_object_set(G_OBJECT(hbox), "margin", 0, (const char *)NULL);
g_object_set(G_OBJECT(hbox), "spacing", 8, (const char *)NULL);
gtk_widget_show(hbox);
return GTK_BOX(hbox);
#else /* not GTK 3 */
return GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dlg)));
#endif
}
void our_dialog_add_to_content_area(GtkWindow *dlg, GtkWidget *w,
bool expand, bool fill, guint padding)
{
#if GTK_CHECK_VERSION(3,0,0)
/* GtkWindow is a GtkBin, hence contains exactly one child, which
* here we always expect to be a vbox */
GtkBox *vbox = GTK_BOX(gtk_bin_get_child(GTK_BIN(dlg)));
gtk_box_pack_start(vbox, w, expand, fill, padding);
#else
gtk_box_pack_start
(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))),
w, expand, fill, padding);
#endif
}
char *buildinfo_gtk_version(void)
{
return dupprintf("%d.%d.%d",
GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
}
#ifndef NOT_X_WINDOWS
Display *get_x11_display(void)
{
#if GTK_CHECK_VERSION(3,0,0)
if (!GDK_IS_X11_DISPLAY(gdk_display_get_default()))
return NULL;
#endif
return GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
}
#endif
|