Debian Codegraph @

lib/gtk/font-manager-preview-page.c

raw
1 /* font-manager-preview-page.c
2 *
3 * Copyright (C) 2009-2025 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-preview-page.h"
22
23 /**
24 * SECTION: font-manager-preview-page
25 * @short_description: Full featured font preview widget
26 * @title: Preview Page
27 * @include: font-manager-preview-page.h
28 *
29 * This widget has three modes to allow previewing font files in various ways.
30 *
31 * The first mode provides an "active" preview where the user can edit the displayed text, set the
32 * size and justification. The second mode displays a standard "waterfall" preview of the selected
33 * font and the third mode displays several paragraphs of "Lorem Ipsum" text.
34 */
35
36 GType
37 font_manager_preview_page_mode_get_type (void)
38 {
39 static gsize g_define_type_id__volatile = 0;
40
41 if (g_once_init_enter (&g_define_type_id__volatile)) {
42 static const GEnumValue values[] = {
43 { FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW, "FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW", "preview" },
44 { FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL, "FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL", "waterfall" },
45 { FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM, "FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM", "lorem-ipsum" },
46 { 0, NULL, NULL }
47 };
48 GType g_define_type_id = g_enum_register_static (g_intern_static_string ("FontManagerPreviewPageMode"), values);
49 g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
50 }
51
52 return g_define_type_id__volatile;
53 }
54
55 /**
56 * font_manager_preview_page_mode_to_string:
57 * @mode: #FontManagerPreviewPageMode
58 *
59 * Returns: (transfer none) (nullable): @mode as a string
60 */
61 const gchar *
62 font_manager_preview_page_mode_to_string (FontManagerPreviewPageMode mode)
63 {
64 switch (mode) {
65 case FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW:
66 return "Preview";
67 case FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL:
68 return "Waterfall";
69 case FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM:
70 return "Lorem Ipsum";
71 default:
72 return NULL;
73 }
74 }
75
76 /**
77 * font_manager_preview_page_mode_to_translatable_string:
78 * @mode: #FontManagerPreviewPageMode
79 *
80 * Returns: (transfer none) (nullable): @mode as a localized string, if available.
81 */
82 const gchar *
83 font_manager_preview_page_mode_to_translatable_string (FontManagerPreviewPageMode mode)
84 {
85 switch (mode) {
86 case FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW:
87 return _("Preview");
88 case FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL:
89 return _("Waterfall");
90 case FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM:
91 return "Lorem Ipsum";
92 default:
93 return NULL;
94 }
95 }
96
97
98 #define MIN_FONT_SIZE FONT_MANAGER_MIN_FONT_SIZE
99 #define MAX_FONT_SIZE FONT_MANAGER_MAX_FONT_SIZE
100 #define DEFAULT_PREVIEW_SIZE FONT_MANAGER_DEFAULT_PREVIEW_SIZE
101 #define DEFAULT_WATERFALL_MAX_SIZE MAX_FONT_SIZE / 2
102
103 static void generate_waterfall_preview (FontManagerPreviewPage *self);
104
105 struct _FontManagerPreviewPage
106 {
107 GtkBox parent;
108
109 gchar *pangram;
110 gchar *default_pangram;
111 gchar *preview;
112 gchar *default_preview;
113 gchar *restore_preview;
114 GtkWidget *controls;
115 GtkWidget *fontscale;
116 GtkWidget *textview;
117 GtkWidget *menu_button;
118
119 gint line_spacing;
120 gdouble waterfall_size_ratio;
121 gdouble min_waterfall_size;
122 gdouble max_waterfall_size;
123 gdouble preview_size;
124 gboolean allow_edit;
125 gboolean show_line_size;
126 GtkJustification justification;
127 FontManagerPreviewPageMode mode;
128 FontManagerFont *font;
129 };
130
131 G_DEFINE_TYPE(FontManagerPreviewPage, font_manager_preview_page, GTK_TYPE_BOX)
132
133 enum
134 {
135 PROP_RESERVED,
136 PROP_PREVIEW_MODE,
137 PROP_PREVIEW_SIZE,
138 PROP_PREVIEW_TEXT,
139 PROP_FONT,
140 PROP_JUSTIFICATION,
141 PROP_WATERFALL_MIN,
142 PROP_WATERFALL_MAX,
143 PROP_WATERFALL_RATIO,
144 PROP_SHOW_LINE_SIZE,
145 PROP_LINE_SPACING,
146 N_PROPERTIES
147 };
148
149 static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
150
151 static void set_preview_mode_internal (FontManagerPreviewPage *self,
152 FontManagerPreviewPageMode mode);
153
154 static void
155 font_manager_preview_page_dispose (GObject *gobject)
156 {
157 g_return_if_fail(gobject != NULL);
158 FontManagerPreviewPage *self = FONT_MANAGER_PREVIEW_PAGE(gobject);
159 g_clear_pointer(&self->pangram, g_free);
160 g_clear_pointer(&self->default_pangram, g_free);
161 g_clear_pointer(&self->preview, g_free);
162 g_clear_pointer(&self->default_preview, g_free);
163 g_clear_pointer(&self->restore_preview, g_free);
164 g_clear_pointer(&self->font, g_object_unref);
165 g_clear_pointer(&self->menu_button, g_object_unref);
166 font_manager_widget_dispose(GTK_WIDGET(self));
167 G_OBJECT_CLASS(font_manager_preview_page_parent_class)->dispose(gobject);
168 return;
169 }
170
171 static void
172 font_manager_preview_page_get_property (GObject *gobject,
173 guint property_id,
174 GValue *value,
175 GParamSpec *pspec)
176 {
177 g_return_if_fail(gobject != NULL);
178 FontManagerPreviewPage *self = FONT_MANAGER_PREVIEW_PAGE(gobject);
179 switch (property_id) {
180 case PROP_PREVIEW_SIZE:
181 g_value_set_double(value, font_manager_preview_page_get_preview_size(self));
182 break;
183 case PROP_PREVIEW_MODE:
184 g_value_set_enum(value, font_manager_preview_page_get_preview_mode(self));
185 break;
186 case PROP_PREVIEW_TEXT:
187 g_value_set_string(value, self->preview);
188 break;
189 case PROP_FONT:
190 g_value_set_object(value, self->font);
191 break;
192 case PROP_JUSTIFICATION:
193 g_value_set_enum(value, (gint) font_manager_preview_page_get_justification(self));
194 break;
195 case PROP_WATERFALL_MIN:
196 g_value_set_double(value, self->min_waterfall_size);
197 break;
198 case PROP_WATERFALL_MAX:
199 g_value_set_double(value, self->max_waterfall_size);
200 break;
201 case PROP_WATERFALL_RATIO:
202 g_value_set_double(value, self->waterfall_size_ratio);
203 break;
204 case PROP_LINE_SPACING:
205 g_value_set_int(value, self->line_spacing);
206 break;
207 case PROP_SHOW_LINE_SIZE:
208 g_value_set_boolean(value, self->show_line_size);
209 break;
210 default:
211 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
212 }
213 return;
214 }
215
216 static void
217 font_manager_preview_page_set_property (GObject *gobject,
218 guint property_id,
219 const GValue *value,
220 GParamSpec *pspec)
221 {
222 g_return_if_fail(gobject != NULL);
223 FontManagerPreviewPage *self = FONT_MANAGER_PREVIEW_PAGE(gobject);
224 switch (property_id) {
225 case PROP_PREVIEW_SIZE:
226 font_manager_preview_page_set_preview_size(self, g_value_get_double(value));
227 break;
228 case PROP_PREVIEW_MODE:
229 font_manager_preview_page_set_preview_mode(self, g_value_get_enum(value));
230 break;
231 case PROP_PREVIEW_TEXT:
232 font_manager_preview_page_set_preview_text(self, g_value_get_string(value));
233 break;
234 case PROP_FONT:
235 font_manager_preview_page_set_font(self, g_value_get_object(value));
236 break;
237 case PROP_JUSTIFICATION:
238 font_manager_preview_page_set_justification(self, (GtkJustification) g_value_get_enum(value));
239 break;
240 case PROP_WATERFALL_MIN:
241 font_manager_preview_page_set_waterfall_size(self, g_value_get_double(value), -1.0, -1.0);
242 break;
243 case PROP_WATERFALL_MAX:
244 font_manager_preview_page_set_waterfall_size(self, -1.0, g_value_get_double(value), -1.0);
245 break;
246 case PROP_WATERFALL_RATIO:
247 font_manager_preview_page_set_waterfall_size(self, -1.0, -1.0, g_value_get_double(value));
248 break;
249 case PROP_LINE_SPACING:
250 self->line_spacing = g_value_get_int(value);
251 gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(self->textview), self->line_spacing);
252 gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(self->textview), self->line_spacing);
253 break;
254 case PROP_SHOW_LINE_SIZE:
255 self->show_line_size = g_value_get_boolean(value);
256 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL)
257 generate_waterfall_preview(self);
258 break;
259 default:
260 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
261 }
262 return;
263 }
264
265 static void
266 font_manager_preview_page_class_init (FontManagerPreviewPageClass *klass)
267 {
268 GObjectClass *object_class = G_OBJECT_CLASS(klass);
269
270 object_class->dispose = font_manager_preview_page_dispose;
271 object_class->get_property = font_manager_preview_page_get_property;
272 object_class->set_property = font_manager_preview_page_set_property;
273
274 /**
275 * FontManagerPreviewPage:preview-mode:
276 *
277 * The current font preview mode.
278 */
279 obj_properties[PROP_PREVIEW_MODE] = g_param_spec_enum("preview-mode",
280 NULL,
281 "Font preview mode.",
282 FONT_MANAGER_TYPE_PREVIEW_PAGE_MODE,
283 (gint) FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL,
284 G_PARAM_STATIC_STRINGS |
285 G_PARAM_READWRITE |
286 G_PARAM_EXPLICIT_NOTIFY);
287
288 /**
289 * FontManagerPreviewPage:preview-size:
290 *
291 * The current font preview size.
292 */
293 obj_properties[PROP_PREVIEW_SIZE] = g_param_spec_double("preview-size",
294 NULL,
295 "Font preview size in points.",
296 MIN_FONT_SIZE,
297 MAX_FONT_SIZE,
298 DEFAULT_PREVIEW_SIZE,
299 G_PARAM_STATIC_STRINGS |
300 G_PARAM_READWRITE |
301 G_PARAM_EXPLICIT_NOTIFY);
302
303 /**
304 * FontManagerPreviewPage:preview-text:
305 *
306 * Current preview text.
307 */
308 obj_properties[PROP_PREVIEW_TEXT] = g_param_spec_string("preview-text",
309 NULL,
310 "Current preview text.",
311 NULL,
312 G_PARAM_STATIC_STRINGS |
313 G_PARAM_READWRITE |
314 G_PARAM_EXPLICIT_NOTIFY);
315
316 /**
317 * FontManagerPreviewPage:font:
318 *
319 * #FontManagerFont
320 */
321 obj_properties[PROP_FONT] = g_param_spec_object("font",
322 NULL,
323 "FontManagerFont",
324 FONT_MANAGER_TYPE_FONT,
325 G_PARAM_READWRITE |
326 G_PARAM_STATIC_STRINGS);
327
328 /**
329 * FontManagerPreviewPage:justification:
330 *
331 * Preview text justification.
332 */
333 obj_properties[PROP_JUSTIFICATION] = g_param_spec_enum("justification",
334 NULL,
335 "Preview text justification.",
336 GTK_TYPE_JUSTIFICATION,
337 GTK_JUSTIFY_CENTER,
338 G_PARAM_STATIC_STRINGS |
339 G_PARAM_READWRITE |
340 G_PARAM_EXPLICIT_NOTIFY);
341
342 /**
343 * FontManagerPreviewPage:min-waterfall-size:
344 *
345 * The current minimum waterfall preview size.
346 */
347 obj_properties[PROP_WATERFALL_MIN] = g_param_spec_double("min-waterfall-size",
348 NULL,
349 "Minimum waterfall preview size in points.",
350 MIN_FONT_SIZE,
351 DEFAULT_WATERFALL_MAX_SIZE,
352 MIN_FONT_SIZE,
353 G_PARAM_STATIC_STRINGS |
354 G_PARAM_READWRITE |
355 G_PARAM_EXPLICIT_NOTIFY);
356
357 /**
358 * FontManagerPreviewPage:max-waterfall-size:
359 *
360 * The current maximum waterfall preview size.
361 */
362 obj_properties[PROP_WATERFALL_MAX] = g_param_spec_double("max-waterfall-size",
363 NULL,
364 "Maximum waterfall preview size in points.",
365 MIN_FONT_SIZE,
366 MAX_FONT_SIZE * 2,
367 DEFAULT_WATERFALL_MAX_SIZE,
368 G_PARAM_STATIC_STRINGS |
369 G_PARAM_READWRITE |
370 G_PARAM_EXPLICIT_NOTIFY);
371
372 /**
373 * FontManagerPreviewPage:waterfall-size-ratio:
374 *
375 * Waterfall point size common ratio.
376 */
377 obj_properties[PROP_WATERFALL_RATIO] = g_param_spec_double("waterfall-size-ratio",
378 NULL,
379 "Waterfall point size common ratio",
380 1.0,
381 DEFAULT_WATERFALL_MAX_SIZE / 2,
382 1.1,
383 G_PARAM_STATIC_STRINGS |
384 G_PARAM_READWRITE |
385 G_PARAM_EXPLICIT_NOTIFY);
386
387 /**
388 * FontManagerPreviewPage:show-line-size:
389 *
390 * Whether to display line size in Waterfall preview or not.
391 */
392 obj_properties[PROP_SHOW_LINE_SIZE] = g_param_spec_boolean("show-line-size",
393 NULL,
394 "Whether to display Waterfall preview line size",
395 TRUE,
396 G_PARAM_STATIC_STRINGS |
397 G_PARAM_READWRITE);
398
399 /**
400 * FontManagerPreviewPage:line-spacing:
401 *
402 * Pixels between lines in Waterfall preview.
403 */
404 obj_properties[PROP_LINE_SPACING] = g_param_spec_int("line-spacing",
405 NULL,
406 "Waterfall preview line spacing",
407 0,
408 G_MAXINT,
409 0,
410 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
411
412 g_object_class_install_properties(object_class, N_PROPERTIES, obj_properties);
413 return;
414 }
415
416 static void
417 update_revealer_state (FontManagerPreviewPage *self,
418 FontManagerPreviewPageMode mode)
419 {
420 g_return_if_fail(self != NULL);
421 gboolean controls_visible = gtk_revealer_get_child_revealed(GTK_REVEALER(self->controls));
422 GtkRevealerTransitionType trans_type = controls_visible ?
423 GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP :
424 GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN;
425 gtk_revealer_set_transition_type(GTK_REVEALER(self->controls), trans_type);
426 gboolean fontscale_visible = gtk_revealer_get_child_revealed(GTK_REVEALER(self->controls));
427 trans_type = fontscale_visible ? GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN :
428 GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP;
429 gtk_revealer_set_transition_type(GTK_REVEALER(self->fontscale), trans_type);
430 gtk_revealer_set_reveal_child(GTK_REVEALER(self->fontscale),
431 (mode == FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW ||
432 mode == FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM));
433 gtk_revealer_set_reveal_child(GTK_REVEALER(self->controls),
434 (mode == FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW));
435 return;
436 }
437
438 static gint current_line = FONT_MANAGER_MIN_FONT_SIZE;
439
440 static gboolean
441 generate_waterfall_line (FontManagerPreviewPage *self)
442 {
443 GtkTextIter iter;
444 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
445 GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(buffer);
446 gint i = current_line;
447 g_autofree gchar *size_point = NULL;
448 g_autofree gchar *line = g_strdup_printf("%i", i);
449 if (self->show_line_size)
450 size_point = g_strdup_printf(i < 10 ? " %spt. " : "%spt. ", line);
451 gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
452 if (self->show_line_size)
453 gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, size_point, -1, "SizePoint", NULL);
454 if (!gtk_text_tag_table_lookup(tag_table, line))
455 gtk_text_buffer_create_tag(buffer, line, "size-points", (gdouble) i, NULL);
456 if (self->show_line_size)
457 gtk_text_buffer_get_end_iter(buffer, &iter);
458 g_autofree gchar *pangram = g_strdup_printf("%s\n", self->pangram);
459 gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, pangram, -1, line, "FontDescription", NULL);
460 if (self->waterfall_size_ratio > 1.0) {
461 gdouble next = current_line * self->waterfall_size_ratio;
462 current_line = self->waterfall_size_ratio > 1.1 ? floor(next) : ceil(next);
463 } else
464 current_line++;
465 return self->mode != FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL ||
466 current_line > self->max_waterfall_size ?
467 G_SOURCE_REMOVE : G_SOURCE_CONTINUE;
468 }
469
470 static void
471 generate_waterfall_preview (FontManagerPreviewPage *self)
472 {
473 g_return_if_fail(self != NULL);
474 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
475 gtk_text_buffer_set_text(buffer, "", -1);
476 g_idle_remove_by_data(self);
477 current_line = self->min_waterfall_size;
478 g_idle_add_full(G_PRIORITY_HIGH_IDLE, (GSourceFunc) generate_waterfall_line, self, NULL);
479 return;
480 }
481
482 static void
483 apply_font_description (FontManagerPreviewPage *self)
484 {
485 g_return_if_fail(self != NULL);
486 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL)
487 return;
488 GtkTextIter start, end;
489 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
490 gtk_text_buffer_get_bounds(buffer, &start, &end);
491 gtk_text_buffer_apply_tag_by_name(buffer, "FontDescription", &start, &end);
492 return;
493 }
494
495 /* Prevent tofu if possible */
496 static void
497 update_sample_string (FontManagerPreviewPage *self)
498 {
499 g_return_if_fail(self != NULL);
500 if (self->font == NULL)
501 return;
502 g_autofree gchar *preview_text = NULL;
503 g_object_get(self->font, "preview-text", &preview_text, NULL);
504 if (preview_text) {
505 g_clear_pointer(&self->pangram, g_free);
506 self->pangram = g_strdup(preview_text);
507 if (!self->restore_preview)
508 self->restore_preview = g_strdup(self->preview);
509 font_manager_preview_page_set_preview_text(self, preview_text);
510 } else {
511 if (self->restore_preview) {
512 g_clear_pointer(&self->pangram, g_free);
513 self->pangram = g_strdup(self->default_pangram);
514 font_manager_preview_page_set_preview_text(self, self->restore_preview);
515 g_clear_pointer(&self->restore_preview, g_free);
516 }
517 }
518 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL)
519 generate_waterfall_preview(self);
520 return;
521 }
522
523 static void
524 update_font_description (FontManagerPreviewPage *self)
525 {
526 g_return_if_fail(self != NULL);
527 if (self->font == NULL)
528 return;
529 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
530 GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(buffer);
531 GtkTextTag *font_description = gtk_text_tag_table_lookup(tag_table, "FontDescription");
532 g_return_if_fail(font_description != NULL);
533 g_autofree gchar *description = NULL;
534 g_object_get(self->font, "description", &description, NULL);
535 g_return_if_fail(description != NULL);
536 g_autoptr(PangoFontDescription) font_desc = pango_font_description_from_string(description);
537 g_object_set(G_OBJECT(font_description),
538 "font-desc", font_desc,
539 "size-points", self->preview_size,
540 "fallback", FALSE,
541 NULL);
542 return;
543 }
544
545 static void
546 on_edit_toggled (FontManagerPreviewPage *self, gboolean active)
547 {
548 g_return_if_fail(self != NULL);
549 self->allow_edit = active;
550 gtk_text_view_set_editable(GTK_TEXT_VIEW(self->textview), active);
551 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(self->textview), active);
552 gtk_widget_set_can_target(self->textview, active);
553 gtk_widget_grab_focus(self->textview);
554 return;
555 }
556
557 static void
558 on_buffer_changed (GtkTextBuffer *buffer, FontManagerPreviewPage *self)
559 {
560 g_return_if_fail(self != NULL);
561 /* Buffer may be modified by the user in preview mode */
562 if (self->mode != FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW)
563 return;
564 gboolean undo_available = FALSE;
565 GtkWidget *controls = gtk_revealer_get_child(GTK_REVEALER(self->controls));
566 GtkTextIter start, end;
567 gtk_text_buffer_get_bounds(buffer, &start, &end);
568 gchar *current_text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
569 /* Restore default preview if we have an empty buffer */
570 if (g_strcmp0(current_text, "") == 0) {
571 g_free(current_text);
572 current_text = g_strdup(self->default_preview);
573 }
574 undo_available = (g_strcmp0(self->default_preview, current_text) != 0);
575 /* Store the buffer contents if they've been modified */
576 if (undo_available && (g_strcmp0(self->preview, current_text) != 0)) {
577 g_free(self->preview);
578 self->preview = g_strdup(current_text);
579 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_PREVIEW_TEXT]);
580 }
581 g_clear_pointer(&current_text, g_free);
582 g_object_set(G_OBJECT(controls), "undo-available", undo_available, NULL);
583 return;
584 }
585
586 static void
587 on_undo_clicked (FontManagerPreviewPage *self, FontManagerPreviewControls *controls)
588 {
589 g_return_if_fail(self != NULL);
590 g_return_if_fail(self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW);
591 font_manager_preview_page_set_preview_text(self, self->default_preview);
592 return;
593 }
594
595 static void
596 on_mode_action_activated (GSimpleAction *action,
597 GVariant *parameter,
598 FontManagerPreviewPage *self)
599 {
600 FontManagerPreviewPageMode mode = FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM;
601 const gchar *param = g_variant_get_string(parameter, NULL);
602 if (g_strcmp0(param, "Waterfall") == 0)
603 mode = FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL;
604 else if (g_strcmp0(param, "Preview") == 0)
605 mode = FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW;
606 set_preview_mode_internal(self, mode);
607 g_simple_action_set_state(G_SIMPLE_ACTION(action), parameter);
608 return;
609 }
610
611 static void
612 on_zoom_event (FontManagerPreviewPage *self,
613 GtkGestureZoom *controller,
614 gdouble scale)
615 {
616 g_return_if_fail(self != NULL);
617 if (self->mode != FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL) {
618 if (scale > 1.0)
619 font_manager_preview_page_set_preview_size(self, self->preview_size + 0.5);
620 else
621 font_manager_preview_page_set_preview_size(self, self->preview_size - 0.5);
622 }
623 return;
624 }
625
626 static void
627 on_long_press_event (GtkWidget *textview,
628 GtkGestureZoom *controller,
629 gdouble x,
630 gdouble y)
631 {
632 g_return_if_fail(GTK_IS_TEXT_VIEW(textview));
633 gtk_widget_activate_action(textview, "menu.popup", NULL);
634 return;
635 }
636
637 static void
638 on_swipe_event (FontManagerPreviewPage *self,
639 gdouble x,
640 gdouble y,
641 GtkGestureSwipe *swipe)
642 {
643 g_return_if_fail(self != NULL);
644 gint mode = (gint) self->mode;
645 mode = (x < 0) ? ((mode < 2) ? (mode + 1) : 0) : ((mode > 0) ? (mode - 1) : 2);
646 font_manager_preview_page_set_preview_mode(self, mode);
647 return;
648 }
649
650 // TODO : Figure out why this is needed.
651 // This ensures our PreviewColors CSS is applied to preview widget.
652 // Otherwise the CSS fails to apply until the user interacts with it
653 // if it's not visible at start up.
654 static void
655 force_css_update (GtkWidget *preview)
656 {
657 g_return_if_fail(preview != NULL);
658 gtk_widget_grab_focus(preview);
659 gtk_widget_queue_draw(preview);
660 return;
661 }
662
663 static void
664 font_manager_preview_page_init (FontManagerPreviewPage *self)
665 {
666 g_return_if_fail(self != NULL);
667 self->allow_edit = FALSE;
668 self->show_line_size = TRUE;
669 self->restore_preview = NULL;
670 self->menu_button = NULL;
671 self->min_waterfall_size = MIN_FONT_SIZE + 2;
672 self->max_waterfall_size = DEFAULT_WATERFALL_MAX_SIZE;
673 self->waterfall_size_ratio = 1.1;
674 gtk_widget_add_css_class(GTK_WIDGET(self), FONT_MANAGER_STYLE_CLASS_VIEW);
675 gtk_widget_add_css_class(GTK_WIDGET(self), "FontManagerFontPreviewArea");
676 font_manager_widget_set_name(GTK_WIDGET(self), "FontManagerPreviewPage");
677 gtk_orientable_set_orientation(GTK_ORIENTABLE(self), GTK_ORIENTATION_VERTICAL);
678 g_autoptr(GtkTextTagTable) tag_table = font_manager_text_tag_table_new();
679 self->pangram = font_manager_get_localized_pangram();
680 self->default_pangram = font_manager_get_localized_pangram();
681 self->preview = font_manager_get_localized_preview_text();
682 self->default_preview = g_strdup(self->preview);
683 self->justification = GTK_JUSTIFY_CENTER;
684 g_autoptr(GtkTextBuffer) buffer = gtk_text_buffer_new(tag_table);
685 GtkWidget *scroll = gtk_scrolled_window_new();
686 self->textview = gtk_text_view_new_with_buffer(buffer);
687 gtk_widget_add_css_class(GTK_WIDGET(self->textview), "FontManagerFontPreviewArea");
688 /* gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(self->textview), FALSE); */
689 GtkWidget *controls = font_manager_preview_controls_new();
690 self->controls = gtk_revealer_new();
691 GtkWidget *fontscale = font_manager_font_scale_new();
692 self->fontscale = gtk_revealer_new();
693 gtk_revealer_set_child(GTK_REVEALER(self->controls), controls);
694 gtk_revealer_set_child(GTK_REVEALER(self->fontscale), fontscale);
695 gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scroll), self->textview);
696 font_manager_widget_set_expand(scroll, TRUE);
697 gtk_box_append(GTK_BOX(self), self->controls);
698 gtk_box_append(GTK_BOX(self), scroll);
699 gtk_box_append(GTK_BOX(self), self->fontscale);
700 font_manager_widget_set_margin(self->textview, FONT_MANAGER_DEFAULT_MARGIN * 2);
701 gtk_widget_set_margin_top(self->textview, FONT_MANAGER_DEFAULT_MARGIN * 1.5);
702 gtk_widget_set_margin_bottom(self->textview, FONT_MANAGER_DEFAULT_MARGIN * 1.5);
703 font_manager_widget_set_expand(scroll, TRUE);
704 font_manager_preview_page_set_preview_size(self, FONT_MANAGER_DEFAULT_PREVIEW_SIZE);
705 font_manager_preview_page_set_preview_mode(self, FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL);
706 GtkAdjustment *adjustment = font_manager_font_scale_get_adjustment(FONT_MANAGER_FONT_SCALE(fontscale));
707 GBindingFlags flags = G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE;
708 g_object_bind_property(adjustment, "value", self, "preview-size", flags);
709 flags = G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE;
710 g_object_bind_property(self, "font", controls, "font", flags);
711 g_object_bind_property(controls, "justification", self, "justification", flags);
712 font_manager_preview_page_set_justification(self, GTK_JUSTIFY_CENTER);
713 g_signal_connect_swapped(controls, "edit-toggled", G_CALLBACK(on_edit_toggled), self);
714 g_signal_connect_after(buffer, "changed", G_CALLBACK(on_buffer_changed), self);
715 g_signal_connect_swapped(controls, "undo-clicked", G_CALLBACK(on_undo_clicked), self);
716 GtkGesture *zoom = gtk_gesture_zoom_new();
717 g_signal_connect_swapped(zoom, "scale-changed", G_CALLBACK(on_zoom_event), self);
718 gtk_widget_add_controller(GTK_WIDGET(self), GTK_EVENT_CONTROLLER(zoom));
719 GtkGesture *swipe = gtk_gesture_swipe_new();
720 gtk_gesture_single_set_touch_only(GTK_GESTURE_SINGLE(swipe), TRUE);
721 g_signal_connect_swapped(swipe, "swipe", G_CALLBACK(on_swipe_event), self);
722 gtk_widget_add_controller(GTK_WIDGET(self), GTK_EVENT_CONTROLLER(swipe));
723 GtkGesture *long_press = gtk_gesture_long_press_new();
724 g_signal_connect_swapped(long_press, "pressed", G_CALLBACK(on_long_press_event), self->textview);
725 gtk_widget_add_controller(GTK_WIDGET(self->textview), GTK_EVENT_CONTROLLER(long_press));
726 font_manager_preview_page_set_waterfall_size(self, self->min_waterfall_size, DEFAULT_WATERFALL_MAX_SIZE, 1.0);
727 self->menu_button = g_object_ref_sink(gtk_menu_button_new());
728 font_manager_set_preview_page_mode_menu_and_actions(GTK_WIDGET(self), self->menu_button, G_CALLBACK(on_mode_action_activated));
729 g_signal_connect_after(self->textview, "map", G_CALLBACK(force_css_update), NULL);
730 return;
731 }
732
733 /**
734 * font_manager_preview_page_get_action_widget:
735 * @self: #FontManagerPreviewPage
736 *
737 * Returns: (transfer full) (nullable): A #GtkMenuButton which provides controls for preview mode.
738 * Free the returned object using #g_object_unref().
739 */
740 GtkWidget *
741 font_manager_preview_page_get_action_widget (FontManagerPreviewPage *self)
742 {
743 g_return_val_if_fail(self != NULL, NULL);
744 return g_object_ref(self->menu_button);
745 }
746
747 /**
748 * font_manager_preview_page_get_font:
749 * @self: #FontManagerPreviewPage
750 *
751 * Returns:(transfer none) (nullable):#FontManagerFont which is owned by
752 * the instance and must not be modified or freed.
753 */
754 FontManagerFont *
755 font_manager_preview_page_get_font (FontManagerPreviewPage *self)
756 {
757 g_return_val_if_fail(self != NULL, NULL);
758 return self->font;
759 }
760
761 /**
762 * font_manager_preview_page_get_justification:
763 * @self: #FontManagerPreviewPage
764 *
765 * Returns: Current preview text justification.
766 */
767 GtkJustification
768 font_manager_preview_page_get_justification (FontManagerPreviewPage *self)
769 {
770 g_return_val_if_fail(self != NULL, 0);
771 return self->justification;
772 }
773
774 /**
775 * font_manager_preview_page_get_preview_mode:
776 * @self: #FontManagerPreviewPage
777 *
778 * Returns: Current preview mode.
779 */
780 FontManagerPreviewPageMode
781 font_manager_preview_page_get_preview_mode (FontManagerPreviewPage *self)
782 {
783 g_return_val_if_fail(self != NULL, 0);
784 return self->mode;
785 }
786
787 /**
788 * font_manager_preview_page_get_preview_size:
789 * @self: #FontManagerPreviewPage
790 *
791 * Returns: Current preview size.
792 */
793 gdouble
794 font_manager_preview_page_get_preview_size (FontManagerPreviewPage *self)
795 {
796 g_return_val_if_fail(self != NULL, 0.0);
797 return self->preview_size;
798 }
799
800 /**
801 * font_manager_preview_page_get_preview_text:
802 * @self: #FontManagerPreviewPage
803 *
804 * Returns:(transfer full) (nullable):
805 * A newly allocated string that must be freed with #g_free or %NULL
806 */
807 gchar *
808 font_manager_preview_page_get_preview_text (FontManagerPreviewPage *self)
809 {
810 g_return_val_if_fail(self != NULL, NULL);
811 return g_strdup(self->preview);
812 }
813
814 /**
815 * font_manager_preview_page_set_font:
816 * @self: #FontManagerPreviewPage
817 * @font: #FontManagerFont
818 */
819 void
820 font_manager_preview_page_set_font (FontManagerPreviewPage *self,
821 FontManagerFont *font)
822 {
823 g_return_if_fail(self != NULL);
824 if (g_set_object(&self->font, font))
825 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_FONT]);
826 update_font_description(self);
827 update_sample_string(self);
828 apply_font_description(self);
829 return;
830 }
831
832 /**
833 * font_manager_preview_page_set_justification:
834 * @self: #FontManagerPreviewPage
835 * @justification: #GtkJustification
836 *
837 * Set preview text justification.
838 */
839 void
840 font_manager_preview_page_set_justification (FontManagerPreviewPage *self,
841 GtkJustification justification)
842 {
843 g_return_if_fail(self != NULL);
844 self->justification = justification;
845 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW)
846 gtk_text_view_set_justification(GTK_TEXT_VIEW(self->textview), justification);
847 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_JUSTIFICATION]);
848 return;
849 }
850
851 static void
852 set_preview_mode_internal (FontManagerPreviewPage *self,
853 FontManagerPreviewPageMode mode)
854 {
855 while (g_idle_remove_by_data(self))
856 g_idle_remove_by_data(self);
857 self->mode = mode;
858 GtkTextIter start;
859 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
860 gtk_text_buffer_get_start_iter(buffer, &start);
861 gtk_text_view_set_editable(GTK_TEXT_VIEW(self->textview), FALSE);
862 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(self->textview), GTK_WRAP_WORD_CHAR);
863 gtk_text_view_set_justification(GTK_TEXT_VIEW(self->textview), GTK_JUSTIFY_FILL);
864 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(self->textview), &start, 0.0, TRUE, 0.0, 0.0);
865 gtk_text_view_set_top_margin(GTK_TEXT_VIEW(self->textview), 0);
866 gtk_widget_set_can_target(self->textview, FALSE);
867 switch (mode) {
868 case FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW:
869 gtk_text_view_set_top_margin(GTK_TEXT_VIEW(self->textview), FONT_MANAGER_DEFAULT_MARGIN * 6);
870 gtk_text_view_set_justification(GTK_TEXT_VIEW(self->textview), self->justification);
871 gtk_text_view_set_editable(GTK_TEXT_VIEW(self->textview), self->allow_edit);
872 gtk_widget_set_can_target(self->textview, self->allow_edit ? TRUE : FALSE);
873 gchar *text = self->preview ? self->preview : self->default_preview;
874 font_manager_preview_page_set_preview_text(self, text);
875 break;
876 case FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL:
877 generate_waterfall_preview(self);
878 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(self->textview), GTK_WRAP_NONE);
879 break;
880 case FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM:
881 gtk_text_buffer_set_text(buffer, FONT_MANAGER_LOREM_IPSUM, -1);
882 break;
883 default:
884 g_critical("Invalid preview mode : %i", (gint) mode);
885 g_return_if_reached();
886 }
887 apply_font_description(self);
888 update_revealer_state(self, mode);
889 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_PREVIEW_MODE]);
890 }
891
892 /**
893 * font_manager_preview_page_set_preview_mode:
894 * @self: #FontManagerPreviewPage
895 * @mode: Preview mode.
896 */
897 void
898 font_manager_preview_page_set_preview_mode (FontManagerPreviewPage *self,
899 FontManagerPreviewPageMode mode)
900 {
901 g_return_if_fail(self != NULL);
902 const gchar *mode_string = font_manager_preview_page_mode_to_string(mode);
903 gtk_widget_activate_action(GTK_WIDGET(self), "preview.mode", "s", mode_string);
904 return;
905 }
906
907 /**
908 * font_manager_preview_page_set_preview_size:
909 * @self: #FontManagerPreviewPage
910 * @size_points: Preview text size.
911 */
912 void
913 font_manager_preview_page_set_preview_size (FontManagerPreviewPage *self,
914 gdouble size_points)
915 {
916 g_return_if_fail(self != NULL);
917 self->preview_size = CLAMP(size_points, MIN_FONT_SIZE, MAX_FONT_SIZE);
918 update_font_description(self);
919 apply_font_description(self);
920 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_PREVIEW_SIZE]);
921 return;
922 }
923
924 /**
925 * font_manager_preview_page_set_preview_text:
926 * @self: #FontManagerPreviewPage
927 * @preview_text: Preview text.
928 */
929 void
930 font_manager_preview_page_set_preview_text (FontManagerPreviewPage *self,
931 const gchar *preview_text)
932 {
933 g_return_if_fail(self != NULL);
934
935 if (preview_text) {
936 gchar *new_preview = g_strdup(preview_text);
937 g_free(self->preview);
938 self->preview = new_preview;
939 }
940
941 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_PREVIEW) {
942 g_return_if_fail(self->preview != NULL);
943 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textview));
944 g_autofree gchar *valid = g_utf8_make_valid(self->preview, -1);
945 gtk_text_buffer_set_text(buffer, valid, -1);
946 }
947 apply_font_description(self);
948 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_PREVIEW_TEXT]);
949 return;
950 }
951
952 /**
953 * font_manager_preview_page_set_waterfall_size:
954 * @self: #FontManagerPreviewPage
955 * @min_size: Minimum point size to use for waterfall previews. (-1.0 to keep current)
956 * @max_size: Maximum size to use for waterfall previews. (-1.0 to keep current)
957 * @ratio: Waterfall point size common ratio. (-1.0 to keep current)
958 */
959 void
960 font_manager_preview_page_set_waterfall_size (FontManagerPreviewPage *self,
961 gdouble min_size,
962 gdouble max_size,
963 gdouble ratio)
964 {
965 g_return_if_fail(self != NULL);
966 g_return_if_fail(ratio == -1.0 || (ratio >= 1.0 && ratio <= DEFAULT_WATERFALL_MAX_SIZE));
967 if (min_size != -1.0) {
968 self->min_waterfall_size = CLAMP(min_size, MIN_FONT_SIZE, MAX_FONT_SIZE / 2);
969 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_WATERFALL_MIN]);
970 }
971 if (max_size != -1.0) {
972 self->max_waterfall_size = CLAMP(max_size, MIN_FONT_SIZE * 4, MAX_FONT_SIZE * 2);
973 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_WATERFALL_MAX]);
974 }
975 if (ratio != -1.0) {
976 self->waterfall_size_ratio = ratio;
977 g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_WATERFALL_RATIO]);
978 }
979 if (self->mode == FONT_MANAGER_PREVIEW_PAGE_MODE_WATERFALL)
980 generate_waterfall_preview(self);
981 return;
982 }
983
984 /**
985 * font_manager_preview_page_restore_state:
986 * @self: #FontManagerPreviewPage
987 * @settings: #GSettings
988 *
989 * Applies the values in @settings to @self and also binds those settings to their
990 * respective properties so that they are updated when any changes take place.
991 *
992 * The following keys MUST be present in @settings:
993 *
994 * - preview-font-size
995 * - preview-mode
996 * - preview-text
997 * - show-line-size
998 * - min-waterfall-size
999 * - max-waterfall-size
1000 * - waterfall-size-ratio
1001 * - waterfall-line-spacing
1002 */
1003 void
1004 font_manager_preview_page_restore_state (FontManagerPreviewPage *self,
1005 GSettings *settings)
1006 {
1007 g_return_if_fail(self != NULL);
1008 g_return_if_fail(settings != NULL);
1009 GSettingsBindFlags flags = G_SETTINGS_BIND_DEFAULT;
1010 g_settings_bind(settings, "preview-font-size", self, "preview-size", flags);
1011 g_settings_bind(settings, "preview-mode", self, "preview-mode", flags);
1012 g_settings_bind(settings, "preview-text", self, "preview-text", flags);
1013 // Our settings use the English version as a default...
1014 PangoLanguage *lang = pango_language_from_string("xx");
1015 const gchar *pangram = pango_language_get_sample_string(lang);
1016 g_autofree gchar *xx = g_strdup_printf(FONT_MANAGER_DEFAULT_PREVIEW_TEXT, pangram);
1017 // If the stored version matches the English default use the localized version
1018 if (g_strcmp0(self->preview, xx) == 0)
1019 font_manager_preview_page_set_preview_text(self, self->default_preview);
1020 g_settings_bind(settings, "waterfall-show-line-size", self, "show-line-size", flags);
1021 g_settings_bind(settings, "waterfall-line-spacing", self, "line-spacing", flags);
1022 g_settings_bind(settings, "min-waterfall-size", self, "min-waterfall-size", flags);
1023 g_settings_bind(settings, "max-waterfall-size", self, "max-waterfall-size", flags);
1024 g_settings_bind(settings, "waterfall-size-ratio", self, "waterfall-size-ratio", flags);
1025 font_manager_preview_page_set_waterfall_size(self, -1.0, -1.0, -1.0);
1026 return;
1027 }
1028
1029 /**
1030 * font_manager_preview_page_new:
1031 *
1032 * Returns: A newly created #FontManagerPreviewPage.
1033 * Free the returned object using #g_object_unref().
1034 */
1035 GtkWidget *
1036 font_manager_preview_page_new (void)
1037 {
1038 return g_object_new(FONT_MANAGER_TYPE_PREVIEW_PAGE, NULL);
1039 }
1040
1041 /**
1042 * font_manager_set_preview_page_mode_menu_and_actions:
1043 * @parent: #GtkWidget
1044 * @menu_button: #GtkMenuButton
1045 * @callback: (scope forever) : #GCallback for action "activate" signal
1046 */
1047 void
1048 font_manager_set_preview_page_mode_menu_and_actions (GtkWidget *parent,
1049 GtkWidget *menu_button,
1050 GCallback callback)
1051 {
1052 GMenu *mode_menu = g_menu_new();
1053 GVariant *variant = g_variant_new_string("Waterfall");
1054 g_autoptr(GSimpleAction) action = g_simple_action_new_stateful("mode", G_VARIANT_TYPE_STRING, variant);
1055 g_simple_action_set_enabled(action, TRUE);
1056 g_signal_connect(action, "activate", callback, parent);
1057 g_action_activate(G_ACTION(action), variant);
1058 g_autoptr(GSimpleActionGroup) action_group = g_simple_action_group_new();
1059 g_action_map_add_action(G_ACTION_MAP(action_group), G_ACTION(action));
1060 gtk_widget_insert_action_group(menu_button, "preview", G_ACTION_GROUP(action_group));
1061 gtk_widget_insert_action_group(parent, "preview", G_ACTION_GROUP(action_group));
1062 GtkEventController *shortcuts = gtk_shortcut_controller_new();
1063 gtk_event_controller_set_propagation_phase(shortcuts, GTK_PHASE_BUBBLE);
1064 gtk_widget_add_controller(parent, GTK_EVENT_CONTROLLER(shortcuts));
1065 gtk_shortcut_controller_set_scope(GTK_SHORTCUT_CONTROLLER(shortcuts), GTK_SHORTCUT_SCOPE_GLOBAL);
1066 for (gint i = 0; i <= FONT_MANAGER_PREVIEW_PAGE_MODE_LOREM_IPSUM; i++) {
1067 const gchar *action_state = font_manager_preview_page_mode_to_string((FontManagerPreviewPageMode) i);
1068 const gchar *display_name = font_manager_preview_page_mode_to_translatable_string((FontManagerPreviewPageMode) i);
1069 g_autofree gchar *action_name = g_strdup_printf("preview.mode::%s", action_state);
1070 g_autoptr(GMenuItem) item = g_menu_item_new(display_name, action_name);
1071 g_autofree gchar *accel = g_strdup_printf("<Alt>%i", i + 1);
1072 g_menu_append_item(mode_menu, item);
1073 GtkShortcut *shortcut = font_manager_get_shortcut_for_stateful_action("preview", "mode", action_state, accel);
1074 gtk_shortcut_controller_add_shortcut(GTK_SHORTCUT_CONTROLLER(shortcuts), shortcut);
1075 }
1076 gtk_menu_button_set_icon_name(GTK_MENU_BUTTON(menu_button), "view-more-symbolic");
1077 gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menu_button), G_MENU_MODEL(mode_menu));
1078 font_manager_widget_set_margin(menu_button, 2);
1079 g_object_unref(mode_menu);
1080 return;
1081 }
1082
1083