X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Ffont-selector.cpp;h=6745fcc59c996e9402ecf19230835b0c14ac2678;hb=7ef48edbe66c565cd417c7d1acf2757033be5c61;hp=b73ef5fc1303e51b5f67efd168933ffe87d9383f;hpb=6b15695578f07a3f72c4c9475c1a261a3021472a;p=inkscape.git diff --git a/src/widgets/font-selector.cpp b/src/widgets/font-selector.cpp index b73ef5fc1..6745fcc59 100644 --- a/src/widgets/font-selector.cpp +++ b/src/widgets/font-selector.cpp @@ -7,9 +7,11 @@ * Chris Lahey * Lauris Kaplinski * bulia byak + * Johan Engelen * * Copyright (C) 1999-2001 Ximian, Inc. * Copyright (C) 2002 Lauris Kaplinski + * Copyright (C) -2007 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -24,7 +26,9 @@ #include #include #include +#include +#include #include #include #include @@ -36,6 +40,7 @@ #include "../display/nr-plain-stuff-gdk.h" #include +#include "../desktop.h" #include "font-selector.h" /* SPFontSelector */ @@ -43,13 +48,16 @@ struct SPFontSelector { GtkHBox hbox; - + unsigned int block_emit : 1; - + GtkWidget *family; GtkWidget *style; GtkWidget *size; - + + GtkWidget *family_treeview; + GtkWidget *style_treeview; + NRNameList families; NRStyleList styles; int familyidx; @@ -63,7 +71,7 @@ struct SPFontSelector struct SPFontSelectorClass { GtkHBoxClass parent_class; - + void (* font_set) (SPFontSelector *fsel, font_instance *font); }; @@ -72,24 +80,29 @@ enum { LAST_SIGNAL }; -static void sp_font_selector_class_init(SPFontSelectorClass *c); -static void sp_font_selector_init(SPFontSelector *fsel); -static void sp_font_selector_destroy(GtkObject *object); +static void sp_font_selector_class_init (SPFontSelectorClass *c); +static void sp_font_selector_init (SPFontSelector *fsel); +static void sp_font_selector_destroy (GtkObject *object); -static void sp_font_selector_family_select_row(GtkCList *clist, gint row, gint column, - GdkEvent *event, SPFontSelector *fsel); -static void sp_font_selector_style_select_row(GtkCList *clist, gint row, gint column, - GdkEvent *event, SPFontSelector *fsel); -static void sp_font_selector_size_changed(GtkEditable *editable, SPFontSelector *fsel); +static void sp_font_selector_family_select_row (GtkTreeSelection *selection, + SPFontSelector *fsel); -static void sp_font_selector_emit_set(SPFontSelector *fsel); +static void sp_font_selector_style_select_row (GtkTreeSelection *selection, + SPFontSelector *fsel); -static const gchar *sizes[] = { - "4", "6", "8", "9", "10", "11", "12", "13", "14", - "16", "18", "20", "22", "24", "28", - "32", "36", "40", "48", "56", "64", "72", "144", - NULL -}; +static void sp_font_selector_size_changed (GtkComboBox *combobox, + SPFontSelector *fsel); + +static void sp_font_selector_emit_set (SPFontSelector *fsel); + +namespace { + const char *sizes[] = { + "4", "6", "8", "9", "10", "11", "12", "13", "14", + "16", "18", "20", "22", "24", "28", + "32", "36", "40", "48", "56", "64", "72", "144", + NULL + }; +} static GtkHBoxClass *fs_parent_class = NULL; static guint fs_signals[LAST_SIGNAL] = { 0 }; @@ -114,9 +127,9 @@ GtkType sp_font_selector_get_type() static void sp_font_selector_class_init(SPFontSelectorClass *c) { GtkObjectClass *object_class = (GtkObjectClass *) c; - + fs_parent_class = (GtkHBoxClass* )gtk_type_class(GTK_TYPE_HBOX); - + fs_signals[FONT_SET] = gtk_signal_new ("font_set", GTK_RUN_FIRST, GTK_CLASS_TYPE(object_class), @@ -124,189 +137,237 @@ static void sp_font_selector_class_init(SPFontSelectorClass *c) gtk_marshal_NONE__POINTER, GTK_TYPE_NONE, 1, GTK_TYPE_POINTER); - - object_class->destroy = sp_font_selector_destroy; + + object_class->destroy = sp_font_selector_destroy; } static void sp_font_selector_init(SPFontSelector *fsel) { - gtk_box_set_homogeneous(GTK_BOX(fsel), TRUE); - gtk_box_set_spacing(GTK_BOX(fsel), 4); - - /* Family frame */ - GtkWidget *f = gtk_frame_new(_("Font family")); - gtk_widget_show(f); - gtk_box_pack_start(GTK_BOX(fsel), f, TRUE, TRUE, 0); - - GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); - gtk_widget_show(sw); - gtk_container_set_border_width(GTK_CONTAINER (sw), 4); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); - gtk_container_add(GTK_CONTAINER(f), sw); - - fsel->family = gtk_clist_new (1); - gtk_widget_show (fsel->family); - gtk_clist_set_selection_mode(GTK_CLIST(fsel->family), GTK_SELECTION_SINGLE); - gtk_clist_column_titles_hide(GTK_CLIST(fsel->family)); - gtk_signal_connect(GTK_OBJECT(fsel->family), "select_row", GTK_SIGNAL_FUNC(sp_font_selector_family_select_row), fsel); - gtk_container_add(GTK_CONTAINER(sw), fsel->family); - - if ((font_factory::Default())->Families(&fsel->families)) { - gtk_clist_freeze(GTK_CLIST(fsel->family)); - for (guint i = 0; i < fsel->families.length; i++) { - gtk_clist_append(GTK_CLIST(fsel->family), (gchar **) fsel->families.names + i); - gtk_clist_set_row_data(GTK_CLIST(fsel->family), i, GUINT_TO_POINTER(i)); - } - gtk_clist_thaw(GTK_CLIST(fsel->family)); - } - - /* Style frame */ - f = gtk_frame_new(_("Style")); - gtk_widget_show(f); - gtk_box_pack_start(GTK_BOX (fsel), f, TRUE, TRUE, 0); - - GtkWidget *vb = gtk_vbox_new(FALSE, 4); - gtk_widget_show(vb); - gtk_container_set_border_width(GTK_CONTAINER (vb), 4); - gtk_container_add(GTK_CONTAINER(f), vb); - - sw = gtk_scrolled_window_new(NULL, NULL); - gtk_widget_show(sw); - gtk_container_set_border_width(GTK_CONTAINER (sw), 4); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); - gtk_box_pack_start(GTK_BOX (vb), sw, TRUE, TRUE, 0); - - fsel->style = gtk_clist_new (1); - gtk_widget_show (fsel->style); - gtk_clist_set_selection_mode(GTK_CLIST (fsel->style), GTK_SELECTION_SINGLE); - gtk_clist_column_titles_hide(GTK_CLIST (fsel->style)); - gtk_signal_connect(GTK_OBJECT(fsel->style), "select_row", GTK_SIGNAL_FUNC (sp_font_selector_style_select_row), fsel); - gtk_container_add(GTK_CONTAINER(sw), fsel->style); - - GtkWidget *hb = gtk_hbox_new(FALSE, 4); - gtk_widget_show(hb); - gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 0); - - fsel->size = gtk_combo_new(); - gtk_widget_show (fsel->size); - gtk_combo_set_value_in_list(GTK_COMBO (fsel->size), FALSE, FALSE); - gtk_combo_set_use_arrows(GTK_COMBO (fsel->size), TRUE); - gtk_combo_set_use_arrows_always(GTK_COMBO (fsel->size), TRUE); - gtk_widget_set_size_request(fsel->size, 90, -1); - gtk_signal_connect(GTK_OBJECT(GTK_COMBO(fsel->size)->entry), "changed", GTK_SIGNAL_FUNC(sp_font_selector_size_changed), fsel); - gtk_box_pack_end(GTK_BOX(hb), fsel->size, FALSE, FALSE, 0); - - GtkWidget *l = gtk_label_new(_("Font size:")); - gtk_widget_show(l); - gtk_box_pack_end(GTK_BOX (hb), l, FALSE, FALSE, 0); - - /* Setup strings */ - GList *sl = NULL; - for (int i = 0; sizes[i] != NULL; i++) { - sl = g_list_prepend (sl, (gpointer) sizes[i]); - } - sl = g_list_reverse (sl); - gtk_combo_set_popdown_strings(GTK_COMBO(fsel->size), sl); - g_list_free (sl); - - fsel->familyidx = 0; - fsel->styleidx = 0; - fsel->fontsize = 10.0; - fsel->fontsize_dirty = false; - fsel->font = NULL; + gtk_box_set_homogeneous(GTK_BOX(fsel), TRUE); + gtk_box_set_spacing(GTK_BOX(fsel), 4); + + /* Family frame */ + GtkWidget *f = gtk_frame_new(_("Font family")); + gtk_widget_show (f); + gtk_box_pack_start (GTK_BOX(fsel), f, TRUE, TRUE, 0); + + GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); + gtk_widget_show(sw); + gtk_container_set_border_width(GTK_CONTAINER (sw), 4); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); + gtk_container_add(GTK_CONTAINER(f), sw); + + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + + fsel->family_treeview = gtk_tree_view_new (); + GtkTreeViewColumn *column = gtk_tree_view_column_new (); + GtkCellRenderer *cell = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_set_attributes (column, cell, "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW(fsel->family_treeview), column); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(fsel->family_treeview), FALSE); + Glib::RefPtr store = fontlister->get_font_list(); + gtk_tree_view_set_model (GTK_TREE_VIEW(fsel->family_treeview), GTK_TREE_MODEL (Glib::unwrap (store))); + gtk_container_add(GTK_CONTAINER(sw), fsel->family_treeview); + gtk_widget_show_all (sw); + + GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(fsel->family_treeview)); + g_signal_connect (G_OBJECT(selection), "changed", G_CALLBACK (sp_font_selector_family_select_row), fsel); + g_object_set_data (G_OBJECT(fsel), "family-treeview", fsel->family_treeview); + + + /* Style frame */ + f = gtk_frame_new(_("Style")); + gtk_widget_show(f); + gtk_box_pack_start(GTK_BOX (fsel), f, TRUE, TRUE, 0); + + GtkWidget *vb = gtk_vbox_new(FALSE, 4); + gtk_widget_show(vb); + gtk_container_set_border_width(GTK_CONTAINER (vb), 4); + gtk_container_add(GTK_CONTAINER(f), vb); + + sw = gtk_scrolled_window_new(NULL, NULL); + gtk_widget_show(sw); + gtk_container_set_border_width(GTK_CONTAINER (sw), 4); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); + gtk_box_pack_start(GTK_BOX (vb), sw, TRUE, TRUE, 0); + + fsel->style_treeview = gtk_tree_view_new (); + column = gtk_tree_view_column_new (); + cell = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_set_attributes (column, cell, "text", 0, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW(fsel->style_treeview), column); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(fsel->style_treeview), FALSE); + gtk_container_add(GTK_CONTAINER(sw), fsel->style_treeview); + gtk_widget_show_all (sw); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(fsel->style_treeview)); + g_signal_connect (G_OBJECT(selection), "changed", G_CALLBACK (sp_font_selector_style_select_row), fsel); + + GtkWidget *hb = gtk_hbox_new(FALSE, 4); + gtk_widget_show(hb); + gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 0); + + fsel->size = gtk_combo_box_entry_new_text (); + gtk_widget_set_size_request(fsel->size, 90, -1); + g_signal_connect (G_OBJECT(fsel->size), "changed", G_CALLBACK (sp_font_selector_size_changed), fsel); + gtk_box_pack_end (GTK_BOX(hb), fsel->size, FALSE, FALSE, 0); + + GtkWidget *l = gtk_label_new(_("Font size:")); + gtk_widget_show_all (l); + gtk_box_pack_end(GTK_BOX (hb), l, FALSE, FALSE, 0); + + for (unsigned int n = 0; sizes[n]; ++n) + { + gtk_combo_box_append_text (GTK_COMBO_BOX(fsel->size), sizes[n]); + } + + gtk_widget_show_all (fsel->size); + + fsel->familyidx = 0; + fsel->styleidx = 0; + fsel->fontsize = 10.0; + fsel->fontsize_dirty = false; + fsel->font = NULL; } static void sp_font_selector_destroy(GtkObject *object) { SPFontSelector *fsel = SP_FONT_SELECTOR (object); - + if (fsel->font) { fsel->font->Unref(); fsel->font = NULL; } - + if (fsel->families.length > 0) { nr_name_list_release(&fsel->families); fsel->families.length = 0; } - + if (fsel->styles.length > 0) { nr_style_list_release(&fsel->styles); fsel->styles.length = 0; } - + if (GTK_OBJECT_CLASS(fs_parent_class)->destroy) { GTK_OBJECT_CLASS(fs_parent_class)->destroy(object); } } -static void sp_font_selector_family_select_row(GtkCList *clist, gint row, gint column, - GdkEvent *event, SPFontSelector *fsel) +static void sp_font_selector_family_select_row(GtkTreeSelection *selection, + SPFontSelector *fsel) { - fsel->familyidx = GPOINTER_TO_UINT (gtk_clist_get_row_data (clist, row)); - - if (fsel->styles.length > 0) { - nr_style_list_release (&fsel->styles); - fsel->styles.length = 0; - fsel->styleidx = 0; - } - gtk_clist_clear (GTK_CLIST (fsel->style)); - - if ( static_cast (fsel->familyidx) < fsel->families.length ) { - - const gchar *family = (const gchar *) fsel->families.names[fsel->familyidx]; - - if ((font_factory::Default())->Styles(family, &fsel->styles)) { + GtkTreeIter iter; + GtkTreeModel *model; + GtkListStore *store; + GtkTreePath *path; + GList *list=0; - gtk_clist_freeze(GTK_CLIST(fsel->style)); - for (unsigned int i = 0; i < fsel->styles.length; i++) { - - const gchar *p = (const gchar *) ((fsel->styles.records)[i].name); - - gtk_clist_append(GTK_CLIST(fsel->style), (gchar **) &p); - gtk_clist_set_row_data(GTK_CLIST(fsel->style), static_cast (i), GUINT_TO_POINTER (i)); - } - gtk_clist_thaw(GTK_CLIST(fsel->style)); - gtk_clist_select_row(GTK_CLIST(fsel->style), 0, 0); - } + if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return; + + path = gtk_tree_model_get_path (model, &iter); + gtk_tree_model_get (model, &iter, 1, &list, -1); + fsel->familyidx = gtk_tree_path_get_indices (path)[0]; + fsel->styleidx = 0; + + store = gtk_list_store_new (1, G_TYPE_STRING); + + for ( ; list ; list = list->next ) + { + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, 0, (char*)list->data, -1); } + + gtk_tree_view_set_model (GTK_TREE_VIEW (fsel->style_treeview), GTK_TREE_MODEL (store)); + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, 0); + gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->style_treeview)), path); + gtk_tree_path_free (path); } -static void sp_font_selector_style_select_row(GtkCList *clist, gint row, gint column, - GdkEvent *event, SPFontSelector *fsel) +static void sp_font_selector_style_select_row (GtkTreeSelection *selection, + SPFontSelector *fsel) { - fsel->styleidx = GPOINTER_TO_UINT(gtk_clist_get_row_data(clist, row)); - - if (!fsel->block_emit) { + GtkTreeModel *model; + GtkTreePath *path; + GtkTreeIter iter; + + if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return; + + path = gtk_tree_model_get_path (model, &iter); + fsel->styleidx = gtk_tree_path_get_indices (path)[0]; + + if (!fsel->block_emit) + { sp_font_selector_emit_set (fsel); } } -static void sp_font_selector_size_changed(GtkEditable *editable, SPFontSelector *fsel) +static void sp_font_selector_size_changed( GtkComboBox */*cbox*/, SPFontSelector *fsel ) { - const gchar *sstr = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(fsel->size)->entry)); + char *text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (fsel->size)); gfloat old_size = fsel->fontsize; - fsel->fontsize = MAX(atof(sstr), 0.1); - if ( fabs(fsel->fontsize-old_size) > 0.001) { + + gchar *endptr; + gdouble value = -1; + if (text) { + value = g_strtod (text, &endptr); + if (endptr == text) // conversion failed, non-numeric input + value = -1; + free (text); + } + if (value <= 0) { + return; // could not parse value + } + if (value > 10000) + value = 10000; // somewhat arbitrary, but text&font preview freezes with too huge fontsizes + + fsel->fontsize = value; + if ( fabs(fsel->fontsize-old_size) > 0.001) + { fsel->fontsize_dirty = true; } - - sp_font_selector_emit_set(fsel); + + sp_font_selector_emit_set (fsel); } -static void sp_font_selector_emit_set(SPFontSelector *fsel) +static void sp_font_selector_emit_set (SPFontSelector *fsel) { font_instance *font; - - if (static_cast(fsel->styleidx) < fsel->styles.length - && static_cast(fsel->familyidx) < fsel->families.length) - { - font = (font_factory::Default())->FaceFromDescr ((gchar *) ((fsel->families.names)[fsel->familyidx]), - (gchar *) ((fsel->styles.records)[fsel->styleidx].name)); - } else { - font = NULL; - } - + + GtkTreeSelection *selection_family; + GtkTreeSelection *selection_style; + GtkTreeModel *model_family; + GtkTreeModel *model_style; + GtkTreeIter iter_family; + GtkTreeIter iter_style; + char *family=0, *style=0; + + //We need to check this here since most GtkTreeModel operations are not atomic + //See GtkListStore documenation, Chapter "Atomic Operations" --mderezynski + + model_family = gtk_tree_view_get_model (GTK_TREE_VIEW (fsel->family_treeview)); + if (!model_family) return; + model_style = gtk_tree_view_get_model (GTK_TREE_VIEW (fsel->style_treeview)); + if (!model_style) return; + + selection_family = gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->family_treeview)); + selection_style = gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->style_treeview)); + + if (!gtk_tree_selection_get_selected (selection_family, NULL, &iter_family)) return; + if (!gtk_tree_selection_get_selected (selection_style, NULL, &iter_style)) return; + + gtk_tree_model_get (model_family, &iter_family, 0, &family, -1); + gtk_tree_model_get (model_style, &iter_style, 0, &style, -1); + + if ((!family) || (!style)) return; + + font = (font_factory::Default())->FaceFromUIStrings (family, style); + // FIXME: when a text object uses non-available font, font==NULL and we can't set size // (and the size shown in the widget is invalid). To fix, here we must always get some // default font, exactly the same as sptext uses for on-canvas display, so that @@ -331,65 +392,110 @@ static void sp_font_selector_emit_set(SPFontSelector *fsel) GtkWidget *sp_font_selector_new() { SPFontSelector *fsel = (SPFontSelector*) gtk_type_new(SP_TYPE_FONT_SELECTOR); - + return (GtkWidget *) fsel; } -void sp_font_selector_set_font(SPFontSelector *fsel, font_instance *font, double size) +void sp_font_selector_set_font (SPFontSelector *fsel, font_instance *font, double size) { - GtkCList *fcl = GTK_CLIST(fsel->family); - GtkCList *scl = GTK_CLIST(fsel->style); - - if (font && (fsel->font != font || size != fsel->fontsize)) { - { // select family in the list - gchar family[256]; - font->Family (family, 256); - - unsigned int i; - for (i = 0; i < fsel->families.length; i++) { - if (!strcasecmp (family, (gchar *)fsel->families.names[i])) { - break; - } - } + if (font) + { + Gtk::TreePath path; + font_instance *tempFont = NULL; + + Glib::ustring family = font_factory::Default()->GetUIFamilyString(font->descr); + + try { + path = Inkscape::FontLister::get_instance()->get_row_for_font (family); + } catch (...) { + return; + } + + fsel->block_emit = TRUE; + gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->family_treeview)), path.gobj()); + gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fsel->family_treeview), path.gobj(), NULL, TRUE, 0.5, 0.5); + fsel->block_emit = FALSE; + + GList *list = 0; + GtkTreeIter iter; + GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW(fsel->family_treeview)); + gtk_tree_model_get_iter (model, &iter, path.gobj()); + gtk_tree_model_get (model, &iter, 1, &list, -1); + + unsigned int currentStyleNumber = 0; + unsigned int bestStyleNumber = 0; + + PangoFontDescription *incomingFont = pango_font_description_copy(font->descr); + pango_font_description_unset_fields(incomingFont, PANGO_FONT_MASK_SIZE); + + char *incomingFontString = pango_font_description_to_string(incomingFont); + + tempFont = (font_factory::Default())->FaceFromUIStrings(family.c_str(), (char*)list->data); + + PangoFontDescription *bestMatchForFont = NULL; + if (tempFont) { + bestMatchForFont = pango_font_description_copy(tempFont->descr); + tempFont->Unref(); + tempFont = NULL; + } + + pango_font_description_unset_fields(bestMatchForFont, PANGO_FONT_MASK_SIZE); + + list = list->next; + + while (list) { + currentStyleNumber++; - if (i >= fsel->families.length) { - return; + tempFont = font_factory::Default()->FaceFromUIStrings(family.c_str(), (char*)list->data); + + PangoFontDescription *currentMatchForFont = NULL; + if (tempFont) { + currentMatchForFont = pango_font_description_copy(tempFont->descr); + tempFont->Unref(); + tempFont = NULL; } - - fsel->block_emit = TRUE; - gtk_clist_select_row(fcl, i, 0); - gtk_clist_moveto(fcl, i, 0, 0.66, 0.0); - fsel->block_emit = FALSE; - } - - { // select best-matching style in the list - gchar descr[256]; - font->Name(descr, 256); - PangoFontDescription *descr_ = pango_font_description_from_string(descr); - PangoFontDescription *best_ = pango_font_description_from_string((fsel->styles.records)[0].descr); - guint best_i = 0; - - for (guint i = 0; i < fsel->styles.length; i++) { - PangoFontDescription *try_ = pango_font_description_from_string((fsel->styles.records)[i].descr); - if (pango_font_description_better_match(descr_, best_, try_)) { - pango_font_description_free(best_); - best_ = pango_font_description_from_string((fsel->styles.records)[i].descr); - best_i = i; + + if (currentMatchForFont) { + pango_font_description_unset_fields(currentMatchForFont, PANGO_FONT_MASK_SIZE); + + char *currentMatchString = pango_font_description_to_string(currentMatchForFont); + + if (!strcmp(incomingFontString, currentMatchString) + || pango_font_description_better_match(incomingFont, bestMatchForFont, currentMatchForFont)) { + // Found a better match for the font we are looking for + pango_font_description_free(bestMatchForFont); + bestMatchForFont = pango_font_description_copy(currentMatchForFont); + bestStyleNumber = currentStyleNumber; } - pango_font_description_free(try_); + + g_free(currentMatchString); + + pango_font_description_free(currentMatchForFont); } - gtk_clist_select_row(scl, best_i, 0); - gtk_clist_moveto(scl, best_i, 0, 0.66, 0.0); + list = list->next; } - if (size != fsel->fontsize) { + if (bestMatchForFont) + pango_font_description_free(bestMatchForFont); + if (incomingFont) + pango_font_description_free(incomingFont); + g_free(incomingFontString); + + GtkTreePath *path_c = gtk_tree_path_new (); + gtk_tree_path_append_index (path_c, bestStyleNumber); + gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (fsel->style_treeview)), path_c); + gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fsel->style_treeview), path_c, NULL, TRUE, 0.5, 0.5); + + if (size != fsel->fontsize) + { gchar s[8]; g_snprintf (s, 8, "%.5g", size); // UI, so printf is ok - gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (fsel->size)->entry), s); + gtk_entry_set_text (GTK_ENTRY (GTK_BIN(fsel->size)->child), s); fsel->fontsize = size; } } + } font_instance* sp_font_selector_get_font(SPFontSelector *fsel) @@ -397,7 +503,7 @@ font_instance* sp_font_selector_get_font(SPFontSelector *fsel) if (fsel->font) { fsel->font->Ref(); } - + return fsel->font; } @@ -411,7 +517,7 @@ double sp_font_selector_get_size(SPFontSelector *fsel) struct SPFontPreview { GtkDrawingArea darea; - + font_instance *font; raster_font *rfont; gchar *phrase; @@ -453,11 +559,11 @@ static void sp_font_preview_class_init (SPFontPreviewClass *c) { GtkObjectClass *object_class = (GtkObjectClass *) c; GtkWidgetClass *widget_class = (GtkWidgetClass *) c; - + fp_parent_class = (GtkDrawingAreaClass*) gtk_type_class(GTK_TYPE_DRAWING_AREA); - + object_class->destroy = sp_font_preview_destroy; - + widget_class->size_request = sp_font_preview_size_request; widget_class->expose_event = sp_font_preview_expose; } @@ -470,26 +576,26 @@ static void sp_font_preview_init(SPFontPreview *fprev) static void sp_font_preview_destroy(GtkObject *object) { SPFontPreview *fprev = SP_FONT_PREVIEW (object); - + if (fprev->rfont) { fprev->rfont->Unref(); fprev->rfont = NULL; } - + if (fprev->font) { fprev->font->Unref(); fprev->font = NULL; } - + g_free(fprev->phrase); fprev->phrase = NULL; - + if (GTK_OBJECT_CLASS (fp_parent_class)->destroy) { GTK_OBJECT_CLASS (fp_parent_class)->destroy(object); } } -void sp_font_preview_size_request(GtkWidget *widget, GtkRequisition *req) +void sp_font_preview_size_request(GtkWidget */*widget*/, GtkRequisition *req) { req->width = 256; req->height = 32; @@ -500,17 +606,17 @@ void sp_font_preview_size_request(GtkWidget *widget, GtkRequisition *req) static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) { SPFontPreview *fprev = SP_FONT_PREVIEW(widget); - + if (GTK_WIDGET_DRAWABLE (widget)) { if (fprev->rfont) { - + int glyphs[SPFP_MAX_LEN]; double hpos[SPFP_MAX_LEN]; - + font_instance *tface = fprev->rfont->daddy; - + double theSize = NR_MATRIX_DF_EXPANSION (&fprev->rfont->style.transform); - + gchar const *p; if (fprev->phrase) { p = fprev->phrase; @@ -519,13 +625,13 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) * text has been entered) to get a preview of the font. Choose * some representative characters that users of your locale will be * interested in. */ - p = _("AaBbCcIiPpQq12368.;/()"); + p = _("AaBbCcIiPpQq12369$\342\202\254\302\242?.;/()"); } int len = 0; - + NRRect bbox; bbox.x0 = bbox.y0 = bbox.x1 = bbox.y1 = 0.0; - + text_wrapper* str_text=new text_wrapper; str_text->SetDefaultFont(tface); str_text->AppendUTF8(p,-1); @@ -549,16 +655,18 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) } NR::Point base_pt(str_text->glyph_text[i].x, str_text->glyph_text[i].y); base_pt *= theSize; - + glyphs[len] = str_text->glyph_text[i].gl; hpos[len] = base_pt[0]; len++; if ( curF ) { - NR::Rect nbbox = curF->BBox(str_text->glyph_text[i].gl); - bbox.x0 = MIN(bbox.x0, base_pt[NR::X] + theSize * (nbbox.min())[0]); - bbox.y0 = MIN(bbox.y0, base_pt[NR::Y] - theSize * (nbbox.max())[1]); - bbox.x1 = MAX(bbox.x1, base_pt[NR::X] + theSize * (nbbox.max())[0]); - bbox.y1 = MAX(bbox.y1, base_pt[NR::Y] - theSize * (nbbox.min())[1]); + NR::Maybe nbbox = curF->BBox(str_text->glyph_text[i].gl); + if (nbbox) { + bbox.x0 = MIN(bbox.x0, base_pt[NR::X] + theSize * (nbbox->min())[0]); + bbox.y0 = MIN(bbox.y0, base_pt[NR::Y] - theSize * (nbbox->max())[1]); + bbox.x1 = MAX(bbox.x1, base_pt[NR::X] + theSize * (nbbox->max())[0]); + bbox.y1 = MAX(bbox.y1, base_pt[NR::Y] - theSize * (nbbox->min())[1]); + } } } if ( curF ) { @@ -566,10 +674,10 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) } } } - + // XXX: FIXME: why does this code ignore adv.y - /* while (p && *p && (len < SPFP_MAX_LEN)) { - unsigned int unival; + /* while (p && *p && (len < SPFP_MAX_LEN)) { + unsigned int unival; NRRect gbox; unival = g_utf8_get_char (p); glyphs[len] = tface->MapUnicodeChar( unival); @@ -584,10 +692,10 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) len += 1; p = g_utf8_next_char (p); }*/ - + float startx = (widget->allocation.width - (bbox.x1 - bbox.x0)) / 2; float starty = widget->allocation.height - (widget->allocation.height - (bbox.y1 - bbox.y0)) / 2 - bbox.y1; - + for (int y = event->area.y; y < event->area.y + event->area.height; y += 64) { for (int x = event->area.x; x < event->area.x + event->area.width; x += 64) { NRPixBlock pb, m; @@ -599,7 +707,7 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) nr_pixblock_setup_extern(&pb, NR_PIXBLOCK_MODE_R8G8B8, x0, y0, x1, y1, ps, 3 * (x1 - x0), FALSE, FALSE); nr_pixblock_setup_fast(&m, NR_PIXBLOCK_MODE_A8, x0, y0, x1, y1, TRUE); pb.empty = FALSE; - + PangoFont *curPF = NULL; font_instance *curF = NULL; raster_font *curRF = NULL; @@ -634,7 +742,7 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) if (curF) { curF->Unref(); } - + nr_blit_pixblock_mask_rgba32(&pb, &m, fprev->rgba); gdk_draw_rgb_image(widget->window, widget->style->black_gc, x0, y0, x1 - x0, y1 - y0, @@ -644,48 +752,54 @@ static gint sp_font_preview_expose(GtkWidget *widget, GdkEventExpose *event) nr_pixelstore_16K_free(ps); } } - + delete str_text; - + } else { nr_gdk_draw_gray_garbage(widget->window, widget->style->black_gc, event->area.x, event->area.y, event->area.width, event->area.height); } } - + return TRUE; } GtkWidget * sp_font_preview_new() { GtkWidget *w = (GtkWidget*) gtk_type_new(SP_TYPE_FONT_PREVIEW); - + return w; } void sp_font_preview_set_font(SPFontPreview *fprev, font_instance *font, SPFontSelector *fsel) { - if (font != fprev->font) { - if (font) { + if (font) + { font->Ref(); } - if (fprev->font) { + + if (fprev->font) + { fprev->font->Unref(); } + fprev->font = font; - - if (fprev->rfont) { + + if (fprev->rfont) + { fprev->rfont->Unref(); fprev->rfont=NULL; } - if (fprev->font) { + + if (fprev->font) + { NRMatrix flip; nr_matrix_set_scale (&flip, fsel->fontsize, -fsel->fontsize); fprev->rfont = fprev->font->RasterFont(flip, 0); } + if (GTK_WIDGET_DRAWABLE (fprev)) gtk_widget_queue_draw (GTK_WIDGET (fprev)); - } } void sp_font_preview_set_rgba32(SPFontPreview *fprev, guint32 rgba)