Debian Codegraph @

lib/gtk/font-manager-font-scale.c

raw
1 /* font-manager-font-scale.c
2 *
3 * Copyright (C) 2009-2023 Jerry Casiano
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program.
17 *
18 * If not, see <http://www.gnu.org/licenses/gpl-3.0.txt>.
19 */
20
21 #include "font-manager-font-scale.h"
22
23 /**
24 * SECTION: font-manager-font-scale
25 * @short_description: Font size selection widget
26 * @title: Font Scale
27 * @include: font-manager-font-scale.h
28 *
29 * Widget allowing for font size selection through use of a #GtkScale,
30 * #GtkSpinButton and two clickable #GtkLabel widgets for quick selection
31 * of minimum and maximum sizes.
32 */
33
34 #define DEFAULT_OPACITY 0.60
35 #define FOCUSED_OPACITY 0.95
36 #define MIN_FONT_SIZE FONT_MANAGER_MIN_FONT_SIZE
37 #define MAX_FONT_SIZE FONT_MANAGER_MAX_FONT_SIZE
38 #define MIN_LABEL "<span font=\"Serif Italic Bold\" size=\"small\"> A </span>"
39 #define MAX_LABEL "<span font=\"Serif Italic Bold\" size=\"large\"> A </span>"
40
41 #define N_ZOOM_SHORTCUTS 3
42
43 static const struct {
44 gint16 direction;
45 const gchar *accel;
46 } ZoomShortcuts [N_ZOOM_SHORTCUTS] = {
47 { -1, "<Ctrl>minus" },
48 { 0, "<Ctrl>0" },
49 { 1, "<Ctrl>plus|<Ctrl>equal" }
50 };
51
52 static void on_zoom (GtkWidget *widget, const gchar *action_name, GVariant *parameter);
53
54 struct _FontManagerFontScale
55 {
56 GtkWidget parent;
57
58 gdouble default_size;
59 GtkWidget *min;
60 GtkWidget *max;
61 GtkWidget *scale;
62 GtkWidget *spin;
63 GtkAdjustment *adjustment;
64 };
65
66 G_DEFINE_TYPE(FontManagerFontScale, font_manager_font_scale, GTK_TYPE_WIDGET)
67
68 enum
69 {
70 PROP_RESERVED,
71 PROP_ADJUSTMENT,
72 PROP_DEFAULT_SIZE,
73 PROP_VALUE,
74 N_PROPERTIES
75 };
76
77 static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
78
79 static void
80 font_manager_font_scale_dispose (GObject *gobject)
81 {
82 FontManagerFontScale *self = FONT_MANAGER_FONT_SCALE(gobject);
83 g_return_if_fail(self != NULL);
84 g_clear_object(&self->adjustment);
85 font_manager_widget_dispose(GTK_WIDGET(gobject));
86 G_OBJECT_CLASS(font_manager_font_scale_parent_class)->dispose(gobject);
87 return;
88 }
89
90 static void
91 font_manager_font_scale_get_property (GObject *gobject,
92 guint property_id,
93 GValue *value,
94 GParamSpec *pspec)
95 {
96 FontManagerFontScale *self = FONT_MANAGER_FONT_SCALE(gobject);
97 g_return_if_fail(self != NULL);
98 switch (property_id) {
99 case PROP_ADJUSTMENT:
100 g_value_set_object(value, font_manager_font_scale_get_adjustment(self));
101 break;
102 case PROP_DEFAULT_SIZE:
103 g_value_set_double(value, self->default_size);
104 break;
105 case PROP_VALUE:
106 g_value_set_double(value, font_manager_font_scale_get_value(self));
107 break;
108 default:
109 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
110 }
111 return;
112 }
113
114 static void
115 font_manager_font_scale_set_property (GObject *gobject,
116 guint property_id,
117 const GValue *value,
118 GParamSpec *pspec)
119 {
120 FontManagerFontScale *self = FONT_MANAGER_FONT_SCALE(gobject);
121 g_return_if_fail(self != NULL);
122 switch (property_id) {
123 case PROP_ADJUSTMENT:
124 font_manager_font_scale_set_adjustment(self, g_value_get_object(value));
125 break;
126 case PROP_DEFAULT_SIZE:
127 font_manager_font_scale_set_default_size(self, g_value_get_double(value));
128 break;
129 case PROP_VALUE:
130 font_manager_font_scale_set_value(self, g_value_get_double(value));
131 break;
132 default:
133 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
134 }
135 return;
136 }
137
138 static void
139 font_manager_font_scale_class_init (FontManagerFontScaleClass *klass)
140 {
141 GObjectClass *object_class = G_OBJECT_CLASS(klass);
142 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
143
144 object_class->dispose = font_manager_font_scale_dispose;
145 object_class->get_property = font_manager_font_scale_get_property;
146 object_class->set_property = font_manager_font_scale_set_property;
147 gtk_widget_class_set_layout_manager_type(widget_class, GTK_TYPE_BOX_LAYOUT);
148 gtk_widget_class_install_action(widget_class, "zoom", "n", on_zoom);
149
150 /**
151 * FontManagerFontScale:adjustment:
152 *
153 * The #GtkAdjustment in use.
154 */
155 obj_properties[PROP_ADJUSTMENT] = g_param_spec_object("adjustment",
156 NULL,
157 "#GtkAdjustment in use",
158 GTK_TYPE_ADJUSTMENT,
159 G_PARAM_STATIC_STRINGS |
160 G_PARAM_READWRITE |
161 G_PARAM_EXPLICIT_NOTIFY);
162
163 /**
164 * FontManagerFontScale:default-size:
165 *
166 * The default preview size of #FontManagerFontScale.
167 */
168 obj_properties[PROP_DEFAULT_SIZE] = g_param_spec_double("default-size",
169 NULL,
170 "Default preview size",
171 MIN_FONT_SIZE,
172 MAX_FONT_SIZE,
173 FONT_MANAGER_DEFAULT_PREVIEW_SIZE,
174 G_PARAM_STATIC_STRINGS |
175 G_PARAM_READWRITE |
176 G_PARAM_EXPLICIT_NOTIFY);
177
178 /**
179 * FontManagerFontScale:value:
180 *
181 * The current value of #FontManagerFontScale.
182 */
183 obj_properties[PROP_VALUE] = g_param_spec_double("value",
184 NULL,
185 "Current value",
186 MIN_FONT_SIZE,
187 MAX_FONT_SIZE,
188 FONT_MANAGER_DEFAULT_PREVIEW_SIZE,
189 G_PARAM_STATIC_STRINGS |
190 G_PARAM_READWRITE |
191 G_PARAM_EXPLICIT_NOTIFY);
192
193 g_object_class_install_properties(object_class, N_PROPERTIES, obj_properties);
194 return;
195
196 }
197
198 static void
199 on_zoom (GtkWidget *widget,
200 const gchar *action_name,
201 GVariant *parameter)
202 {
203 FontManagerFontScale *self = FONT_MANAGER_FONT_SCALE(widget);
204 gint16 direction = g_variant_get_int16(parameter);
205 gdouble step = 0.5;
206 gdouble current = gtk_adjustment_get_value(self->adjustment);
207 gdouble value = self->default_size;
208 if (direction != 0)
209 value = direction > 0 ? current + step : current - step;
210 value = CLAMP(value, MIN_FONT_SIZE, MAX_FONT_SIZE);
211 gtk_adjustment_set_value(self->adjustment, value);
212 return;
213 }
214
215 static void
216 on_click (GtkGestureClick *gesture,
217 gint n_press,
218 gdouble x,
219 gdouble y,
220 FontManagerFontScale *self)
221 {
222 g_return_if_fail(self != NULL);
223 GtkWidget *widget = gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(gesture));
224 gdouble new_value = (widget == self->min) ? MIN_FONT_SIZE : MAX_FONT_SIZE;
225 gtk_adjustment_set_value(self->adjustment, new_value);
226 return;
227 }
228
229 static void
230 on_state_change (GtkWidget *widget,
231 GtkStateFlags flags,
232 FontManagerFontScale *self)
233 {
234 gboolean active = gtk_window_is_active(GTK_WINDOW(gtk_widget_get_root(widget)));
235 gboolean prelight = ((flags & GTK_STATE_FLAG_PRELIGHT) == 0);
236 gdouble opacity = active && prelight ? FOCUSED_OPACITY : DEFAULT_OPACITY;
237 gtk_widget_set_opacity(widget, opacity);
238 return;
239 }
240
241 static void
242 on_value_changed (FontManagerFontScale *self, GtkAdjustment *adjustment)
243 {
244 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_VALUE]);
245 return;
246 }
247
248 static void
249 add_child_widget (FontManagerFontScale *self,
250 const gchar *name,
251 GtkWidget *widget)
252 {
253 gtk_widget_set_parent(widget, GTK_WIDGET(self));
254 gtk_widget_set_name(widget, name);
255 font_manager_widget_set_expand(widget, FALSE);
256 font_manager_widget_set_align(widget, GTK_ALIGN_CENTER);
257 font_manager_widget_set_margin(widget, FONT_MANAGER_DEFAULT_MARGIN);
258 return;
259 }
260
261 static void
262 add_click_target (FontManagerFontScale *self, GtkWidget *widget)
263 {
264 gtk_widget_set_can_focus(widget, TRUE);
265 gtk_widget_set_opacity(widget, DEFAULT_OPACITY);
266 g_signal_connect(widget, "state-flags-changed", G_CALLBACK(on_state_change), self);
267 GtkGesture *gesture = gtk_gesture_click_new();
268 gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(gesture), FALSE);
269 gtk_gesture_single_set_exclusive(GTK_GESTURE_SINGLE(gesture), TRUE);
270 gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(gesture), GDK_BUTTON_PRIMARY);
271 g_signal_connect(gesture, "pressed", G_CALLBACK(on_click), self);
272 gtk_event_controller_set_propagation_phase(GTK_EVENT_CONTROLLER(gesture),
273 GTK_PHASE_BUBBLE);
274 gtk_widget_add_controller(widget, GTK_EVENT_CONTROLLER(gesture));
275 return;
276 }
277
278 static void
279 font_manager_font_scale_init (FontManagerFontScale *self)
280 {
281 g_return_if_fail(self != NULL);
282 self->default_size = FONT_MANAGER_DEFAULT_PREVIEW_SIZE;
283 self->min = gtk_label_new(NULL);
284 self->max = gtk_label_new(NULL);
285 self->scale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, NULL);
286 self->spin = gtk_spin_button_new(NULL, 0.5, 1);
287 self->adjustment = gtk_adjustment_new(self->default_size,
288 MIN_FONT_SIZE,
289 MAX_FONT_SIZE,
290 0.5, 1.0, 0);
291 self->adjustment = g_object_ref_sink(self->adjustment);
292 font_manager_font_scale_set_adjustment(self, self->adjustment);
293 add_child_widget(self, "min", self->min);
294 add_child_widget(self, "scale", self->scale);
295 add_child_widget(self, "max", self->max);
296 add_child_widget(self, "spin", self->spin);
297 add_click_target(self, self->min);
298 add_click_target(self, self->max);
299 gtk_widget_set_focusable(self->scale, FALSE);
300 gtk_widget_set_focusable(self->spin, FALSE);
301 gtk_widget_set_hexpand(self->scale, TRUE);
302 gtk_widget_set_halign(self->scale, GTK_ALIGN_FILL);
303 gtk_scale_set_draw_value(GTK_SCALE(self->scale), FALSE);
304 gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(self->spin), TRUE);
305 gtk_label_set_markup(GTK_LABEL(self->min), MIN_LABEL);
306 gtk_label_set_markup(GTK_LABEL(self->max), MAX_LABEL);
307 gtk_widget_set_hexpand(GTK_WIDGET(self), TRUE);
308 gtk_widget_set_valign(GTK_WIDGET(self), GTK_ALIGN_END);
309 gtk_widget_add_css_class(GTK_WIDGET(self), FONT_MANAGER_STYLE_CLASS_VIEW);
310 font_manager_widget_set_name(GTK_WIDGET(self), "FontManagerFontScale");
311 GtkEventController *shortcuts = gtk_shortcut_controller_new();
312 gtk_event_controller_set_propagation_phase(shortcuts, GTK_PHASE_BUBBLE);
313 gtk_widget_add_controller(GTK_WIDGET(self), GTK_EVENT_CONTROLLER(shortcuts));
314 gtk_shortcut_controller_set_scope(GTK_SHORTCUT_CONTROLLER(shortcuts), GTK_SHORTCUT_SCOPE_GLOBAL);
315 for (gint i = 0; i < N_ZOOM_SHORTCUTS; i++) {
316 GtkShortcutAction *action = gtk_named_action_new("zoom");
317 GtkShortcutTrigger *trigger = gtk_shortcut_trigger_parse_string(ZoomShortcuts[i].accel);
318 GtkShortcut *shortcut = gtk_shortcut_new(trigger, action);
319 GVariant *args = g_variant_new_int16(ZoomShortcuts[i].direction);
320 gtk_shortcut_set_arguments(shortcut, args);
321 gtk_shortcut_controller_add_shortcut(GTK_SHORTCUT_CONTROLLER(shortcuts), shortcut);
322 }
323 return;
324 }
325
326 /**
327 * font_manager_font_scale_get_adjustment:
328 * @self: #FontManagerFontScale
329 *
330 * Returns: (transfer none) (nullable): The #GtkAdjustment currently in use or %NULL.
331 */
332 GtkAdjustment *
333 font_manager_font_scale_get_adjustment (FontManagerFontScale *self)
334 {
335 g_return_val_if_fail(self != NULL, NULL);
336 return self->adjustment;
337 }
338
339 /**
340 * font_manager_font_scale_get_value:
341 * @self: #FontManagerFontScale
342 *
343 * Returns: The current value.
344 */
345 gdouble
346 font_manager_font_scale_get_value (FontManagerFontScale *self)
347 {
348 g_return_val_if_fail(self != NULL && self->adjustment != NULL, -1);
349 return gtk_adjustment_get_value(self->adjustment);
350 }
351
352 /**
353 * font_manager_font_scale_set_adjustment:
354 * @self: #FontManagerFontScale
355 * @adjustment: #GtkAdjustment to use
356 */
357 void
358 font_manager_font_scale_set_adjustment (FontManagerFontScale *self,
359 GtkAdjustment *adjustment)
360 {
361 g_return_if_fail(self != NULL && adjustment != NULL);
362 if (g_set_object(&self->adjustment, adjustment))
363 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_ADJUSTMENT]);
364 gtk_range_set_adjustment(GTK_RANGE(self->scale), self->adjustment);
365 gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(self->spin), self->adjustment);
366 g_signal_connect_swapped(self->adjustment, "value-changed",
367 (GCallback) on_value_changed, self);
368 return;
369 }
370
371 /**
372 * font_manager_font_scale_set_default_size:
373 * @self: #FontManagerFontScale
374 * @value: #gdouble to use as default size for @self
375 *
376 * Sets the size used as default when a reset is requested using a keyboard
377 * shortcut i.e. &lt;Ctrl&gt;+0
378 */
379 void
380 font_manager_font_scale_set_default_size (FontManagerFontScale *self,
381 gdouble value)
382 {
383 self->default_size = value;
384 gdouble current_value = gtk_adjustment_get_value(self->adjustment);
385 gtk_adjustment_configure(self->adjustment,
386 current_value,
387 MIN_FONT_SIZE, MAX_FONT_SIZE,
388 0.5, 1.0, 0);
389 return;
390 }
391
392 /**
393 * font_manager_font_scale_set_value:
394 * @self: #FontManagerFontScale
395 * @value: New value
396 */
397 void
398 font_manager_font_scale_set_value (FontManagerFontScale *self, gdouble value)
399 {
400 g_return_if_fail(self != NULL && self->adjustment != NULL);
401 gtk_adjustment_set_value(self->adjustment,
402 CLAMP(value, MIN_FONT_SIZE, MAX_FONT_SIZE));
403 return;
404 }
405
406 /**
407 * font_manager_font_scale_new:
408 *
409 * Returns: (transfer full): A newly created #FontManagerFontScale.
410 * Free the returned object using #g_object_unref().
411 */
412 GtkWidget *
413 font_manager_font_scale_new (void)
414 {
415 return g_object_new(FONT_MANAGER_TYPE_FONT_SCALE, NULL);
416 }
417