/* gtkDPSfontsel.c --- File renamed from gtkDPSfontpanel.c by Masatake YAMATO */ /* gtkDPSfontpanel.c --- DPS font panel widget * Copyright (C) 1998 Hideki FUJIMOTO * * Author: Hideki FUJIMOTO * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "config.h" #include "gtkDPSfontsel.h" #include "gtkDPSarea.h" #include "gdkDPSfont.h" #include "fonts.h" #include "gtkDPSintl.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Default preview area size */ #define AREA_SIZE_WIDTH 288 #define AREA_SIZE_HEIGHT 70 static void gtk_dps_font_selection_class_init (GtkDPSFontSelectionClass * klass); static void gtk_dps_font_selection_init (GtkDPSFontSelection * fontsel); static void gtk_dps_font_selection_dialog_class_init (GtkDPSFontSelectionDialogClass * klass); static void gtk_dps_font_selection_dialog_init (GtkDPSFontSelectionDialog * fontseldiag); static GtkWidget * font_box_new (GtkDPSFontSelection * fontsel, const gchar *label_str, GtkWidget ** slot, GtkSignalFunc func); static GtkWidget * font_family_box_new (GtkDPSFontSelection * fontsel); static GtkWidget * font_face_box_new (GtkDPSFontSelection * fontsel); static GtkWidget * font_size_box_new (GtkDPSFontSelection * fontsel); static void font_box_install_list_items(GtkDPSFontSelection * fontsel); static void font_box_install_list_item (GdkDPSFontFamily * font_family, gpointer user_data); static void font_face_box_install_list_items (GtkDPSFontSelection * fontsel, GSList * type_faces_list); static GtkVPanedClass *gtk_dps_font_selection_parent_class; static GtkWindowClass *gtk_dps_font_dialog_parent_class; enum { FONT_CHANGED, PREVIEW_TEXT_CHANGED, DRAW_PREVIEW_TEXT, LAST_SIGNAL }; static guint gtk_dps_font_selection_signals[LAST_SIGNAL] = {0}; enum { ARG_0, ARG_FONT_NAME, ARG_FONT_SIZE, ARG_PREVIEW_TEXT }; const gchar *font_size_defaults [] = {"8", "10", "12", "14", "16", "24", "36", "48", "64", "128", "256"}; const gchar * preview_text_default = "abcdefghijk ABCDEFGHIJK"; static void gtk_dps_font_selection_set_arg(GtkObject * object, GtkArg * arg, guint arg_id); static void gtk_dps_font_selection_get_arg(GtkObject * object, GtkArg * arg, guint arg_id); static void gtk_dps_font_selection_destroy (GtkObject * object); static void gtk_dps_font_selection_realize (GtkWidget * widget, gpointer data); static void gtk_dps_font_selection_change_family (GtkWidget * widget, GdkEventButton * event, gpointer data); static void gtk_dps_font_selection_change_face (GtkWidget * widget, GdkEventButton * event, gpointer data); static void gtk_dps_font_selection_change_size_via_entry (GtkWidget * widget, gpointer data); static void gtk_dps_font_selection_change_size_via_list (GtkWidget * widget, GdkEventButton * event, gpointer data); static void gtk_dps_font_selection_draw_lazy(GtkDPSArea *area, GdkRectangle *x_rectangle, GdkDPSRectangle *dps_rectangle, gpointer data); static void gtk_dps_font_selection_coordtr_update(GtkDPSArea *area, GdkDPSCoordtr * coordtr, gpointer data); static void gtk_dps_font_selection_propagate_preview_text_change(GtkEditable *editable, gpointer user_data); static void gtk_real_dps_font_selection_font_change (GtkDPSFontSelection *fontsel, const gchar * font_name, const gint font_size); static void gtk_real_dps_font_selection_preview_change (GtkDPSFontSelection *fontsel, const gchar * preview_text); static gboolean gtk_real_dps_font_selection_draw_preview_text(GtkDPSFontSelection * fontsel, DPSContext raw_ctxt, const gchar * font_name, const gint font_size, const gchar * preview_text); static void gtk_dps_font_selection_draw_preview_text(GtkDPSFontSelection *fontsel); /* Marshaler */ static void gtk_marshal_BOOL__POINTER_POINTER_INT_POINTER (GtkObject *object, GtkSignalFunc func, gpointer func_data, GtkArg *args); /* * Initialize */ GtkWidget * gtk_dps_font_selection_new (void) { GtkDPSFontSelection * fontsel; fontsel = gtk_type_new (gtk_dps_font_selection_get_type ()); return GTK_WIDGET (fontsel); } GtkType gtk_dps_font_selection_get_type (void) { static GtkType dps_font_selection_type = 0; if (!dps_font_selection_type) { GtkTypeInfo dps_font_selection_info = { "GtkDPSFontSelection", sizeof (GtkDPSFontSelection), sizeof (GtkDPSFontSelectionClass), (GtkClassInitFunc) gtk_dps_font_selection_class_init, (GtkObjectInitFunc) gtk_dps_font_selection_init, NULL, NULL }; dps_font_selection_type = gtk_type_unique(gtk_vpaned_get_type (), &dps_font_selection_info); } return dps_font_selection_type; } static void gtk_dps_font_selection_class_init (GtkDPSFontSelectionClass * klass) { GtkObjectClass *object_class = (GtkObjectClass *) klass; /* GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; */ gtk_dps_font_selection_parent_class = gtk_type_class (gtk_vpaned_get_type ()); gtk_object_add_arg_type ("GtkDPSFontSelection::font_name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_FONT_NAME); gtk_object_add_arg_type ("GtkDPSFontSelection::font_size", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FONT_SIZE); gtk_object_add_arg_type ("GtkDPSFontSelection::preview_text", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_PREVIEW_TEXT); /* Signal setup */ gtk_dps_font_selection_signals[FONT_CHANGED] = gtk_signal_new ("font_changed", GTK_RUN_FIRST, object_class->type, GTK_SIGNAL_OFFSET (GtkDPSFontSelectionClass, font_changed), gtk_marshal_NONE__POINTER_INT, GTK_TYPE_NONE, 2, GTK_TYPE_POINTER, GTK_TYPE_INT); klass->font_changed = gtk_real_dps_font_selection_font_change; gtk_dps_font_selection_signals[PREVIEW_TEXT_CHANGED] = gtk_signal_new ("preview_text_changed", GTK_RUN_FIRST, object_class->type, GTK_SIGNAL_OFFSET (GtkDPSFontSelectionClass, preview_text_changed), gtk_marshal_NONE__STRING, GTK_TYPE_NONE, 1, GTK_TYPE_STRING); klass->preview_text_changed = gtk_real_dps_font_selection_preview_change; gtk_dps_font_selection_signals[DRAW_PREVIEW_TEXT] = gtk_signal_new ("draw_preview_text", GTK_RUN_LAST, object_class->type, GTK_SIGNAL_OFFSET (GtkDPSFontSelectionClass, draw_preview_text), gtk_marshal_BOOL__POINTER_POINTER_INT_POINTER, GTK_TYPE_BOOL, 4, GTK_TYPE_POINTER, GTK_TYPE_STRING, GTK_TYPE_INT, GTK_TYPE_STRING); klass->draw_preview_text = gtk_real_dps_font_selection_draw_preview_text; gtk_object_class_add_signals (object_class, gtk_dps_font_selection_signals, LAST_SIGNAL); object_class->set_arg = gtk_dps_font_selection_set_arg; object_class->get_arg = gtk_dps_font_selection_get_arg; object_class->destroy = gtk_dps_font_selection_destroy; } static void gtk_dps_font_selection_init (GtkDPSFontSelection * fontsel) { GtkWidget *display_frame; GtkWidget *selection_box; GtkWidget *selection_and_entry; fontsel->font_name = NULL; fontsel->type_face = NULL; fontsel->font_size = 0; fontsel->type_face_list_item = NULL; fontsel->size_list_item = NULL; fontsel->fonts_data = gdk_dps_font_families_list_new(NULL); #if 0 gdk_dps_font_families_list_dump(fontsel->fonts_data, NULL); #endif /* 1, 0 */ fontsel->disable_default_previewer = FALSE; /* fontsel [DISPLAY] -- display_frame ---- dps_area (?) == [paned(self)] =o= -- selection_and_entry [SELECTION] ---- selection_box ------ family ------ face ------ size -- input_entry */ /* [DISPLAY] */ display_frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (display_frame), GTK_SHADOW_IN); gtk_paned_add1(GTK_PANED(fontsel), display_frame); gtk_container_set_border_width (GTK_CONTAINER (display_frame), 4); gtk_widget_show (display_frame); /* -- dps area */ fontsel->dps_area = gtk_dps_area_new (1); gtk_dps_area_size (GTK_DPS_AREA(fontsel->dps_area), AREA_SIZE_WIDTH, AREA_SIZE_HEIGHT); /* TODO */ gtk_container_add (GTK_CONTAINER (display_frame), fontsel->dps_area); gtk_widget_show(fontsel->dps_area); /* [SELECTION] */ selection_and_entry = gtk_vbox_new(FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (selection_and_entry), 4); selection_box = gtk_hbox_new (FALSE, 3); gtk_container_set_border_width (GTK_CONTAINER (selection_box), 0); gtk_widget_set_usize (selection_box, 300, 160); gtk_box_pack_start (GTK_BOX(selection_and_entry), selection_box, TRUE, TRUE, 0); fontsel->input_entry = gtk_entry_new(); gtk_box_pack_start (GTK_BOX(selection_and_entry), fontsel->input_entry, FALSE, FALSE, 0); gtk_entry_set_text(GTK_ENTRY (fontsel->input_entry), preview_text_default); gtk_signal_connect (GTK_OBJECT (fontsel->input_entry), "changed", (GtkSignalFunc) gtk_dps_font_selection_propagate_preview_text_change, fontsel); gtk_widget_show(fontsel->input_entry); gtk_paned_add2(GTK_PANED(fontsel), selection_and_entry); { GtkWidget * family_box; GtkWidget * face_box; GtkWidget * size_box; family_box = font_family_box_new(fontsel); face_box = font_face_box_new(fontsel); fontsel->font_name = NULL; font_box_install_list_items(fontsel); g_return_if_fail(fontsel->font_name); gtk_box_pack_start (GTK_BOX(selection_box), family_box, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(selection_box), face_box, TRUE, TRUE, 0); gtk_widget_show (family_box); gtk_widget_show (face_box); size_box = font_size_box_new (fontsel); gtk_box_pack_start (GTK_BOX(selection_box), size_box, FALSE, TRUE, 0); gtk_widget_show (size_box); } gtk_widget_show (selection_box); gtk_widget_show (selection_and_entry); gtk_signal_connect (GTK_OBJECT(fontsel->dps_area), "coordtr_update", (GtkSignalFunc)gtk_dps_font_selection_coordtr_update, fontsel); gtk_signal_connect (GTK_OBJECT(fontsel->dps_area), "draw_lazy", (GtkSignalFunc)gtk_dps_font_selection_draw_lazy, fontsel); gtk_signal_connect (GTK_OBJECT(fontsel->dps_area), "realize", (GtkSignalFunc)gtk_dps_font_selection_realize, fontsel); } static GtkWidget * font_box_new (GtkDPSFontSelection * fontsel, const gchar *label_str, GtkWidget ** slot, GtkSignalFunc func) { GtkWidget *main_box; GtkWidget *label; GtkWidget *frame; GtkWidget *win; main_box = gtk_vbox_new (FALSE, 3); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (main_box), frame, FALSE, FALSE, 0); gtk_widget_show (frame); label = gtk_label_new (label_str); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_signal_connect (GTK_OBJECT (win), "button_press_event", (GtkSignalFunc)func , fontsel); gtk_box_pack_start (GTK_BOX (main_box), win, TRUE, TRUE, 0); gtk_widget_show (win); *slot = gtk_list_new (); gtk_list_set_selection_mode (GTK_LIST (*slot), GTK_SELECTION_BROWSE); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (win), *slot); gtk_widget_show (*slot); return main_box; } static GtkWidget * font_family_box_new (GtkDPSFontSelection * fontsel) { GtkWidget * box = font_box_new(fontsel, _("Family"), &fontsel->family_box, gtk_dps_font_selection_change_family); return box; } static GtkWidget * font_face_box_new (GtkDPSFontSelection * fontsel) { GtkWidget * box = font_box_new(fontsel, _("Face"), &fontsel->face_box, gtk_dps_font_selection_change_face); return box; } static GtkWidget * font_size_box_new (GtkDPSFontSelection * fontsel) { GtkWidget *main_box; GtkWidget *frame; GtkWidget *label; GtkWidget *win; GtkWidget *list_item; gint lots_of_sizes_entries = sizeof (font_size_defaults) / sizeof (gchar *); gint i; /* 8(0), 10(1), 12(2), 14(3), 16(4): Select 16 point as default font size */ const int default_font_size_index = 4; main_box = gtk_vbox_new (FALSE, 3); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (main_box), frame, FALSE, FALSE, 0); gtk_widget_show (frame); label = gtk_label_new ( _("Size")); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); fontsel->size_entry = gtk_entry_new (); gtk_widget_set_usize (fontsel->size_entry, 60, 20); gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), font_size_defaults[default_font_size_index]); fontsel->font_size = atoi(font_size_defaults[default_font_size_index]); gtk_signal_connect (GTK_OBJECT (fontsel->size_entry), "activate", (GtkSignalFunc) gtk_dps_font_selection_change_size_via_entry, fontsel); gtk_box_pack_start (GTK_BOX (main_box), fontsel->size_entry, FALSE, FALSE, 0); gtk_widget_show (fontsel->size_entry); win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_signal_connect (GTK_OBJECT (win), "button_press_event", (GtkSignalFunc) gtk_dps_font_selection_change_size_via_list, fontsel); gtk_box_pack_start (GTK_BOX (main_box), win, TRUE, TRUE, 0); gtk_widget_show (win); fontsel->size_box = gtk_list_new (); gtk_list_set_selection_mode (GTK_LIST (fontsel->size_box), GTK_SELECTION_BROWSE); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (win), fontsel->size_box); gtk_widget_show (fontsel->size_box); for (i = 0; i < lots_of_sizes_entries; i++) { list_item = gtk_list_item_new_with_label (font_size_defaults[i]); gtk_container_add (GTK_CONTAINER (fontsel->size_box), list_item); gtk_object_set_user_data (GTK_OBJECT (list_item), (gpointer)font_size_defaults[i]); if (i == default_font_size_index) { gtk_list_item_select (GTK_LIST_ITEM (list_item)); fontsel->size_list_item = list_item; } else gtk_list_item_deselect (GTK_LIST_ITEM (list_item)); gtk_widget_show (list_item); } return main_box; } static void font_box_install_list_items(GtkDPSFontSelection * fontsel) { g_slist_foreach(fontsel->fonts_data, (GFunc) font_box_install_list_item, fontsel); } static void font_box_install_list_item (GdkDPSFontFamily * font_family, gpointer user_data) { GtkDPSFontSelection * fontsel = user_data; GtkWidget *list_item; list_item = gtk_list_item_new_with_label (font_family->font_family); gtk_container_add (GTK_CONTAINER (fontsel->family_box), list_item); gtk_object_set_user_data (GTK_OBJECT (list_item), font_family); gtk_list_item_deselect (GTK_LIST_ITEM (list_item)); gtk_widget_show (list_item); if (!fontsel->font_name) { GSList * type_faces_list; GdkDPSTypeFace * type_face; type_faces_list = font_family->type_faces_list; g_return_if_fail (type_faces_list); type_face = g_slist_nth_data (type_faces_list, 0); g_return_if_fail (type_face); g_return_if_fail (type_face->font_name); gtk_list_item_select (GTK_LIST_ITEM (list_item)); fontsel->font_name = type_face->font_name; font_face_box_install_list_items(fontsel, type_faces_list); g_return_if_fail (fontsel->font_name == type_face->font_name); } } static void font_face_box_install_list_items (GtkDPSFontSelection * fontsel, GSList * type_faces_list) { GSList * current; GdkDPSTypeFace * current_type_face; GtkWidget *list_item = NULL; GtkWidget *first_item = NULL; gint selected = 0; g_return_if_fail(fontsel); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel)); current_type_face = g_slist_nth_data(type_faces_list, 0); if (current_type_face) { g_return_if_fail(current_type_face->font_name); fontsel->font_name = current_type_face->font_name; } else fontsel->font_name = NULL; for (current = type_faces_list; current; current = g_slist_next(current)) { if (current->data) { current_type_face = (GdkDPSTypeFace *)current->data; if (!current_type_face->type_face) goto type_face_is_null; list_item = gtk_list_item_new_with_label (current_type_face->type_face); } else { type_face_is_null: current_type_face = NULL; list_item = gtk_list_item_new_with_label ("(void)"); } gtk_container_add (GTK_CONTAINER (fontsel->face_box), list_item); gtk_object_set_user_data (GTK_OBJECT (list_item), current_type_face); /* current? */ /* Set first item */ if (current == type_faces_list) first_item = list_item; if (!selected && current_type_face && current_type_face->type_face /* ??? */ && fontsel->type_face && (0 == strcmp (fontsel->type_face, current_type_face->type_face))) { gtk_list_item_select(GTK_LIST_ITEM(list_item)); fontsel->font_name = current_type_face->font_name; fontsel->type_face_list_item = list_item; selected = 1; } else gtk_list_item_deselect (GTK_LIST_ITEM (list_item)); gtk_widget_show (list_item); } if (!selected) { /* type_face_is_null */ gtk_list_item_select (GTK_LIST_ITEM (first_item)); fontsel->type_face_list_item = first_item; current_type_face = (GdkDPSTypeFace *)type_faces_list->data; g_return_if_fail(current_type_face->font_name); fontsel->font_name = current_type_face->font_name; } } static void gtk_dps_font_selection_set_arg(GtkObject * object, GtkArg * arg, guint arg_id) { GtkDPSFontSelection * fontsel; fontsel = GTK_DPS_FONT_SELECTION(object); switch (arg_id) { case ARG_FONT_NAME: gtk_dps_font_selection_set_font_name(fontsel, GTK_VALUE_STRING(*arg)); break; case ARG_FONT_SIZE: gtk_dps_font_selection_set_font_size(fontsel, GTK_VALUE_INT(*arg)); break; case ARG_PREVIEW_TEXT: gtk_dps_font_selection_set_preview_text(fontsel, GTK_VALUE_STRING(*arg)); break; default: break; } } static void gtk_dps_font_selection_get_arg(GtkObject * object, GtkArg * arg, guint arg_id) { GtkDPSFontSelection * fontsel; gchar * tmp; fontsel = GTK_DPS_FONT_SELECTION(object); switch (arg_id) { case ARG_FONT_NAME: tmp = gtk_dps_font_selection_get_font_name(fontsel); GTK_VALUE_STRING(*arg) = g_strdup(tmp); break; case ARG_FONT_SIZE: GTK_VALUE_INT(*arg) = gtk_dps_font_selection_get_font_size(fontsel); break; case ARG_PREVIEW_TEXT: tmp = gtk_dps_font_selection_get_preview_text(fontsel); GTK_VALUE_STRING(*arg) = g_strdup(tmp); break; default: arg->type = GTK_TYPE_INVALID; break; } } static void gtk_dps_font_selection_destroy (GtkObject * object) { GtkDPSFontSelection *fontsel; g_return_if_fail (object != NULL); g_return_if_fail (GTK_IS_DPS_FONT_SELECTION (object)); fontsel = GTK_DPS_FONT_SELECTION(object); gdk_dps_font_families_list_free(fontsel->fonts_data); fontsel->fonts_data = NULL; fontsel->dps_area = NULL; fontsel->family_box = NULL; fontsel->face_box = NULL; fontsel->size_box = NULL; fontsel->size_entry = NULL; fontsel->input_entry = NULL; fontsel->type_face_list_item = NULL; fontsel->size_list_item = NULL; if (GTK_OBJECT_CLASS (gtk_dps_font_selection_parent_class)->destroy) (* GTK_OBJECT_CLASS (gtk_dps_font_selection_parent_class)->destroy) (object); } static void gtk_dps_font_selection_realize (GtkWidget * widget, gpointer data) { GtkDPSFontSelection * fontsel; g_return_if_fail (data); g_return_if_fail (GTK_DPS_FONT_SELECTION(data)); fontsel = GTK_DPS_FONT_SELECTION(data); gtk_signal_emit (GTK_OBJECT(data), gtk_dps_font_selection_signals[FONT_CHANGED], fontsel->font_name, fontsel->font_size); } gchar * gtk_dps_font_selection_get_font_name (GtkDPSFontSelection *fontsel) { g_return_val_if_fail(fontsel, NULL); g_return_val_if_fail(fontsel->font_name, NULL); return fontsel->font_name; } gint gtk_dps_font_selection_get_font_size (GtkDPSFontSelection *fontsel) { gchar * str; gint val; g_return_val_if_fail(fontsel, 0); g_return_val_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel), 0); str = gtk_entry_get_text (GTK_ENTRY (fontsel->size_entry)); if (strlen (str) < 1) return fontsel->font_size; val = atoi (str); if (val == 0) return fontsel->font_size; fontsel->font_size = val; return fontsel->font_size; } /* In case of cliked at the window box of font family, make font face list in the window box of font face. */ static void gtk_dps_font_selection_change_family (GtkWidget * widget, GdkEventButton * event, gpointer data) { GtkWidget *event_widget; GtkDPSFontSelection * fontsel; GdkDPSFontFamily * font_family; gchar * font_name_cache; g_return_if_fail(data); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(data)); fontsel = GTK_DPS_FONT_SELECTION(data); g_return_if_fail(event != NULL); g_return_if_fail(widget != NULL); event_widget = gtk_get_event_widget ((GdkEvent *) event); if (!GTK_IS_LIST_ITEM (event_widget)) return; font_family = (GdkDPSFontFamily *) gtk_object_get_user_data (GTK_OBJECT (event_widget)); if (fontsel->type_face_list_item) gtk_list_item_deselect (GTK_LIST_ITEM (fontsel->type_face_list_item)); fontsel->type_face_list_item = NULL; gtk_list_clear_items (GTK_LIST (fontsel->face_box), 0, -1); gdk_flush(); font_name_cache = fontsel->font_name; font_face_box_install_list_items(fontsel, font_family->type_faces_list); if (font_name_cache != fontsel->font_name) gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], gtk_dps_font_selection_get_font_name(fontsel), gtk_dps_font_selection_get_font_size(fontsel)); } /* In case of cliked at the window box of font face, change font face list in the window box of font face. */ static void gtk_dps_font_selection_change_face (GtkWidget * widget, GdkEventButton * event, gpointer data) { GtkWidget *event_widget; GtkDPSFontSelection * fontsel; GdkDPSTypeFace * buf; gboolean emitp; g_return_if_fail(data); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(data)); fontsel = GTK_DPS_FONT_SELECTION(data); g_return_if_fail(event != NULL); g_return_if_fail(widget != NULL); event_widget = gtk_get_event_widget ((GdkEvent *) event); if (!GTK_IS_LIST_ITEM (event_widget)) return; buf = (GdkDPSTypeFace *)gtk_object_get_user_data (GTK_OBJECT (event_widget)); if (!buf) return ; if (fontsel->font_name == buf->font_name) emitp = FALSE; else emitp = TRUE; fontsel->font_name = buf->font_name; fontsel->type_face = buf->type_face; if (fontsel->type_face_list_item) gtk_list_item_deselect (GTK_LIST_ITEM (fontsel->type_face_list_item)); fontsel->type_face_list_item = event_widget; if (emitp) gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], gtk_dps_font_selection_get_font_name(fontsel), gtk_dps_font_selection_get_font_size(fontsel)); } static void gtk_dps_font_selection_change_size_via_entry (GtkWidget * widget, gpointer data) { GtkEntry * entry; GtkDPSFontSelection * fontsel; gint tmp; g_return_if_fail(widget); g_return_if_fail(data); g_return_if_fail(GTK_IS_ENTRY(widget)); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(data)); entry = GTK_ENTRY(widget); fontsel = GTK_DPS_FONT_SELECTION(data); if (fontsel->size_list_item) gtk_list_item_deselect(GTK_LIST_ITEM (fontsel->size_list_item)); fontsel->size_list_item = NULL; tmp = fontsel->font_size; gtk_dps_font_selection_get_font_size(fontsel); if (tmp != fontsel->font_size) gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], gtk_dps_font_selection_get_font_name(fontsel), fontsel->font_size); } static void gtk_dps_font_selection_change_size_via_list (GtkWidget * widget, GdkEventButton * event, gpointer data) { GtkWidget *event_widget; GtkDPSFontSelection * fontsel; gchar * buf; gint tmp; g_return_if_fail(data); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(data)); fontsel = GTK_DPS_FONT_SELECTION(data); event_widget = gtk_get_event_widget ((GdkEvent *) event); if (!GTK_IS_LIST_ITEM (event_widget)) return ; buf = (gchar *) gtk_object_get_user_data (GTK_OBJECT (event_widget)); if (!buf) return ; gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buf); /* deselect */ if (fontsel->size_list_item) gtk_list_item_deselect (GTK_LIST_ITEM (fontsel->size_list_item)); fontsel->size_list_item = event_widget; tmp = fontsel->font_size; gtk_dps_font_selection_get_font_size(fontsel); if (tmp != fontsel->font_size) gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], gtk_dps_font_selection_get_font_name(fontsel), fontsel->font_size); } static void gtk_dps_font_selection_draw_lazy(GtkDPSArea *area, GdkRectangle *x_rectangle, GdkDPSRectangle *dps_rectangle, gpointer data) { g_return_if_fail(area); g_return_if_fail(GTK_IS_DPS_AREA(area)); gtk_dps_area_map_area_on_screen(area, dps_rectangle); } static void gtk_real_dps_font_selection_font_change (GtkDPSFontSelection *fontsel, const gchar * font_name, const gint font_size) { g_return_if_fail(fontsel); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel)); g_return_if_fail(font_name); g_return_if_fail(font_size != 0); gtk_dps_font_selection_draw_preview_text(fontsel); } static void gtk_real_dps_font_selection_preview_change (GtkDPSFontSelection *fontsel, const gchar * preview_text) { g_return_if_fail(fontsel); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel)); g_return_if_fail(preview_text != NULL); gtk_dps_font_selection_draw_preview_text(fontsel); } static void gtk_dps_font_selection_coordtr_update(GtkDPSArea *area, GdkDPSCoordtr * coordtr, gpointer data) { gtk_dps_font_selection_draw_preview_text(data); } static void gtk_dps_font_selection_propagate_preview_text_change(GtkEditable * editable, gpointer usre_data) { gchar * str; g_return_if_fail ( editable ); g_return_if_fail ( usre_data ); g_return_if_fail ( GTK_ENTRY(editable) ); g_return_if_fail ( GTK_DPS_FONT_SELECTION(usre_data)); str = gtk_entry_get_text(GTK_ENTRY(editable)); gtk_signal_emit(GTK_OBJECT(usre_data), gtk_dps_font_selection_signals[PREVIEW_TEXT_CHANGED], str); } void gtk_dps_font_selection_set_font_name (GtkDPSFontSelection *fontsel, gchar *font_name) { GSList * fonts_list; GdkDPSFontFamily * font_family; GSList * type_faces_list; GdkDPSTypeFace * type_face; gboolean matchp = FALSE; g_return_if_fail (font_name); g_return_if_fail (fontsel); g_return_if_fail (GTK_IS_DPS_FONT_SELECTION(fontsel)); if (0 == strcmp(font_name, fontsel->font_name)) return ; /* Update internal value, TODO: Here the code of gtkDPSfontsel access font list data internal. We should provide an access function. */ for (fonts_list = fontsel->fonts_data; fonts_list; fonts_list = g_slist_next (fonts_list)) { font_family = (GdkDPSFontFamily *)fonts_list->data; if (font_family == NULL) continue ; for (type_faces_list = font_family->type_faces_list; type_faces_list; type_faces_list = g_slist_next (type_faces_list)) { type_face = (GdkDPSTypeFace *)type_faces_list->data; if (type_face == NULL) continue ; if (0 == strcmp (font_name, type_face->font_name)) { matchp = TRUE; fontsel->font_name = type_face->font_name; fontsel->type_face = type_face->type_face; goto update_gui; } } } update_gui: /* Update GUI */ g_return_if_fail(matchp); /* deselect */ if (fontsel->type_face_list_item) gtk_list_item_deselect(GTK_LIST_ITEM(fontsel->type_face_list_item)); /* erace previous list */ gtk_list_clear_items (GTK_LIST (fontsel->face_box), 0, -1); fontsel->type_face_list_item = NULL; gdk_flush(); font_face_box_install_list_items(fontsel, font_family->type_faces_list); { gint font_index = g_slist_index(fontsel->fonts_data, font_family); g_return_if_fail (font_index != -1); gtk_list_select_item (GTK_LIST (fontsel->family_box), font_index); } /* Emit */ gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], fontsel->font_name, gtk_dps_font_selection_get_font_size(fontsel)); } void gtk_dps_font_selection_set_font_size (GtkDPSFontSelection *fontsel, gint font_size) { gchar * buf; gint i; gint lots_of_sizes_entries = sizeof (font_size_defaults) / sizeof (char *); g_return_if_fail (fontsel); g_return_if_fail (font_size != 0); g_return_if_fail (GTK_DPS_FONT_SELECTION(fontsel)); /* Update internal value */ if (fontsel->font_size == font_size) return ; fontsel->font_size = font_size; /* Update GUI */ buf = g_strdup_printf("%d", fontsel->font_size); gtk_entry_set_text (GTK_ENTRY (fontsel->size_entry), buf); g_free(buf); if (fontsel->size_list_item) gtk_list_item_deselect (GTK_LIST_ITEM (fontsel->size_list_item)); /* Serach index */ for (i = 0; i < lots_of_sizes_entries; i++) { if (fontsel->font_size == atoi(font_size_defaults[i])) { gtk_list_select_item (GTK_LIST (fontsel->size_box), i); fontsel->size_list_item = NULL; /* TODO */ break; } } /* Emit */ gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[FONT_CHANGED], gtk_dps_font_selection_get_font_name(fontsel), fontsel->font_size); } gchar* gtk_dps_font_selection_get_preview_text (GtkDPSFontSelection *fontsel) { g_return_val_if_fail(fontsel, NULL); g_return_val_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel), NULL); return gtk_entry_get_text (GTK_ENTRY (fontsel->input_entry)); } void gtk_dps_font_selection_set_preview_text (GtkDPSFontSelection *fontsel, const gchar *text) { g_return_if_fail(fontsel); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel)); g_return_if_fail(text); gtk_entry_set_text(GTK_ENTRY (fontsel->input_entry), text); gtk_dps_font_selection_draw_preview_text(fontsel); } static gboolean gtk_real_dps_font_selection_draw_preview_text(GtkDPSFontSelection * fontsel, DPSContext raw_ctxt, const gchar * font_name, const gint font_size, const gchar * preview_text) { g_return_val_if_fail(fontsel, FALSE); g_return_val_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel), FALSE); if (!fontsel->disable_default_previewer) { /* original: * PSWShowSampleString(raw_ctxt, * font_name, font_size, preview_text); */ gint err_count = -1; PSWShowSampleSafely(raw_ctxt, font_name, font_size, preview_text, &err_count); if (gdk_dps_debug_flags & GDK_DPS_DEBUG_FONT) { g_message("### %d error counted", err_count); } while (0 < err_count) { gchar err_msg[BUFSIZ]; PSWStrNCpyTopOfStack(raw_ctxt, BUFSIZ, err_msg); g_message("### PS error:%s", err_msg); err_count --; } } return FALSE; } static void gtk_dps_font_selection_draw_preview_text (GtkDPSFontSelection *fontsel) { gchar * str; g_return_if_fail(fontsel); g_return_if_fail(GTK_IS_DPS_FONT_SELECTION(fontsel)); g_return_if_fail(fontsel->font_name); g_return_if_fail(fontsel->font_size); if (!GTK_WIDGET_REALIZED(fontsel->dps_area)) return; str = gtk_dps_font_selection_get_preview_text(fontsel); if (str == NULL) return; fontsel->disable_default_previewer = FALSE; gtk_dps_widget_begin(fontsel->dps_area); { gtk_signal_emit(GTK_OBJECT(fontsel), gtk_dps_font_selection_signals[DRAW_PREVIEW_TEXT], raw_ctxt, fontsel->font_name, fontsel->font_size, str, &(fontsel->disable_default_previewer)); } gtk_dps_widget_end(); gtk_dps_area_map_area_on_screen(GTK_DPS_AREA(fontsel->dps_area), NULL); } /*****************************/ /* GtkDPSFontSelectionDialog */ /*****************************/ guint gtk_dps_font_selection_dialog_get_type (void) { static guint dps_font_selection_dialog_type = 0; if (!dps_font_selection_dialog_type) { GtkTypeInfo dps_font_selection_diag_info = { "GtkDPSFontSelectionDialog", sizeof (GtkDPSFontSelectionDialog), sizeof (GtkDPSFontSelectionDialogClass), (GtkClassInitFunc) gtk_dps_font_selection_dialog_class_init, (GtkObjectInitFunc) gtk_dps_font_selection_dialog_init, /* reserved_1 */ NULL, /* reserved_2 */ NULL, (GtkClassInitFunc) NULL, }; dps_font_selection_dialog_type = gtk_type_unique (gtk_window_get_type (), &dps_font_selection_diag_info); } return dps_font_selection_dialog_type; } static void gtk_dps_font_selection_dialog_class_init (GtkDPSFontSelectionDialogClass *klass) { GtkObjectClass *object_class; object_class = (GtkObjectClass*) klass; gtk_dps_font_dialog_parent_class = gtk_type_class (gtk_window_get_type ()); } static void gtk_dps_font_selection_dialog_init (GtkDPSFontSelectionDialog *fontseldiag) { GtkWidget *action_area, *frame; fontseldiag->main_vbox = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (fontseldiag), 10); gtk_container_add (GTK_CONTAINER (fontseldiag), fontseldiag->main_vbox); gtk_widget_show (fontseldiag->main_vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_container_add (GTK_CONTAINER (fontseldiag->main_vbox), frame); gtk_widget_show (frame); fontseldiag->fontsel = gtk_dps_font_selection_new (); gtk_container_add (GTK_CONTAINER (frame), fontseldiag->fontsel); gtk_widget_show (fontseldiag->fontsel); action_area = gtk_hbutton_box_new (); gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(action_area), 5); gtk_box_pack_end (GTK_BOX (fontseldiag->main_vbox), action_area, FALSE, FALSE, 0); gtk_widget_show (action_area); fontseldiag->ok_button = gtk_button_new_with_label ( _("OK")); GTK_WIDGET_SET_FLAGS (fontseldiag->ok_button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (action_area), fontseldiag->ok_button, TRUE, TRUE, 0); gtk_widget_grab_default (fontseldiag->ok_button); gtk_widget_show (fontseldiag->ok_button); fontseldiag->cancel_button = gtk_button_new_with_label ( _("Cancel")); GTK_WIDGET_SET_FLAGS (fontseldiag->cancel_button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (action_area), fontseldiag->cancel_button, TRUE, TRUE, 0); gtk_widget_show (fontseldiag->cancel_button); fontseldiag->help_button = gtk_button_new_with_label ( _("Help")); GTK_WIDGET_SET_FLAGS (fontseldiag->help_button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (action_area), fontseldiag->help_button, TRUE, TRUE, 0); gtk_widget_show (fontseldiag->help_button); } GtkWidget * gtk_dps_font_selection_dialog_new (const gchar *title) { GtkDPSFontSelectionDialog *fontseldiag; fontseldiag = gtk_type_new (gtk_dps_font_selection_dialog_get_type ()); gtk_window_set_title (GTK_WINDOW (fontseldiag), title); return GTK_WIDGET (fontseldiag); } /* Marshaler */ typedef gboolean (*GtkSignal_BOOL__POINTER_POINTER_INT_POINTER) (GtkObject *object, gpointer arg1, gpointer arg2, gint arg3, gpointer arg4, gpointer user_data); static void gtk_marshal_BOOL__POINTER_POINTER_INT_POINTER (GtkObject *object, GtkSignalFunc func, gpointer func_data, GtkArg *args) { GtkSignal_BOOL__POINTER_POINTER_INT_POINTER rfunc; gboolean *return_val; return_val = GTK_RETLOC_BOOL(args[4]); rfunc = (GtkSignal_BOOL__POINTER_POINTER_INT_POINTER) func; (*return_val) = (*rfunc) (object, GTK_VALUE_POINTER (args[0]), GTK_VALUE_POINTER (args[1]), GTK_VALUE_INT (args[2]), GTK_VALUE_POINTER (args[3]), func_data); }