/* Based on the GTK Font Selection dialog. See GTK source for licensing information. */ #include "stdafx.h" #include "common.h" #include #include #include #include "gdk/gdk.h" #include "gdk/gdkkeysyms.h" #include "gui_main_fontsel.h" #include "sub_preview.h" #include "sabbu.h" extern struct sabbu app; /* We don't enable the font and style entries because they don't add * much in terms of visible effect and have a weird effect on keynav. * the Windows font selector has entries similarly positioned but they * act in conjunction with the associated lists to form a single focus * location. */ #undef INCLUDE_FONT_ENTRIES /* This is the default text shown in the preview entry, though the user can set it. Remember that some fonts only have capital letters. */ #define PREVIEW_TEXT ("abcdefghijk ABCDEFGHIJK") /* This is the initial and maximum height of the preview entry (it expands when large font sizes are selected). Initial height is also the minimum. */ #define INITIAL_PREVIEW_HEIGHT 44 #define MAX_PREVIEW_HEIGHT 300 /* These are the sizes of the font, style & size lists. */ #define FONT_LIST_HEIGHT 136 #define FONT_LIST_WIDTH 190 #define FONT_STYLE_LIST_WIDTH 170 #define FONT_SIZE_LIST_WIDTH 60 /* These are what we use as the standard font sizes, for the size list. */ static const guint16 font_sizes[] = { 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28, 32, 36, 40, 48, 56, 64, 72 }; enum { PROP_0, PROP_FONT_NAME, PROP_FONT, PROP_PREVIEW_TEXT }; enum { FAMILY_COLUMN, FAMILY_NAME_COLUMN }; enum { FACE_COLUMN, FACE_NAME_COLUMN }; enum { SIZE_COLUMN }; static void kry_font_selection_class_init (KryFontSelectionClass *klass); static void kry_font_selection_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void kry_font_selection_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void kry_font_selection_init (KryFontSelection *fontsel); static void kry_font_selection_finalize (GObject *object); static void kry_font_selection_screen_changed (GtkWidget *widget, GdkScreen *previous_screen); /* These are the callbacks & related functions. */ static void kry_font_selection_select_font (GtkTreeSelection *selection, gpointer data); static void kry_font_selection_show_available_fonts (KryFontSelection *fs); static void kry_font_selection_show_available_styles (KryFontSelection *fs); static void kry_font_selection_select_best_style (KryFontSelection *fs, gboolean use_first); static void kry_font_selection_select_style (GtkTreeSelection *selection, gpointer data); static void kry_font_selection_select_best_size (KryFontSelection *fs); static void kry_font_selection_show_available_sizes (KryFontSelection *fs, gboolean first_time); static void kry_font_selection_size_activate (GtkWidget *w, gpointer data); static gboolean kry_font_selection_size_focus_out (GtkWidget *w, GdkEventFocus *event, gpointer data); static void kry_font_selection_select_size (GtkTreeSelection *selection, gpointer data); static void kry_font_selection_scroll_on_map (GtkWidget *w, gpointer data); static void kry_font_selection_preview_changed (GtkWidget *entry, KryFontSelection *fontsel); /* Misc. utility functions. */ static void kry_font_selection_load_font (KryFontSelection *fs); static void kry_font_selection_update_preview (KryFontSelection *fs); static GdkFont* kry_font_selection_get_font_internal (KryFontSelection *fontsel); /* FontSelectionDialog */ static void kry_font_selection_dialog_class_init (KryFontSelectionDialogClass *klass); static void kry_font_selection_dialog_init (KryFontSelectionDialog *fontseldiag); static GtkVBoxClass *font_selection_parent_class = NULL; static GtkWindowClass *font_selection_dialog_parent_class = NULL; GType kry_font_selection_get_type (void) { static GType font_selection_type = 0; if (!font_selection_type) { static const GTypeInfo fontsel_type_info = { sizeof (KryFontSelectionClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc) kry_font_selection_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (KryFontSelection), 0, /* n_preallocs */ (GInstanceInitFunc) kry_font_selection_init, }; font_selection_type = g_type_register_static (GTK_TYPE_VBOX, "KryFontSelection", &fontsel_type_info, (GTypeFlags) 0); } return font_selection_type; } static void kry_font_selection_class_init (KryFontSelectionClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); font_selection_parent_class = GTK_VBOX_CLASS(g_type_class_peek_parent (klass)); gobject_class->set_property = kry_font_selection_set_property; gobject_class->get_property = kry_font_selection_get_property; widget_class->screen_changed = kry_font_selection_screen_changed; g_object_class_install_property (gobject_class, PROP_FONT_NAME, g_param_spec_string ("font_name", ("Font name"), ("The X string that represents this font"), NULL, (GParamFlags) G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_FONT, g_param_spec_boxed ("font", ("Font"), ("The GdkFont that is currently selected"), GDK_TYPE_FONT, G_PARAM_READABLE)); g_object_class_install_property (gobject_class, PROP_PREVIEW_TEXT, g_param_spec_string ("preview_text", ("Preview text"), ("The text to display in order to demonstrate the selected font"), PREVIEW_TEXT, (GParamFlags) G_PARAM_READWRITE)); gobject_class->finalize = kry_font_selection_finalize; } static void kry_font_selection_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { KryFontSelection *fontsel; fontsel = KRY_FONT_SELECTION (object); switch (prop_id) { case PROP_FONT_NAME: kry_font_selection_set_font_name (fontsel, g_value_get_string (value)); break; case PROP_PREVIEW_TEXT: kry_font_selection_set_preview_text (fontsel, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void kry_font_selection_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { KryFontSelection *fontsel; fontsel = KRY_FONT_SELECTION (object); switch (prop_id) { case PROP_FONT_NAME: g_value_set_string (value, kry_font_selection_get_font_name (fontsel)); break; case PROP_FONT: g_value_set_object (value, kry_font_selection_get_font_internal (fontsel)); break; case PROP_PREVIEW_TEXT: g_value_set_string (value, kry_font_selection_get_preview_text (fontsel)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } void gui_main_fontsel_configure_cb(GtkWidget *widget, GdkEventConfigure *event, KryFontSelection *fontsel) { gtk_widget_queue_draw(widget); } void gui_main_fontsel_apply(KryFontSelection *fontsel) { char *style = KRY_TS(gtk_combo_box_get_active_text(fontsel->combo_style)); kryStyle *subscript_style = app.script->GetStyle(style); fontsel->affected_style = kry_strdup(style); fontsel->orig_font_size = (int) subscript_style->GetFontSize(); fontsel->orig_font_name = kry_strdup(subscript_style->GetFontName()); fontsel->orig_bold = subscript_style->GetBold(); fontsel->orig_italic = subscript_style->GetItalic(); fontsel->orig_underline = subscript_style->GetUnderline(); fontsel->orig_strikethrough = subscript_style->GetStrikethrough(); subscript_style->SetFontSize(fontsel->size / PANGO_SCALE); subscript_style->SetFontName(fontsel->face); subscript_style->SetBold(fontsel->bold); subscript_style->SetItalic(fontsel->italic); subscript_style->SetUnderline(fontsel->underline); subscript_style->SetStrikethrough(fontsel->strikethrough); kry_free(style); } void gui_main_fontsel_revert(KryFontSelection *fontsel) { if(!fontsel->affected_style) return; kryStyle *style = app.script->GetStyle(fontsel->affected_style); style->SetFontSize(fontsel->orig_font_size); style->SetFontName(fontsel->orig_font_name); style->SetBold(fontsel->orig_bold); style->SetItalic(fontsel->orig_italic); style->SetUnderline(fontsel->orig_underline); style->SetStrikethrough(fontsel->orig_strikethrough); kry_free(fontsel->orig_font_name); kry_free(fontsel->affected_style); fontsel->affected_style = NULL; } void gui_main_fontsel_expose_cb(GtkWidget *widget, GdkEventExpose *event, KryFontSelection *fontsel) { int orig_alignment; int width = widget->allocation.width; int height = widget->allocation.height; if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) gui_main_fontsel_apply(fontsel); char *data = (char *) kry_malloc0(4 * width * height); GdkPixbuf *pixbuf; int i; for(i = 0; i < 4 * width * height; i++) data[i] = (char) 255; char *style_name = KRY_TS(gtk_combo_box_get_active_text(fontsel->combo_style)); kryStyle *subscript_style = app.script->GetStyle((char *) style_name); kry_free(style_name); orig_alignment = subscript_style->GetAlignment(); subscript_style->SetAlignment(7); #ifdef _WINDOWS subtest_init(width, height, width, height); #endif style_name = KRY_TS(gtk_combo_box_get_active_text(fontsel->combo_style)); #ifdef _WINDOWS subtest_set("{\\pos(4,4)}abc def ghi jkl ABC DEF GHI JKL", app.script->GetStyle(style_name), 0, 1000, 1); #endif kry_free(style_name); #ifdef _WINDOWS subtest_do(data, width, height, 500); subtest_uninit(); #endif for(i = 0; i + 2 < 4 * width * height; i+= 4) { char temp = data[i]; data[i] = data[i+2]; data[i+2] = temp; } for(i = 0; i + 3 < 4 * width * height; i+= 4) data[i+3] = (char) 255; pixbuf = gdk_pixbuf_new_from_data((const guchar *) data, GDK_COLORSPACE_RGB, TRUE, 8, width, height, width * 4, NULL, NULL); gdk_draw_pixbuf(widget->window, NULL, pixbuf, 0, 0, 0, 0, width, height, GDK_RGB_DITHER_NORMAL, 0, 0); g_object_unref(pixbuf); kry_free(data); if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) gui_main_fontsel_revert(fontsel); subscript_style->SetAlignment(orig_alignment); } void gui_main_fontsel_style_cb(GtkWidget *widget, KryFontSelection *fontsel) { char *text = KRY_TS(gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget))); gtk_widget_queue_draw(GTK_WIDGET(fontsel->preview_area)); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) { // we have to revert the style settings, otherwise we affect the style we are using for preview gui_main_fontsel_revert(fontsel); gui_combo_box_set_text(app.ui.combo_style, text); // now we must apply the settings to the current style gui_main_fontsel_apply(fontsel); } kry_free(text); } void gui_main_fontsel_preview_cb(GtkWidget *widget, KryFontSelection *fontsel) { if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { gui_main_fontsel_revert(fontsel); gui_main_fontsel_apply(fontsel); char *style_name = KRY_TS(gtk_combo_box_get_active_text(fontsel->combo_style)); gui_combo_box_set_text(app.ui.combo_style, style_name); kry_free(style_name); } else { gui_main_fontsel_revert(fontsel); } gtk_widget_queue_draw(GTK_WIDGET(fontsel->preview_area)); gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); } void kry_font_selection_style_cb(GtkWidget *widget, KryFontSelection *fontsel, int type) { gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); gui_main_fontsel_revert(fontsel); if(type == 0 && active) fontsel->bold = PANGO_WEIGHT_BOLD; else if(type == 0) fontsel->bold = active; else if(type == 1) fontsel->italic = active; else if(type == 2) fontsel->strikethrough = active; else if(type == 3) fontsel->underline = active; gui_main_fontsel_apply(fontsel); fontsel->fontsel_info->bold = fontsel->bold; fontsel->fontsel_info->italic = fontsel->italic; fontsel->fontsel_info->strikethough = fontsel->strikethrough; fontsel->fontsel_info->underline = fontsel->underline; gtk_widget_queue_draw(GTK_WIDGET(fontsel->preview_area)); if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) gui_main_fontsel_revert(fontsel); gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); } void kry_font_selection_style_bold_cb(GtkWidget *widget, KryFontSelection *fontsel) { kry_font_selection_style_cb(widget, fontsel, 0); } void kry_font_selection_style_italic_cb(GtkWidget *widget, KryFontSelection *fontsel) { kry_font_selection_style_cb(widget, fontsel, 1); } void kry_font_selection_style_strikethrough_cb(GtkWidget *widget, KryFontSelection *fontsel) { kry_font_selection_style_cb(widget, fontsel, 2); } void kry_font_selection_style_underline_cb(GtkWidget *widget, KryFontSelection *fontsel) { kry_font_selection_style_cb(widget, fontsel, 3); } static void kry_font_selection_init (KryFontSelection *fontsel) { GtkWidget *scrolled_win; GtkWidget *text_frame; GtkWidget *text_box; GtkWidget *table, *label; GtkWidget *font_label, *style_label; GtkListStore *model; GtkTreeViewColumn *column; GList *focus_chain = NULL; fontsel->affected_style = NULL; fontsel->fonts = NULL; fontsel->orig_style = KRY_TS(gtk_combo_box_get_active_text(app.ui.combo_style)); gtk_widget_push_composite_child (); fontsel->size = 12 * PANGO_SCALE; /* Create the table of font, style & size. */ table = gtk_table_new (3, 3, FALSE); gtk_widget_show (table); gtk_table_set_col_spacings (GTK_TABLE (table), 8); gtk_box_pack_start (GTK_BOX (fontsel), table, FALSE, TRUE, 0); #ifdef INCLUDE_FONT_ENTRIES fontsel->font_entry = gtk_entry_new (); gtk_editable_set_editable (GTK_EDITABLE (fontsel->font_entry), FALSE); gtk_widget_set_size_request (fontsel->font_entry, 20, -1); gtk_widget_show (fontsel->font_entry); gtk_table_attach (GTK_TABLE (table), fontsel->font_entry, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); fontsel->font_style_entry = gtk_entry_new (); gtk_editable_set_editable (GTK_EDITABLE (fontsel->font_style_entry), FALSE); gtk_widget_set_size_request (fontsel->font_style_entry, 20, -1); gtk_widget_show (fontsel->font_style_entry); gtk_table_attach (GTK_TABLE (table), fontsel->font_style_entry, 1, 2, 1, 2, GTK_FILL, 0, 0, 0); #endif /* INCLUDE_FONT_ENTRIES */ fontsel->size_entry = gtk_entry_new (); gtk_widget_set_size_request (fontsel->size_entry, 20, -1); gtk_widget_show (fontsel->size_entry); gtk_table_attach (GTK_TABLE (table), fontsel->size_entry, 2, 3, 1, 2, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); g_signal_connect (fontsel->size_entry, "activate", G_CALLBACK (kry_font_selection_size_activate), fontsel); g_signal_connect_after (fontsel->size_entry, "focus_out_event", G_CALLBACK (kry_font_selection_size_focus_out), fontsel); font_label = gtk_label_new_with_mnemonic (__("FontSelectDialog|_Font:")); gtk_misc_set_alignment (GTK_MISC (font_label), 0.0, 0.5); gtk_widget_show (font_label); gtk_table_attach (GTK_TABLE (table), font_label, 0, 1, 0, 1, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); style_label = gtk_label_new_with_mnemonic (__("FontSelectDialog|_Style:")); gtk_misc_set_alignment (GTK_MISC (style_label), 0.0, 0.5); gtk_widget_show (style_label); gtk_table_attach (GTK_TABLE (table), style_label, 1, 2, 0, 1, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); label = gtk_label_new_with_mnemonic (__("FontSelectDialog|Si_ze:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), fontsel->size_entry); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); /* Create the lists */ model = gtk_list_store_new (2, G_TYPE_OBJECT, /* FAMILY_COLUMN */ G_TYPE_STRING); /* FAMILY_NAME_COLUMN */ fontsel->family_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); column = gtk_tree_view_column_new_with_attributes ("Family", gtk_cell_renderer_text_new (), "text", FAMILY_NAME_COLUMN, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->family_list), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->family_list), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->family_list)), GTK_SELECTION_BROWSE); gtk_label_set_mnemonic_widget (GTK_LABEL (font_label), fontsel->family_list); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_widget_set_size_request (scrolled_win, FONT_LIST_WIDTH, FONT_LIST_HEIGHT); gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->family_list); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_show (fontsel->family_list); gtk_widget_show (scrolled_win); gtk_table_attach (GTK_TABLE (table), scrolled_win, 0, 1, 1, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); focus_chain = g_list_append (focus_chain, scrolled_win); GtkVBox *vbox_style = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkCheckButton *button_bold = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Bold"))); GtkCheckButton *button_italic = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Italic"))); GtkCheckButton *button_underline = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Underline"))); GtkCheckButton *button_strikethrough = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Strikethrough"))); gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(button_bold), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(button_italic), FALSE, TRUE, 0); if(app.script->GetType() == KRY_FORMAT_ASS) { gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(button_underline), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(button_strikethrough), FALSE, TRUE, 0); } g_signal_connect(G_OBJECT(button_bold), "toggled", G_CALLBACK(kry_font_selection_style_bold_cb), fontsel); g_signal_connect(G_OBJECT(button_italic), "toggled", G_CALLBACK(kry_font_selection_style_italic_cb), fontsel); g_signal_connect(G_OBJECT(button_underline), "toggled", G_CALLBACK(kry_font_selection_style_underline_cb), fontsel); g_signal_connect(G_OBJECT(button_strikethrough), "toggled", G_CALLBACK(kry_font_selection_style_strikethrough_cb), fontsel); fontsel->toggle_bold = GTK_TOGGLE_BUTTON(button_bold); fontsel->toggle_italic = GTK_TOGGLE_BUTTON(button_italic); fontsel->toggle_strikethrough = GTK_TOGGLE_BUTTON(button_strikethrough); fontsel->toggle_underline = GTK_TOGGLE_BUTTON(button_underline); gtk_widget_show_all(GTK_WIDGET(vbox_style)); model = gtk_list_store_new (2, G_TYPE_OBJECT, /* FACE_COLUMN */ G_TYPE_STRING); /* FACE_NAME_COLUMN */ fontsel->face_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); gtk_label_set_mnemonic_widget (GTK_LABEL (style_label), fontsel->face_list); column = gtk_tree_view_column_new_with_attributes ("Face", gtk_cell_renderer_text_new (), "text", FACE_NAME_COLUMN, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->face_list), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->face_list), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->face_list)), GTK_SELECTION_BROWSE); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_widget_set_size_request (scrolled_win, FONT_STYLE_LIST_WIDTH, FONT_LIST_HEIGHT); gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->face_list); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_widget_show (fontsel->face_list); gtk_widget_show (scrolled_win); gtk_table_attach (GTK_TABLE (table), GTK_WIDGET(vbox_style), 1, 2, 1, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); focus_chain = g_list_append (focus_chain, scrolled_win); focus_chain = g_list_append (focus_chain, fontsel->size_entry); model = gtk_list_store_new (1, G_TYPE_INT); fontsel->size_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); column = gtk_tree_view_column_new_with_attributes ("Size", gtk_cell_renderer_text_new (), "text", SIZE_COLUMN, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (GTK_TREE_VIEW (fontsel->size_list), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (fontsel->size_list), FALSE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)), GTK_SELECTION_BROWSE); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (scrolled_win), fontsel->size_list); gtk_widget_set_size_request (scrolled_win, -1, FONT_LIST_HEIGHT); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show (fontsel->size_list); gtk_widget_show (scrolled_win); gtk_table_attach (GTK_TABLE (table), scrolled_win, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); focus_chain = g_list_append (focus_chain, scrolled_win); gtk_container_set_focus_chain (GTK_CONTAINER (table), focus_chain); g_list_free (focus_chain); /* Insert the fonts. */ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->family_list)), "changed", G_CALLBACK (kry_font_selection_select_font), fontsel); g_signal_connect_after (fontsel->family_list, "map", G_CALLBACK (kry_font_selection_scroll_on_map), fontsel); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->face_list)), "changed", G_CALLBACK (kry_font_selection_select_style), fontsel); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)), "changed", G_CALLBACK (kry_font_selection_select_size), fontsel); /* create the text entry widget */ label = gtk_label_new_with_mnemonic (__("FontSelectDialog|_Preview:")); gtk_widget_show (label); text_frame = gtk_frame_new (NULL); gtk_frame_set_label_widget (GTK_FRAME (text_frame), label); gtk_widget_show (text_frame); gtk_frame_set_shadow_type (GTK_FRAME (text_frame), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (fontsel), text_frame, TRUE, TRUE, 0); GtkVBox *vbox_preview = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkFrame *frame_preview_area = GTK_FRAME(gtk_frame_new(NULL)); GtkDrawingArea *preview_area = GTK_DRAWING_AREA(gtk_drawing_area_new()); g_signal_connect (G_OBJECT (preview_area), "configure_event", G_CALLBACK (gui_main_fontsel_configure_cb), fontsel); g_signal_connect (G_OBJECT (preview_area), "expose_event", G_CALLBACK (gui_main_fontsel_expose_cb), fontsel); gtk_widget_show(GTK_WIDGET(vbox_preview)); gtk_widget_show(GTK_WIDGET(preview_area)); gtk_widget_set_size_request(GTK_WIDGET(preview_area), -1, 100); gtk_widget_show(GTK_WIDGET(frame_preview_area)); gtk_container_add(GTK_CONTAINER(frame_preview_area), GTK_WIDGET(preview_area)); GtkHBox *hbox_preview_style = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkLabel *label_preview_style = GTK_LABEL(gtk_label_new(_("Style:"))); GtkComboBox *combo_preview_style = GTK_COMBO_BOX(gtk_combo_box_new_text()); GtkCheckButton *toggle_video_preview = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Preview in Video Area"))); gtk_widget_show(GTK_WIDGET(toggle_video_preview)); gtk_box_pack_start(GTK_BOX(hbox_preview_style), GTK_WIDGET(label_preview_style), FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(hbox_preview_style), GTK_WIDGET(combo_preview_style), FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(hbox_preview_style), GTK_WIDGET(toggle_video_preview), FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vbox_preview), GTK_WIDGET(hbox_preview_style), FALSE, TRUE, 3); gtk_widget_show_all(GTK_WIDGET(hbox_preview_style)); g_signal_connect(G_OBJECT(toggle_video_preview), "toggled", G_CALLBACK(gui_main_fontsel_preview_cb), fontsel); fontsel->toggle_video_preview = toggle_video_preview; // fill styles combo { gtk_combo_box_set_model(combo_preview_style, GTK_TREE_MODEL(app.ui.style_store)); gtk_combo_box_set_active(combo_preview_style, gtk_combo_box_get_active(app.ui.style_editor.combo_style)); } g_signal_connect(G_OBJECT(combo_preview_style), "changed", G_CALLBACK(gui_main_fontsel_style_cb), fontsel); fontsel->preview_area = preview_area; fontsel->combo_style = combo_preview_style; /* This is just used to get a 4-pixel space around the preview entry. */ text_box = gtk_hbox_new (FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_preview), GTK_WIDGET(text_box), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_preview), GTK_WIDGET(frame_preview_area), TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (text_frame), GTK_WIDGET(vbox_preview)); gtk_container_set_border_width (GTK_CONTAINER (text_box), 4); fontsel->preview_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), fontsel->preview_entry); gtk_widget_show (fontsel->preview_entry); g_signal_connect (fontsel->preview_entry, "changed", G_CALLBACK (kry_font_selection_preview_changed), fontsel); gtk_widget_set_size_request (fontsel->preview_entry, -1, INITIAL_PREVIEW_HEIGHT); gtk_box_pack_start (GTK_BOX (text_box), fontsel->preview_entry, TRUE, TRUE, 0); gtk_widget_pop_composite_child(); } GtkWidget * kry_font_selection_new (struct fontsel_info *fontsel_info) { KryFontSelection *fontsel; fontsel = (KryFontSelection *) g_object_new (GTK_TYPE_KRY_FONT_SELECTION, NULL); fontsel->fontsel_info = fontsel_info; return GTK_WIDGET (fontsel); } static void kry_font_selection_finalize (GObject *object) { KryFontSelection *fontsel; g_return_if_fail (GTK_IS_KRY_FONT_SELECTION (object)); fontsel = KRY_FONT_SELECTION (object); if (fontsel->font) gdk_font_unref (fontsel->font); if(fontsel->orig_style) { gui_combo_box_set_text(app.ui.combo_style, fontsel->orig_style); kry_free(fontsel->orig_style); fontsel->orig_style = NULL; } gui_main_fontsel_revert(fontsel); gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); if (G_OBJECT_CLASS (font_selection_parent_class)->finalize) (* G_OBJECT_CLASS (font_selection_parent_class)->finalize) (object); } static void kry_font_selection_screen_changed (GtkWidget *widget, GdkScreen *previous_screen) { KryFontSelection *fontsel = KRY_FONT_SELECTION (widget); if (gtk_widget_has_screen (GTK_WIDGET (fontsel))) { kry_font_selection_show_available_fonts (fontsel); kry_font_selection_show_available_sizes (fontsel, TRUE); kry_font_selection_show_available_styles (fontsel); } } static void kry_font_selection_preview_changed (GtkWidget *entry, KryFontSelection *fontsel) { g_object_notify (G_OBJECT (fontsel), "preview_text"); } static void scroll_to_selection (GtkTreeView *tree_view) { GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view); GtkTreeModel *model; GtkTreeIter iter; if (gtk_tree_selection_get_selected (selection, &model, &iter)) { GtkTreePath *path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.5); gtk_tree_path_free (path); } } static void set_cursor_to_iter (GtkTreeView *view, GtkTreeIter *iter) { GtkTreeModel *model = gtk_tree_view_get_model (view); GtkTreePath *path = gtk_tree_model_get_path (model, iter); gtk_tree_view_set_cursor (view, path, 0, FALSE); gtk_tree_path_free (path); } /* This is called when the list is mapped. Here we scroll to the current font if necessary. */ static void kry_font_selection_scroll_on_map (GtkWidget *widget, gpointer data) { KryFontSelection *fontsel; #ifdef FONTSEL_DEBUG g_message ("In expose_list\n"); #endif fontsel = KRY_FONT_SELECTION (data); /* Try to scroll the font family list to the selected item */ scroll_to_selection (GTK_TREE_VIEW (fontsel->family_list)); /* Try to scroll the font family list to the selected item */ scroll_to_selection (GTK_TREE_VIEW (fontsel->face_list)); /* Try to scroll the font family list to the selected item */ scroll_to_selection (GTK_TREE_VIEW (fontsel->size_list)); } /* This is called when a family is selected in the list. */ static void kry_font_selection_select_font (GtkTreeSelection *selection, gpointer data) { KryFontSelection *fontsel; GtkTreeModel *model; GtkTreeIter iter; fontsel = KRY_FONT_SELECTION (data); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { char *family; gtk_tree_model_get (model, &iter, FAMILY_NAME_COLUMN, &family, -1); if (!fontsel->face || strcmp(fontsel->face, family)) { gui_main_fontsel_revert(fontsel); fontsel->face = family; gui_main_fontsel_apply(fontsel); if(fontsel->fontsel_info && fontsel->fontsel_info->font_name) kry_free(fontsel->fontsel_info->font_name); if(fontsel->fontsel_info) fontsel->fontsel_info->font_name = kry_strdup(family); gtk_widget_queue_draw(GTK_WIDGET(fontsel->preview_area)); if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) gui_main_fontsel_revert(fontsel); gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); #ifdef INCLUDE_FONT_ENTRIES gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry), family_name); #endif kry_font_selection_show_available_styles (fontsel); kry_font_selection_select_best_style (fontsel, TRUE); } } } static int cmp_families (const void *a, const void *b) { const char *a_name = pango_font_family_get_name (*(PangoFontFamily **)a); const char *b_name = pango_font_family_get_name (*(PangoFontFamily **)b); return g_utf8_collate (a_name, b_name); } #ifdef _WINDOWS int CALLBACK enum_font_cb( ENUMLOGFONTEXW *lpelfe, // logical-font data NEWTEXTMETRICEXW *lpntme, // physical-font data DWORD FontType, // type of font LPARAM lParam // application-defined data ) { KryFontSelection *fontsel = KRY_FONT_SELECTION(lParam); char *name = g_utf16_to_utf8((const gunichar2 *) lpelfe->elfLogFont.lfFaceName, -1, NULL, NULL, NULL); if(!fontsel->fonts || strcmp((char *) g_list_last(fontsel->fonts)->data, name)) fontsel->fonts = g_list_append(fontsel->fonts, name); return TRUE; } #endif int compare_string(const void *a, const void *b) { return strcmp(* ((char **) a), *((char **) b)); } static void kry_font_selection_show_available_fonts (KryFontSelection *fontsel) { GtkListStore *model; PangoFontFamily **families; char *match_family = NULL; gint n_families, i; int match_index = -1; GtkTreeIter match_row; model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->family_list))); pango_context_list_families (gtk_widget_get_pango_context (GTK_WIDGET (fontsel)), &families, &n_families); KRY_TP(families, n_families * sizeof(PangoFontFamily *)); qsort (families, n_families, sizeof (PangoFontFamily *), cmp_families); gtk_list_store_clear (model); #ifdef _WINDOWS HDC dc = GetDC(HWND(GDK_WINDOW_HWND(GTK_WIDGET(fontsel)->window))); LOGFONTW criteria; GList *ptr; criteria.lfCharSet = DEFAULT_CHARSET; criteria.lfFaceName[0] = 0; criteria.lfPitchAndFamily = 0; g_list_free(fontsel->fonts); fontsel->fonts = NULL; EnumFontFamiliesExW(dc, &criteria, (FONTENUMPROCW) enum_font_cb, (LPARAM) fontsel, 0); ReleaseDC(HWND(GDK_WINDOW_HWND(GTK_WIDGET(fontsel)->window)), dc); n_families = g_list_length(fontsel->fonts); char ** font_arr = (char **) kry_malloc(sizeof(char *) * n_families); int index = 0; for (ptr=fontsel->fonts; ptr; ptr=ptr->next) { font_arr[index++] = (char *) ptr->data; } qsort(font_arr, n_families, sizeof(char *), compare_string); for (i=0; i < n_families; i++) { const gchar *name = font_arr[i]; GtkTreeIter iter; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, FAMILY_COLUMN, NULL, FAMILY_NAME_COLUMN, name, -1); if ((fontsel->fontsel_info && !strcmp(fontsel->fontsel_info->font_name, name)) || (match_family == NULL && !g_ascii_strcasecmp (name, "Arial"))) { match_index = i; match_row = iter; } kry_free((gpointer) name); } kry_free(font_arr); g_list_free(fontsel->fonts); fontsel->fonts = NULL; #else for (i=0; ifamily_list), &match_row); #ifdef INCLUDE_FONT_ENTRIES gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry), pango_font_family_get_name (match_family)); #endif /* INCLUDE_FONT_ENTRIES */ kry_free (families); } /* This fills the font style list with all the possible style combinations for the current font family. */ static void kry_font_selection_show_available_styles (KryFontSelection *fontsel) { GtkListStore *model; model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list))); /* if (fontsel->face) old_desc = pango_font_face_describe (fontsel->face); else old_desc= NULL;*/ if(!fontsel->face) return; gtk_list_store_clear (model); { GtkTreeIter iter; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, FACE_COLUMN, NULL, FACE_NAME_COLUMN, "Regular", -1); } } /* This selects a style when the user selects a font. It just uses the first available style at present. I was thinking of trying to maintain the selected style, e.g. bold italic, when the user selects different fonts. However, the interface is so easy to use now I'm not sure it's worth it. Note: This will load a font. */ static void kry_font_selection_select_best_style (KryFontSelection *fontsel, gboolean use_first) { GtkTreeIter iter; GtkTreeModel *model; model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->face_list)); if (gtk_tree_model_get_iter_first (model, &iter)) { set_cursor_to_iter (GTK_TREE_VIEW (fontsel->face_list), &iter); scroll_to_selection (GTK_TREE_VIEW (fontsel->face_list)); } kry_font_selection_show_available_sizes (fontsel, FALSE); kry_font_selection_select_best_size (fontsel); } /* This is called when a style is selected in the list. */ static void kry_font_selection_select_style (GtkTreeSelection *selection, gpointer data) { KryFontSelection *fontsel = KRY_FONT_SELECTION (data); GtkTreeModel *model; GtkTreeIter iter; if (gtk_tree_selection_get_selected (selection, &model, &iter)) { char *name; gtk_tree_model_get (model, &iter, FACE_NAME_COLUMN, &name, -1); } kry_font_selection_show_available_sizes (fontsel, FALSE); kry_font_selection_select_best_size (fontsel); } static void kry_font_selection_show_available_sizes (KryFontSelection *fontsel, gboolean first_time) { unsigned int i; GtkListStore *model; GtkTreeSelection *selection; gchar buffer[128]; gchar *p; model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->size_list))); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)); /* Insert the standard font sizes */ if (first_time) { gtk_list_store_clear (model); for (i = 0; i < G_N_ELEMENTS (font_sizes); i++) { GtkTreeIter iter; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, SIZE_COLUMN, font_sizes[i], -1); if (font_sizes[i] * PANGO_SCALE == fontsel->size) set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter); } } else { GtkTreeIter iter; gboolean found = FALSE; if(gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter)) { for (i = 0; i < G_N_ELEMENTS (font_sizes) && !found; i++) { if (font_sizes[i] * PANGO_SCALE == fontsel->size) { set_cursor_to_iter (GTK_TREE_VIEW (fontsel->size_list), &iter); found = TRUE; } gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter); } } if (!found) { GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list)); gtk_tree_selection_unselect_all (selection); } } /* Set the entry to the new size, rounding to 1 digit, * trimming of trailing 0's and a trailing period */ g_snprintf (buffer, sizeof (buffer), "%.1f", fontsel->size / (1.0 * PANGO_SCALE)); if (strchr (buffer, '.')) { p = buffer + strlen (buffer) - 1; while (*p == '0') p--; if (*p == '.') p--; p[1] = '\0'; } /* Compare, to avoid moving the cursor unecessarily */ if (strcmp (gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry)), buffer) != 0) gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buffer); } static void kry_font_selection_select_best_size (KryFontSelection *fontsel) { kry_font_selection_load_font (fontsel); } void kry_font_selection_set_styles(KryFontSelection *fontsel, gboolean bold, gboolean italic, gboolean underline, gboolean strikethrough) { gtk_toggle_button_set_active(fontsel->toggle_bold, bold); gtk_toggle_button_set_active(fontsel->toggle_italic, italic); gtk_toggle_button_set_active(fontsel->toggle_underline, underline); gtk_toggle_button_set_active(fontsel->toggle_strikethrough, strikethrough); } static void kry_font_selection_set_size (KryFontSelection *fontsel, gint new_size) { if (fontsel->size != new_size) { fontsel->fontsel_info->font_size = new_size / PANGO_SCALE; gui_main_fontsel_revert(fontsel); fontsel->size = new_size; gui_main_fontsel_apply(fontsel); kry_font_selection_show_available_sizes (fontsel, FALSE); kry_font_selection_load_font (fontsel); gtk_widget_queue_draw(GTK_WIDGET(fontsel->preview_area)); if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fontsel->toggle_video_preview))) gui_main_fontsel_revert(fontsel); gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); } } /* If the user hits return in the font size entry, we change to the new font size. */ static void kry_font_selection_size_activate (GtkWidget *w, gpointer data) { KryFontSelection *fontsel; gint new_size; const gchar *text; fontsel = KRY_FONT_SELECTION (data); text = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry)); new_size = (gint) (MAX (0.1, atof (text) * PANGO_SCALE + 0.5)); kry_font_selection_set_size (fontsel, new_size); } static gboolean kry_font_selection_size_focus_out (GtkWidget *w, GdkEventFocus *event, gpointer data) { kry_font_selection_size_activate (w, data); return TRUE; } /* This is called when a size is selected in the list. */ static void kry_font_selection_select_size (GtkTreeSelection *selection, gpointer data) { KryFontSelection *fontsel; GtkTreeModel *model; GtkTreeIter iter; gint new_size; fontsel = KRY_FONT_SELECTION (data); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, SIZE_COLUMN, &new_size, -1); kry_font_selection_set_size (fontsel, new_size * PANGO_SCALE); } } static void kry_font_selection_load_font (KryFontSelection *fontsel) { if (fontsel->font) gdk_font_unref (fontsel->font); fontsel->font = NULL; kry_font_selection_update_preview (fontsel); } static PangoFontDescription * kry_font_selection_get_font_description (KryFontSelection *fontsel) { PangoFontDescription *font_desc; if (fontsel->face) { char *descr = kry_strdup_printf(KRY_LOC "%s, Regular 10", fontsel->face); font_desc = pango_font_description_from_string (descr); kry_free(descr); } else { font_desc = pango_font_description_from_string ("Sans 10"); } return font_desc; } /* This sets the font in the preview entry to the selected font, and tries to make sure that the preview entry is a reasonable size, i.e. so that the text can be seen with a bit of space to spare. But it tries to avoid resizing the entry every time the font changes. This also used to shrink the preview if the font size was decreased, but that made it awkward if the user wanted to resize the window themself. */ static void kry_font_selection_update_preview (KryFontSelection *fontsel) { GtkRcStyle *rc_style; gint new_height; GtkRequisition old_requisition; GtkWidget *preview_entry = fontsel->preview_entry; const gchar *text; return; gtk_widget_get_child_requisition (preview_entry, &old_requisition); rc_style = gtk_rc_style_new (); rc_style->font_desc = kry_font_selection_get_font_description (fontsel); gtk_widget_modify_style (preview_entry, rc_style); gtk_rc_style_unref (rc_style); gtk_widget_size_request (preview_entry, NULL); /* We don't ever want to be over MAX_PREVIEW_HEIGHT pixels high. */ new_height = CLAMP (preview_entry->requisition.height, INITIAL_PREVIEW_HEIGHT, MAX_PREVIEW_HEIGHT); if (new_height > old_requisition.height || new_height < old_requisition.height - 30) gtk_widget_set_size_request (preview_entry, -1, new_height); /* This sets the preview text, if it hasn't been set already. */ text = gtk_entry_get_text (GTK_ENTRY (preview_entry)); if (strlen (text) == 0) gtk_entry_set_text (GTK_ENTRY (preview_entry), (PREVIEW_TEXT)); gtk_editable_set_position (GTK_EDITABLE (preview_entry), 0); } GdkFont* kry_font_selection_get_font_internal (KryFontSelection *fontsel) { if (!fontsel->font) { PangoFontDescription *font_desc = kry_font_selection_get_font_description (fontsel); fontsel->font = gdk_font_from_description_for_display (gtk_widget_get_display (GTK_WIDGET (fontsel)), font_desc); pango_font_description_free (font_desc); } return fontsel->font; } /***************************************************************************** * These functions are the main public interface for getting/setting the font. *****************************************************************************/ GdkFont* kry_font_selection_get_font (KryFontSelection *fontsel) { return kry_font_selection_get_font_internal (fontsel); } gchar * kry_font_selection_get_font_name (KryFontSelection *fontsel) { gchar *result; PangoFontDescription *font_desc = kry_font_selection_get_font_description (fontsel); result = pango_font_description_to_string (font_desc); pango_font_description_free (font_desc); return result; } /* This sets the current font, selecting the appropriate list rows. First we check the fontname is valid and try to find the font family - i.e. the name in the main list. If we can't find that, then just return. Next we try to set each of the properties according to the fontname. Finally we select the font family & style in the lists. */ gboolean kry_font_selection_set_font_name (KryFontSelection *fontsel, const gchar *fontname) { GtkTreeModel *model; GtkTreeIter iter; gboolean valid; char *new_family = NULL; g_return_val_if_fail (GTK_IS_KRY_FONT_SELECTION (fontsel), FALSE); model = gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->family_list)); for (valid = gtk_tree_model_get_iter_first (model, &iter); valid; valid = gtk_tree_model_iter_next (model, &iter)) { char *family; gtk_tree_model_get (model, &iter, FAMILY_NAME_COLUMN, &family, -1); if (!strcmp(family, fontname)) { new_family = family; break; } } if (!new_family) return FALSE; fontsel->face = new_family; set_cursor_to_iter (GTK_TREE_VIEW (fontsel->family_list), &iter); g_object_freeze_notify (G_OBJECT (fontsel)); g_object_notify (G_OBJECT (fontsel), "font_name"); g_object_notify (G_OBJECT (fontsel), "font"); g_object_thaw_notify (G_OBJECT (fontsel)); return TRUE; } /* This returns the text in the preview entry. You should copy the returned text if you need it. */ G_CONST_RETURN gchar* kry_font_selection_get_preview_text (KryFontSelection *fontsel) { return gtk_entry_get_text (GTK_ENTRY (fontsel->preview_entry)); } /* This sets the text in the preview entry. */ void kry_font_selection_set_preview_text (KryFontSelection *fontsel, const gchar *text) { gtk_entry_set_text (GTK_ENTRY (fontsel->preview_entry), text); } /***************************************************************************** * KryFontSelectionDialog *****************************************************************************/ GType kry_font_selection_dialog_get_type (void) { static GType font_selection_dialog_type = 0; if (!font_selection_dialog_type) { static const GTypeInfo fontsel_diag_info = { sizeof (KryFontSelectionDialogClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc) kry_font_selection_dialog_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (KryFontSelectionDialog), 0, /* n_preallocs */ (GInstanceInitFunc) kry_font_selection_dialog_init, }; font_selection_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, "KryFontSelectionDialog", &fontsel_diag_info, (GTypeFlags) 0); } return font_selection_dialog_type; } static void kry_font_selection_dialog_class_init (KryFontSelectionDialogClass *klass) { font_selection_dialog_parent_class = (GtkWindowClass *) g_type_class_peek_parent (klass); } static void kry_font_selection_dialog_init (KryFontSelectionDialog *fontseldiag) { GtkDialog *dialog; gtk_widget_push_composite_child (); dialog = GTK_DIALOG (fontseldiag); gtk_container_set_border_width (GTK_CONTAINER (fontseldiag), 4); gtk_window_set_resizable (GTK_WINDOW (fontseldiag), TRUE); fontseldiag->main_vbox = dialog->vbox; fontseldiag->fontsel = kry_font_selection_new (fontseldiag->fontsel_info); gtk_container_set_border_width (GTK_CONTAINER (fontseldiag->fontsel), 4); gtk_widget_show (fontseldiag->fontsel); gtk_box_pack_start (GTK_BOX (fontseldiag->main_vbox), fontseldiag->fontsel, TRUE, TRUE, 0); /* Create the action area */ fontseldiag->action_area = dialog->action_area; fontseldiag->cancel_button = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); fontseldiag->apply_button = gtk_dialog_add_button (dialog, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY); gtk_widget_hide (fontseldiag->apply_button); fontseldiag->ok_button = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_widget_grab_default (fontseldiag->ok_button); gtk_window_set_title (GTK_WINDOW (fontseldiag), ("Font Selection")); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_widget_pop_composite_child (); } GtkWidget* kry_font_selection_dialog_new (const gchar *title, struct fontsel_info *fontsel_info) { KryFontSelectionDialog *fontseldiag; fontseldiag = (KryFontSelectionDialog *) g_object_new (GTK_TYPE_KRY_FONT_SELECTION_DIALOG, NULL); fontseldiag->fontsel_info = fontsel_info; ((KryFontSelection *) (fontseldiag->fontsel))->fontsel_info = fontsel_info; if(fontsel_info) kry_font_selection_dialog_set_font_name(fontseldiag, fontsel_info->font_name); if(fontsel_info) kry_font_selection_set_size((KryFontSelection *) fontseldiag->fontsel, fontsel_info->font_size * PANGO_SCALE); if(fontsel_info) kry_font_selection_set_styles((KryFontSelection *) fontseldiag->fontsel, fontsel_info->bold, fontsel_info->italic, fontsel_info->underline, fontsel_info->strikethough); if (title) gtk_window_set_title (GTK_WINDOW (fontseldiag), title); return GTK_WIDGET (fontseldiag); } gchar* kry_font_selection_dialog_get_font_name (KryFontSelectionDialog *fsd) { return kry_font_selection_get_font_name (KRY_FONT_SELECTION (fsd->fontsel)); } GdkFont* kry_font_selection_dialog_get_font (KryFontSelectionDialog *fsd) { return kry_font_selection_get_font (KRY_FONT_SELECTION (fsd->fontsel)); } gboolean kry_font_selection_dialog_set_font_name (KryFontSelectionDialog *fsd, const gchar *fontname) { return kry_font_selection_set_font_name (KRY_FONT_SELECTION (fsd->fontsel), fontname); } G_CONST_RETURN gchar* kry_font_selection_dialog_get_preview_text (KryFontSelectionDialog *fsd) { return kry_font_selection_get_preview_text (KRY_FONT_SELECTION (fsd->fontsel)); } void kry_font_selection_dialog_set_preview_text (KryFontSelectionDialog *fsd, const gchar *text) { kry_font_selection_set_preview_text (KRY_FONT_SELECTION (fsd->fontsel), text); }