From: Owen Taylor Date: Tue, 15 Dec 1998 20:31:26 +0000 (+0000) Subject: Added gdk_text_extents_wc() X-Git-Url: http://pileus.org/git/?a=commitdiff_plain;h=a3c1e86ffa9b75d4e027843d6c3d23249247cad5;p=~andy%2Fgtk Added gdk_text_extents_wc() Tue Dec 15 14:30:35 1998 Owen Taylor * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() * Patch from Jonathan Blanford to add line wrapping to label. (Based on patch from Jeff Dairiki gtk-dairiki-971208-0) - Adds new function gtk_label_set_line_wrap() - implement GTK_JUSTIFY_FILL. - rename gtk_label_set to gtk_label_set_text() add gtk_label_set() to gtkcompat.h. * Use an internal wc representation in the label, so that we handle underlining and line breaks correctly for multi-byte strings. --- diff --git a/ChangeLog b/ChangeLog index 2579178ff..516689fd9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 2579178ff..516689fd9 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,20 @@ +Tue Dec 15 14:30:35 1998 Owen Taylor + + * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc() + + * Patch from Jonathan Blanford to add line wrapping + to label. (Based on patch from Jeff Dairiki + gtk-dairiki-971208-0) + + - Adds new function gtk_label_set_line_wrap() + - implement GTK_JUSTIFY_FILL. + - rename gtk_label_set to gtk_label_set_text() add + gtk_label_set() to gtkcompat.h. + + * Use an internal wc representation in the label, so + that we handle underlining and line breaks correctly + for multi-byte strings. + Tue Dec 15 13:32:28 1998 Owen Taylor * gtk/gtkwidget.h: Added GTK_USER_DRAW flag. diff --git a/gdk/gdk.h b/gdk/gdk.h index 62e4a1b3a..f21cede9c 100644 --- a/gdk/gdk.h +++ b/gdk/gdk.h @@ -604,6 +604,14 @@ void gdk_text_extents (GdkFont *font, gint *width, gint *ascent, gint *descent); +void gdk_text_extents_wc (GdkFont *font, + const GdkWChar *text, + gint text_length, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent); void gdk_string_extents (GdkFont *font, const gchar *string, gint *lbearing, diff --git a/gdk/gdkfont.c b/gdk/gdkfont.c index 094be0c41..e36fde170 100644 --- a/gdk/gdkfont.c +++ b/gdk/gdkfont.c @@ -503,6 +503,80 @@ gdk_text_extents (GdkFont *font, } +void +gdk_text_extents_wc (GdkFont *font, + const GdkWChar *text, + gint text_length, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent) +{ + GdkFontPrivate *private; + XCharStruct overall; + XFontStruct *xfont; + XFontSet fontset; + XRectangle ink, logical; + int direction; + int font_ascent; + int font_descent; + gint i; + + g_return_if_fail (font != NULL); + g_return_if_fail (text != NULL); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + { + gchar *text_8bit; + gint i; + + xfont = (XFontStruct *) private->xfont; + g_return_if_fail ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)); + + text_8bit = g_new (gchar, text_length); + for (i=0; ixfont; + XwcTextExtents (fontset, text, text_length, &ink, &logical); + if (lbearing) + *lbearing = ink.x; + if (rbearing) + *rbearing = ink.x + ink.width; + if (width) + *width = logical.width; + if (ascent) + *ascent = -ink.y; + if (descent) + *descent = ink.y + ink.height; + break; + } + +} + void gdk_string_extents (GdkFont *font, const gchar *string, diff --git a/gdk/x11/gdkfont-x11.c b/gdk/x11/gdkfont-x11.c index 094be0c41..e36fde170 100644 --- a/gdk/x11/gdkfont-x11.c +++ b/gdk/x11/gdkfont-x11.c @@ -503,6 +503,80 @@ gdk_text_extents (GdkFont *font, } +void +gdk_text_extents_wc (GdkFont *font, + const GdkWChar *text, + gint text_length, + gint *lbearing, + gint *rbearing, + gint *width, + gint *ascent, + gint *descent) +{ + GdkFontPrivate *private; + XCharStruct overall; + XFontStruct *xfont; + XFontSet fontset; + XRectangle ink, logical; + int direction; + int font_ascent; + int font_descent; + gint i; + + g_return_if_fail (font != NULL); + g_return_if_fail (text != NULL); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + { + gchar *text_8bit; + gint i; + + xfont = (XFontStruct *) private->xfont; + g_return_if_fail ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)); + + text_8bit = g_new (gchar, text_length); + for (i=0; ixfont; + XwcTextExtents (fontset, text, text_length, &ink, &logical); + if (lbearing) + *lbearing = ink.x; + if (rbearing) + *rbearing = ink.x + ink.width; + if (width) + *width = logical.width; + if (ascent) + *ascent = -ink.y; + if (descent) + *descent = ink.y + ink.height; + break; + } + +} + void gdk_string_extents (GdkFont *font, const gchar *string, diff --git a/gtk/gtkaccellabel.c b/gtk/gtkaccellabel.c index be6650dad..bf24190ec 100644 --- a/gtk/gtkaccellabel.c +++ b/gtk/gtkaccellabel.c @@ -172,7 +172,7 @@ gtk_accel_label_new (const gchar *string) accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL); - gtk_label_set (GTK_LABEL (accel_label), string); + gtk_label_set_text (GTK_LABEL (accel_label), string); return GTK_WIDGET (accel_label); } diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c index 69da1044a..28e2a57bb 100644 --- a/gtk/gtkbutton.c +++ b/gtk/gtkbutton.c @@ -244,7 +244,7 @@ gtk_button_set_arg (GtkObject *object, "parent", button, NULL); if (GTK_IS_LABEL (child)) - gtk_label_set (GTK_LABEL (child), + gtk_label_set_text (GTK_LABEL (child), GTK_VALUE_STRING (*arg) ? GTK_VALUE_STRING (*arg) : ""); break; case ARG_RELIEF: diff --git a/gtk/gtkcompat.h b/gtk/gtkcompat.h index b4370a855..fc4dc7942 100644 --- a/gtk/gtkcompat.h +++ b/gtk/gtkcompat.h @@ -36,7 +36,7 @@ extern "C" { #define gtk_paned_handle_size gtk_paned_set_handle_size #define gtk_scale_value_width gtk_scale_get_value_width #define gtk_window_position gtk_window_set_position - +#define gtk_label_set gtk_label_set_text #ifdef __cplusplus } diff --git a/gtk/gtkdrawwindow.c b/gtk/gtkdrawwindow.c deleted file mode 100644 index 317aae0cf..000000000 --- a/gtk/gtkdrawwindow.c +++ /dev/null @@ -1,125 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald - * - * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ -#include "gtkdrawwindow.h" - -static void gtk_draw_window_class_init (GtkDrawWindowClass *klass); -static void gtk_draw_window_init (GtkDrawWindow *draw_window); -static void gtk_draw_window_draw (GtkWidget *widget, - GdkRectangle *area); -static gint gtk_draw_window_expose (GtkWidget *widget, - GdkEventExpose *event); - - -GtkType -gtk_draw_window_get_type (void) -{ - static GtkType draw_window_type = 0; - - if (!draw_window_type) - { - static const GtkTypeInfo draw_window_info = - { - "GtkDrawWindow", - sizeof (GtkDrawWindow), - sizeof (GtkDrawWindowClass), - (GtkClassInitFunc) gtk_draw_window_class_init, - (GtkObjectInitFunc) gtk_draw_window_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL, - }; - - draw_window_type = gtk_type_unique (GTK_TYPE_WINDOW, &draw_window_info); - } - - return draw_window_type; -} - -static void -gtk_draw_window_class_init (GtkDrawWindowClass *class) -{ - GtkWidgetClass *widget_class; - - widget_class = (GtkWidgetClass*) class; - - widget_class->draw = gtk_draw_window_draw; - widget_class->expose_event = gtk_draw_window_expose; -} - -static void -gtk_draw_window_init (GtkDrawWindow *draw_window) -{ -} - -static gint -gtk_draw_window_expose (GtkWidget *widget, - GdkEventExpose *event) -{ - GtkBin *bin; - GdkEventExpose child_event; - - g_return_val_if_fail (widget != NULL, FALSE); - g_return_val_if_fail (GTK_IS_BIN (widget), FALSE); - g_return_val_if_fail (event != NULL, FALSE); - - if (GTK_WIDGET_DRAWABLE (widget)) - { - bin = GTK_BIN (widget); - - child_event = *event; - if (bin->child && - GTK_WIDGET_NO_WINDOW (bin->child) && - gtk_widget_intersect (bin->child, &event->area, &child_event.area)) - gtk_widget_event (bin->child, (GdkEvent*) &child_event); - } - - return FALSE; -} - -static void -gtk_draw_window_draw (GtkWidget *widget, - GdkRectangle *area) -{ - GtkBin *bin; - GdkRectangle child_area; - - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_BIN (widget)); - - if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget)) - { - bin = GTK_BIN (widget); - - if (bin->child && - gtk_widget_intersect (bin->child, area, &child_area)) - gtk_widget_draw (bin->child, &child_area); - } -} - -GtkWidget* -gtk_draw_window_new (GtkWindowType type) -{ - GtkWindow *window; - - window = gtk_type_new (GTK_TYPE_DRAW_WINDOW); - - window->type = type; - - return GTK_WIDGET (window); -} diff --git a/gtk/gtkdrawwindow.h b/gtk/gtkdrawwindow.h deleted file mode 100644 index 20f9f7fe0..000000000 --- a/gtk/gtkdrawwindow.h +++ /dev/null @@ -1,63 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald - * - * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ -#ifndef __GTK_DRAW_WINDOW_H__ -#define __GTK_DRAW_WINDOW_H__ - - -#include -#include - - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - - -#define GTK_TYPE_DRAW_WINDOW (gtk_draw_window_get_type ()) -#define GTK_DRAW_WINDOW(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_DRAW_WINDOW, GtkDrawWindow)) -#define GTK_DRAW_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_DRAW_WINDOW, GtkDrawWindowClass)) -#define GTK_IS_DRAW_WINDOW(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_DRAW_WINDOW)) -#define GTK_IS_DRAW_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DRAW_WINDOW)) - - -typedef struct _GtkDrawWindow GtkDrawWindow; -typedef struct _GtkDrawWindowClass GtkDrawWindowClass; -typedef struct _GtkDrawWindowButton GtkDrawWindowButton; - - -struct _GtkDrawWindow -{ - GtkWindow window; -}; - -struct _GtkDrawWindowClass -{ - GtkWindowClass parent_class; -}; - - -GtkType gtk_draw_window_get_type (void); -GtkWidget* gtk_draw_window_new (GtkWindowType type); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - - -#endif /* __GTK_DRAW_WINDOW_H__ */ diff --git a/gtk/gtkfilesel.c b/gtk/gtkfilesel.c index 3281f7b0c..8379118f6 100644 --- a/gtk/gtkfilesel.c +++ b/gtk/gtkfilesel.c @@ -499,7 +499,7 @@ gtk_file_selection_init (GtkFileSelection *filesel) sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno)); - gtk_label_set (GTK_LABEL (filesel->selection_text), err_buf); + gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf); } else { @@ -1435,7 +1435,7 @@ gtk_file_selection_populate (GtkFileSelection *fs, strcpy (sel_text, "Selection: "); strcat (sel_text, cmpl_reference_position (cmpl_state)); - gtk_label_set (GTK_LABEL (fs->selection_text), sel_text); + gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text); g_free (sel_text); } @@ -1457,7 +1457,7 @@ gtk_file_selection_abort (GtkFileSelection *fs) /* BEEP gdk_beep(); */ if (fs->selection_entry) - gtk_label_set (GTK_LABEL (fs->selection_text), err_buf); + gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf); } /**********************************************************************/ diff --git a/gtk/gtkfontsel.c b/gtk/gtkfontsel.c index 926bd9512..549169791 100644 --- a/gtk/gtkfontsel.c +++ b/gtk/gtkfontsel.c @@ -1752,19 +1752,19 @@ gtk_font_selection_load_font (GtkFontSelection *fontsel) it's necessary as it results in a resize of the whole window! */ gtk_label_get(GTK_LABEL(fontsel->message_label), &label_text); if (strcmp(label_text, "")) - gtk_label_set(GTK_LABEL(fontsel->message_label), ""); + gtk_label_set_text(GTK_LABEL(fontsel->message_label), ""); gtk_font_selection_update_preview (fontsel); return TRUE; } else { - gtk_label_set(GTK_LABEL(fontsel->message_label), + gtk_label_set_text(GTK_LABEL(fontsel->message_label), "The selected font is not available."); } } else { - gtk_label_set(GTK_LABEL(fontsel->message_label), + gtk_label_set_text(GTK_LABEL(fontsel->message_label), "The selected font is not a valid font."); } @@ -1822,7 +1822,7 @@ gtk_font_selection_update_preview (GtkFontSelection *fontsel) displayed properly. */ xfs = GDK_FONT_XFONT(fontsel->font); if (xfs->min_byte1 != 0 || xfs->max_byte1 != 0) - gtk_label_set(GTK_LABEL(fontsel->message_label), + gtk_label_set_text(GTK_LABEL(fontsel->message_label), "This is a 2-byte font and may not be displayed correctly."); } @@ -2135,12 +2135,12 @@ gtk_font_selection_update_filter (GtkFontSelection *fontsel) if (default_filter) { gtk_widget_set_sensitive(fontsel->filter_button, FALSE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:"); + gtk_label_set_text(GTK_LABEL(fontsel->font_label), "Font:"); } else { gtk_widget_set_sensitive(fontsel->filter_button, TRUE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font: (Filter Applied)"); + gtk_label_set_text(GTK_LABEL(fontsel->font_label), "Font: (Filter Applied)"); } gtk_font_selection_show_available_fonts(fontsel); } @@ -2365,7 +2365,7 @@ gtk_font_selection_clear_filter (GtkFontSelection *fontsel) /* Update the main notebook page. */ gtk_widget_set_sensitive(fontsel->filter_button, FALSE); - gtk_label_set(GTK_LABEL(fontsel->font_label), "Font:"); + gtk_label_set_text(GTK_LABEL(fontsel->font_label), "Font:"); gtk_font_selection_show_available_fonts(fontsel); } diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c index ff97c508f..50166fa0d 100644 --- a/gtk/gtklabel.c +++ b/gtk/gtklabel.c @@ -1,4 +1,4 @@ -/* GTK - The GIMP Toolkit + /* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or @@ -8,17 +8,17 @@ * * 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 + * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include "gtklabel.h" #include "gdk/gdkkeysyms.h" +#include "gdk/gdki18n.h" enum { ARG_0, @@ -27,16 +27,34 @@ enum { ARG_JUSTIFY }; -typedef struct _GtkLabelRow GtkLabelRow; +typedef struct _GtkLabelULine GtkLabelULine; +struct _GtkLabelWord +{ + GdkWChar *beginning; + gint length; -struct _GtkLabelRow { - gint index; + /* FIXME: + * We need (space,width) only before we've set (x,y), so to save + * memory, these pairs should really be wrapped in a union. + * I haven't yet figured out how to do this without making the code + * look ugly. + */ + gint space; gint width; - gint height; - gint len; + gint x; + gint y; + GtkLabelWord *next; + gint uline_y; + GtkLabelULine *uline; }; -GMemChunk *row_mem_chunk = NULL; +struct _GtkLabelULine +{ + gint x1; + gint x2; + gint y; + GtkLabelULine *next; +}; static void gtk_label_class_init (GtkLabelClass *klass); static void gtk_label_init (GtkLabel *label); @@ -51,11 +69,22 @@ static void gtk_label_size_request (GtkWidget *widget, GtkRequisition *requisition); static gint gtk_label_expose (GtkWidget *widget, GdkEventExpose *event); -static void gtk_label_free_rows (GtkLabel *label); + +static GtkLabelWord * gtk_label_word_alloc (void); +static GtkLabelULine * gtk_label_uline_alloc (void); +static void gtk_label_free_words (GtkLabel *label); +static void gtk_label_free_ulines (GtkLabelWord *word); +static gint gtk_label_split_text (GtkLabel * label); +static void gtk_label_finalize_lines (GtkLabel * label, gint line_width); +static void gtk_label_finalize_lines_wrap(GtkLabel * label, gint line_width); static GtkMiscClass *parent_class = NULL; +static GMemChunk *word_chunk = 0; +static GtkLabelWord *free_words = 0; +static GMemChunk *uline_chunk = 0; +static GtkLabelULine *free_ulines = 0; GtkType gtk_label_get_type (void) @@ -118,7 +147,7 @@ gtk_label_set_arg (GtkObject *object, switch (arg_id) { case ARG_LABEL: - gtk_label_set (label, GTK_VALUE_STRING (*arg) ? GTK_VALUE_STRING (*arg) : ""); + gtk_label_set_text (label, GTK_VALUE_STRING (*arg) ? GTK_VALUE_STRING (*arg) : ""); break; case ARG_PATTERN: gtk_label_set_pattern (label, GTK_VALUE_STRING (*arg)); @@ -163,64 +192,51 @@ gtk_label_init (GtkLabel *label) GTK_WIDGET_SET_FLAGS (label, GTK_NO_WINDOW); label->label = NULL; - label->row = NULL; + label->words = NULL; label->max_width = 0; label->jtype = GTK_JUSTIFY_CENTER; label->pattern = NULL; - - gtk_label_set (label, ""); + label->wrap = FALSE; + + gtk_label_set_text (label, ""); } GtkWidget* -gtk_label_new (const gchar *str) +gtk_label_new (const char *str) { GtkLabel *label; - + g_return_val_if_fail (str != NULL, NULL); - + label = gtk_type_new (gtk_label_get_type ()); - - gtk_label_set (label, str); - + + gtk_label_set_text (label, str); + return GTK_WIDGET (label); } void -gtk_label_set (GtkLabel *label, - const gchar *str) +gtk_label_set_text (GtkLabel *label, + const char *str) { - char* p; + guint len; + guint wc_len; g_return_if_fail (label != NULL); g_return_if_fail (GTK_IS_LABEL (label)); g_return_if_fail (str != NULL); - if (!row_mem_chunk) - row_mem_chunk = g_mem_chunk_create (GtkLabelRow, 64, G_ALLOC_AND_FREE); - if (label->label) g_free (label->label); label->label = g_strdup (str); - - if (label->row) - gtk_label_free_rows (label); - p = label->label; - do { - GtkLabelRow *row = g_chunk_new (GtkLabelRow, row_mem_chunk); - label->row = g_slist_append (label->row, row); + /* Convert text to wide characters */ + len = strlen (str); + label->label_wc = g_new (GdkWChar, len + 1); + wc_len = gdk_mbstowcs (label->label_wc, str, len + 1); + label->label_wc[wc_len] = '\0'; - row->index = p - label->label; - - p = strchr(p, '\n'); - if (p) - { - p++; - row->len = (p - label->label) - row->index; - } - else - row->len = strlen (label->label) - row->index; - } while (p); + gtk_label_free_words (label); if (GTK_WIDGET_VISIBLE (label)) { @@ -252,38 +268,59 @@ gtk_label_set_pattern (GtkLabel *label, } void -gtk_label_set_justify (GtkLabel *label, - GtkJustification jtype) +gtk_label_set_justify (GtkLabel *label, GtkJustification jtype) { g_return_if_fail (label != NULL); g_return_if_fail (GTK_IS_LABEL (label)); - + if ((GtkJustification) label->jtype != jtype) { + if ((label->jtype == GTK_JUSTIFY_FILL) || + (jtype == GTK_JUSTIFY_FILL)) + /* FIXME: think about this a little */ + gtk_label_free_words (label); + label->jtype = jtype; if (GTK_WIDGET_VISIBLE (label)) - { - if (GTK_WIDGET_MAPPED (label)) + { + if (GTK_WIDGET_MAPPED (label)) gtk_widget_queue_clear (GTK_WIDGET (label)); - - gtk_widget_queue_resize (GTK_WIDGET (label)); - } + + gtk_widget_queue_resize (GTK_WIDGET (label)); + } } } void -gtk_label_get (GtkLabel *label, - gchar **str) +gtk_label_set_line_wrap (GtkLabel *label, gboolean wrap) +{ + g_return_if_fail (label != NULL); + g_return_if_fail (GTK_IS_LABEL (label)); + + if (label->wrap != wrap) { + if (GTK_WIDGET_VISIBLE (label)) + { + if (GTK_WIDGET_MAPPED (label)) + gtk_widget_queue_clear (GTK_WIDGET (label)); + + gtk_widget_queue_resize (GTK_WIDGET (label)); + } + label->wrap = wrap; + } +} + +void +gtk_label_get (GtkLabel *label, + char **str) { g_return_if_fail (label != NULL); g_return_if_fail (GTK_IS_LABEL (label)); g_return_if_fail (str != NULL); - + *str = label->label; } - static void gtk_label_finalize (GtkObject *object) { @@ -295,170 +332,561 @@ gtk_label_finalize (GtkObject *object) label = GTK_LABEL (object); g_free (label->label); - if (label->pattern) g_free (label->pattern); - gtk_label_free_rows (label); - + if (label->pattern) + g_free (label->pattern); + gtk_label_free_words (label); (* GTK_OBJECT_CLASS (parent_class)->finalize) (object); } -static gint -gtk_label_process_row (GtkLabel *label, - GtkLabelRow *row, - gint x, gint y, - gboolean draw, - GdkRectangle *area) +static GtkLabelWord * +gtk_label_word_alloc () { - GtkWidget *widget = GTK_WIDGET (label); - - char lastc; - gint i, j; - gint offset; - gint height; - gint pattern_length; + GtkLabelWord * word; - if (label->pattern) - pattern_length = strlen (label->pattern); + if (!word_chunk) + { + word_chunk = g_mem_chunk_new ("GtkLabelWord chunk", + sizeof (GtkLabelWord), + 32 * sizeof (GtkLabelWord), + G_ALLOC_ONLY); + } + + if (free_words) + { + word = free_words; + free_words = word->next; + } else - pattern_length = 0; + { + word = g_mem_chunk_alloc (word_chunk); + } + + word->next = 0; + word->uline = 0; + return word; +} - offset = 0; - height = widget->style->font->ascent + widget->style->font->descent; +static void +gtk_label_free_words (GtkLabel * label) +{ + GtkLabelWord * last; + + if (label->words) + { + for (last = label->words; last->next != 0; last = last->next) + gtk_label_free_ulines (label->words); + last->next = free_words; + free_words = label->words; + label->words = 0; + } +} +static GtkLabelULine * +gtk_label_uline_alloc () +{ + GtkLabelULine * uline; + + if (!uline_chunk) + { + uline_chunk = g_mem_chunk_new ("GtkLabelWord chunk", + sizeof (GtkLabelULine), + 32 * sizeof (GtkLabelULine), + G_ALLOC_ONLY); + } - if (draw) + if (free_ulines) { - if (label->jtype == GTK_JUSTIFY_CENTER) - offset = (label->max_width - row->width) / 2; - else if (label->jtype == GTK_JUSTIFY_RIGHT) - offset = (label->max_width - row->width); + uline = free_ulines; + free_ulines = uline->next; } - - if (label->pattern && (row->index < pattern_length)) - lastc = label->pattern[0]; else - lastc = ' '; + { + uline = g_mem_chunk_alloc (uline_chunk); + } + + uline->next = 0; + return uline; +} + +static void +gtk_label_free_ulines (GtkLabelWord *word) +{ + GtkLabelULine *last; + if (word->uline) + { + for (last = word->uline; last->next != 0; last = last->next) + ; + last->next = free_ulines; + free_ulines = word->uline; + word->uline = 0; + } +} - j = 0; - for (i=1; i<=row->len; i++) +static gint +gtk_label_split_text (GtkLabel * label) +{ + GtkLabelWord *word, **tailp; + gint space_width, line_width, max_line_width; + GdkWChar *str, *p; + + g_return_val_if_fail (GTK_WIDGET (label)->style->font != 0, 0); + + gtk_label_free_words (label); + if (label->label == 0) + return 0; + + /* + * Split text at new-lines. + */ + space_width = gdk_string_width (GTK_WIDGET (label)->style->font, " "); + + line_width = 0; + max_line_width = 0; + tailp = &label->words; + str = label->label_wc; + while (*str) { - char c; + word = gtk_label_word_alloc (); - if (label->pattern && (row->index + i < pattern_length)) - c = label->pattern[row->index+i]; + if ((str == label->label_wc) || (str[-1] == '\n')) + { + /* Paragraph break */ + word->space = 0; + + max_line_width = MAX (line_width, max_line_width); + line_width = 0; + } + else if (str[0] == ' ') + { + while (str[0] == ' ') + { + str++; + word->space += space_width; + } + } else - c = ' '; + { + /* Regular inter-word space */ + word->space = space_width; + } - if ((i == row->len) || (lastc != c)) + word->beginning = str; + + word->length = 0; + p = word->beginning; + while (*p && (*p != '\n')) { - gint width = 0; + word->length++; + p++; + } - if (lastc == '_') - { - gint descent; - gint rbearing; - gint lbearing; + word->width = gdk_text_width_wc (GTK_WIDGET (label)->style->font, str, word->length); - gdk_text_extents (widget->style->font, - &label->label[row->index+j], i - j, - &lbearing, &rbearing, &width, NULL, &descent); + str += word->length; + if (*str) + str++; + + line_width += word->space + word->width; - if (draw) - { - gtk_paint_hline (widget->style, widget->window, - widget->state, area, - widget, "label", - offset + x + lbearing - 1, - offset + x + rbearing, - y + descent + 2); - } + *tailp = word; + tailp = &word->next; + } - height = MAX (height, - widget->style->font->ascent + descent + 2); - } - else if (i != row->len) + return MAX (line_width, max_line_width); +} + +static gint +gtk_label_split_text_wrapped (GtkLabel * label) +{ + /* this needs to handle white space better. */ + GtkLabelWord *word, **tailp; + gint space_width, line_width, max_line_width; + GdkWChar *str, *p; + + g_return_val_if_fail (GTK_WIDGET (label)->style->font != 0, 0); + + gtk_label_free_words (label); + if (label->label == 0) + return 0; + + /* + * Split text at new-lines. (Or at spaces in the case of paragraphs). + */ + space_width = gdk_string_width (GTK_WIDGET (label)->style->font, " "); + + line_width = 0; + max_line_width = 0; + tailp = &label->words; + str = label->label_wc; + while (*str) + { + word = gtk_label_word_alloc (); + + if (str == label->label_wc || str[-1] == '\n') + { + /* Paragraph break */ + word->space = 0; + + max_line_width = MAX (line_width, max_line_width); + line_width = 0; + } + else if (str[0] == ' ') + { + gint nspaces = 0; + + while (str[0] == ' ') { - width = gdk_text_width (widget->style->font, - &label->label[row->index+j], - i - j); + nspaces++; + str++; } - if (draw) + if (label->jtype == GTK_JUSTIFY_FILL) + word->space = (space_width * 3 + 1) / 2; + else + word->space += space_width * nspaces; + } + else + { + /* Regular inter-word space */ + word->space = space_width; + } + + word->beginning = str; + word->length = 0; + p = word->beginning; + while (*p && (!gdk_iswspace (*p))) + { + word->length++; + p++; + } + word->width = gdk_text_width_wc (GTK_WIDGET (label)->style->font, str, word->length); + + str += word->length; + if (*str) + str++; + + line_width += word->space + word->width; + + *tailp = word; + tailp = &word->next; + } + + return MAX (line_width, max_line_width); +} + +/* + * gtk_label_pick_width + * + * Split paragraphs, trying to make each line at least min_width, + * and trying even harder to make each line no longer than max_width. + * + * Returns the length of the longest resulting line. + * + * (The reason we go to all this effort to pick a paragraph width is to + * try to avoid the lame look of a short paragraph with a + * short final line.) + */ +static gint +gtk_label_pick_width (GtkLabel * label, gint min_width, gint max_width) +{ + GtkLabelWord *word; + gint width, line_width; + + g_return_val_if_fail (label->wrap, min_width); + + line_width = 0; + width = 0; + for (word = label->words; word; word = word->next) + { + if (word->space == 0 + || (line_width + && (line_width >= min_width + || line_width + word->width + word->space > max_width))) + { + /* New line */ + width = MAX (width, line_width); + line_width = 0; + } + line_width += word->space + word->width; + } + + return MAX (width, line_width); +} + +/* + * Here, we finalize the lines. + * This is only for non-wrap labels. Wrapped labels + * use gtk_label_finalize_wrap instead. + */ +static void +gtk_label_finalize_lines (GtkLabel * label, gint line_width) +{ + GtkLabelWord * line; + gint y, baseline_skip, y_max; + gint i, j; + gchar *ptrn; + + g_return_if_fail (!label->wrap); + ptrn = label->pattern; + + y = 0; + baseline_skip = GTK_WIDGET (label)->style->font->ascent + GTK_WIDGET (label)->style->font->descent + 2; + + for (line = label->words; line; line = line->next) + { + if (label->jtype == GTK_JUSTIFY_CENTER) + line->x = (line_width - line->width) / 2; + else if (label->jtype == GTK_JUSTIFY_RIGHT) + line->x = line_width - line->width; + else + line->x = 0; + + line->y = y + GTK_WIDGET (label)->style->font->ascent + 1; + y_max = 0; + + /* now we deal with the underline stuff; */ + if (ptrn && (ptrn[0] != '\0')) + { + for (i=0;ilength;i++) { - char save = label->label[row->index + i]; - label->label[row->index + i] = '\0'; - gtk_paint_string(widget->style, widget->window, widget->state, - area, widget, "label", offset + x, y, - &label->label[row->index+j]); - label->label[row->index + i] = save; + if (ptrn[i] == '\0') + break; + else if (ptrn[i] == '_') + { + gint descent; + gint rbearing; + gint lbearing; + gint width; + gint offset; + GtkLabelULine *uline; + + for (j=i+1;jlength;j++) + { + if (ptrn[j] == '\0') + break; + else if (ptrn[j] == ' ') + break; + } + /* + * good. Now we have an underlined segment. + * let's measure it and record it. + */ + offset = gdk_text_width_wc (GTK_WIDGET (label)->style->font, + line->beginning, + i); + gdk_text_extents_wc (GTK_WIDGET (label)->style->font, + line->beginning+i, + j-i, &lbearing, + &rbearing, &width, NULL, + &descent); + y_max = MAX (descent + 2, y_max); + uline = gtk_label_uline_alloc (); + uline->x1 = offset + line->x + lbearing - 1; + uline->x2 = offset + line->x + rbearing; + uline->y = line->y + descent + 2; + uline->next = line->uline; + line->uline = uline; + i = j - 1; + } } + if (strlen (ptrn) > line->length) + /* the + 1 is for line breaks. */ + ptrn += line->length + 1; + else + ptrn = NULL; + } + y += (baseline_skip + y_max); + } + + label->max_width = line_width; + GTK_WIDGET (label)->requisition.width = line_width + 2 * label->misc.xpad; + GTK_WIDGET (label)->requisition.height = y + 2 * label->misc.ypad; +} + +/* this finalizes word-wrapped words */ +static void +gtk_label_finalize_lines_wrap (GtkLabel * label, gint line_width) +{ + GtkLabelWord *word, *line, *next_line; + GtkWidget *widget; + gchar *ptrn; + gint x, y, space, extra_width, add_space, baseline_skip; + + g_return_if_fail (label->wrap); - - offset += width; + ptrn = label->pattern; + y = 0; + baseline_skip = GTK_WIDGET (label)->style->font->ascent + GTK_WIDGET (label)->style->font->descent + 1; + + for (line = label->words; line != 0; line = next_line) + { + space = 0; + extra_width = line_width - line->width; + + for (next_line = line->next; next_line; next_line = next_line->next) + { + if (next_line->space == 0) + break; /* New paragraph */ + if (next_line->space + next_line->width > extra_width) + break; + extra_width -= next_line->space + next_line->width; + space += next_line->space; + } + + line->x = 0; + line->y = y + GTK_WIDGET (label)->style->font->ascent + 1; + x = line->width; + add_space = 0; - if (i != row->len) + for (word = line->next; word != next_line; word = word->next) + { + if (next_line && next_line->space) { - lastc = c; - j = i; + /* Not last line of paragraph --- fill line if needed */ + if (label->jtype == GTK_JUSTIFY_FILL) { + add_space = (extra_width * word->space + space / 2) / space; + extra_width -= add_space; + space -= word->space; + } } + + word->x = x + word->space + add_space; + word->y = line->y; + x = word->x + word->width; } + + y += (baseline_skip); } - return height; + label->max_width = line_width; + widget = GTK_WIDGET (label); + widget->requisition.width = line_width + 2 * label->misc.xpad; + widget->requisition.height = y + 2 * label->misc.ypad + 1; } - + static void gtk_label_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkLabel *label; - GSList *tmp_list; - gint width; g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_LABEL (widget)); g_return_if_fail (requisition != NULL); - + label = GTK_LABEL (widget); - - requisition->height = label->misc.ypad * 2; - tmp_list = label->row; - width = 0; - while (tmp_list) + /* + * There are a number of conditions which will necessitate re-filling + * our text: + * + * 1. text changed. + * 2. justification changed either from to to GTK_JUSTIFY_FILL. + * 3. font changed. + * + * These have been detected elsewhere, and label->words will be zero, + * if one of the above has occured. + * + * Additionally, though, if GTK_JUSTIFY_FILL, we need to re-fill if: + * + * 4. gtk_widget_set_usize has changed the requested width. + * 5. gtk_misc_set_padding has changed xpad. + * 6. maybe others?... + * + * Too much of a pain to detect all these case, so always re-fill. I + * don't think it's really that slow. + */ + + if (label->wrap) { - GtkLabelRow *row = tmp_list->data; + GtkWidgetAuxInfo *aux_info; + gint longest_paragraph; + + longest_paragraph = gtk_label_split_text_wrapped (label); + + aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info"); + if (aux_info && aux_info->width > 0) + { + label->max_width = MAX(aux_info->width - 2 * label->misc.xpad, 1); + gtk_label_split_text_wrapped (label); + } + else + { + label->max_width = gdk_string_width (GTK_WIDGET (label)->style->font, + "This is a good enough length for any line to have."); + label->max_width = MIN (label->max_width, (gdk_screen_width () + 1) / 2); + label->max_width = MIN (label->max_width, longest_paragraph); + if (longest_paragraph > 0) + { + gint nlines, perfect_width; + + nlines = (longest_paragraph + label->max_width - 1) / label->max_width; + perfect_width = (longest_paragraph + nlines - 1) / nlines; + label->max_width = gtk_label_pick_width (label, + perfect_width, + label->max_width); + } + } + gtk_label_finalize_lines_wrap (label, label->max_width); + } + else if (label->words == 0) + { + label->max_width = gtk_label_split_text (label); + gtk_label_finalize_lines (label, label->max_width); + + } - row->width = gdk_text_width (GTK_WIDGET (label)->style->font, - &label->label [row->index], - row->len); - width = MAX (width, row->width); + if (requisition != &widget->requisition) + *requisition = widget->requisition; +} +static void +gtk_label_paint_word (GtkLabel *label, + gint x, + gint y, + GtkLabelWord *word, + GdkRectangle *area) +{ + GtkWidget *widget = GTK_WIDGET (label); + GtkLabelULine *uline; + gchar *tmp_str; - requisition->height += gtk_label_process_row (label, row, 0, 0, FALSE, NULL) + 2; + tmp_str = gdk_wcstombs (word->beginning); + gtk_paint_string (widget->style, widget->window, widget->state, + area, widget, "label", + x + word->x, + y + word->y, + tmp_str); + g_free (tmp_str); + + for (uline = word->uline;uline;uline = uline->next) + gtk_paint_hline (widget->style, widget->window, + widget->state, area, + widget, "label", + x + uline->x1, x +uline->x2, y + uline->y); - tmp_list = tmp_list->next; - } - label->max_width = width; - requisition->width = width + label->misc.xpad * 2; } - static gint -gtk_label_expose (GtkWidget *widget, +gtk_label_expose (GtkWidget *widget, GdkEventExpose *event) { GtkLabel *label; GtkMisc *misc; - GSList *tmp_list; + GtkLabelWord *word; gint x, y; - + g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (GTK_IS_LABEL (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); + if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget)) { label = GTK_LABEL (widget); misc = GTK_MISC (widget); - + + g_return_val_if_fail (label->words != 0 || label->label == 0, FALSE); + + /* * GC Clipping */ @@ -466,69 +894,46 @@ gtk_label_expose (GtkWidget *widget, gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state], &event->area); x = widget->allocation.x + misc->xpad + - (widget->allocation.width - (label->max_width + label->misc.xpad * 2)) + (widget->allocation.width - label->max_width) * misc->xalign + 0.5; - - y = (widget->allocation.y * (1.0 - misc->yalign) + - (widget->allocation.y + widget->allocation.height - - (widget->requisition.height - misc->ypad * 2)) * - misc->yalign + widget->style->font->ascent) + 1.5; - - /* - * COMMENT: we can avoid gdk_text_width() calls here storing in label->row - * the widths of the rows calculated in gtk_label_set. - * Once we have a wrapping interface we can support GTK_JUSTIFY_FILL. - */ - tmp_list = label->row; - while (tmp_list) + y = (widget->allocation.y + + (widget->allocation.height + - widget->requisition.height) * misc->yalign + + misc->ypad + 0.5); + for (word = label->words; word; word = word->next) { - y += gtk_label_process_row (label, tmp_list->data, x, y, TRUE, &event->area) + 2; - tmp_list = tmp_list->next; + gchar save = word->beginning[word->length]; + word->beginning[word->length] = '\0'; + gtk_label_paint_word (label, x, y, word, &event->area); + word->beginning[word->length] = save; } - + gdk_gc_set_clip_mask (widget->style->white_gc, NULL); gdk_gc_set_clip_mask (widget->style->fg_gc[widget->state], NULL); } return TRUE; } - -static void -gtk_label_free_rows (GtkLabel *label) -{ - GSList *tmp_list; - - tmp_list = label->row; - while (tmp_list) - { - g_mem_chunk_free (row_mem_chunk, tmp_list->data); - tmp_list = tmp_list->next; - } - g_slist_free (label->row); - label->row = NULL; -} - guint gtk_label_parse_uline (GtkLabel *label, const gchar *string) { guint accel_key = GDK_VoidSymbol; - const gchar *p; - gchar *q, *r; - gchar *name, *pattern; + GdkWChar *p, *q; + gchar *r; + gchar *pattern; gint length; gboolean underscore; length = strlen (string); - name = g_new (gchar, length+1); + gtk_label_set_text (label, string); pattern = g_new (gchar, length+1); underscore = FALSE; - p = string; - q = name; + p = q = label->label_wc; r = pattern; while (*p) @@ -562,10 +967,8 @@ gtk_label_parse_uline (GtkLabel *label, *q = 0; *r = 0; - gtk_label_set (label, name); gtk_label_set_pattern (label, pattern); - g_free (name); g_free (pattern); return accel_key; diff --git a/gtk/gtklabel.h b/gtk/gtklabel.h index 0e1ef6175..6a2b87c8a 100644 --- a/gtk/gtklabel.h +++ b/gtk/gtklabel.h @@ -8,13 +8,12 @@ * * 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 + * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __GTK_LABEL_H__ #define __GTK_LABEL_H__ @@ -28,6 +27,7 @@ extern "C" { #endif /* __cplusplus */ + #define GTK_TYPE_LABEL (gtk_label_get_type ()) #define GTK_LABEL(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_LABEL, GtkLabel)) #define GTK_LABEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL, GtkLabelClass)) @@ -38,16 +38,21 @@ extern "C" { typedef struct _GtkLabel GtkLabel; typedef struct _GtkLabelClass GtkLabelClass; +typedef struct _GtkLabelWord GtkLabelWord; + struct _GtkLabel { GtkMisc misc; - - gchar *label; + + gchar *label; + GdkWChar *label_wc; gchar *pattern; - GSList *row; + GtkLabelWord *words; + guint max_width : 16; guint jtype : 2; + gboolean wrap; }; struct _GtkLabelClass @@ -56,17 +61,18 @@ struct _GtkLabelClass }; -GtkType gtk_label_get_type (void); -GtkWidget* gtk_label_new (const gchar *string); -void gtk_label_set (GtkLabel *label, - const gchar *string); -void gtk_label_set_pattern (GtkLabel *label, - const gchar *pattern); -void gtk_label_set_justify (GtkLabel *label, - GtkJustification jtype); -void gtk_label_get (GtkLabel *label, - gchar **string); - +guint gtk_label_get_type (void); +GtkWidget* gtk_label_new (const char *str); +void gtk_label_set_text (GtkLabel *label, + const char *str); +void gtk_label_set_justify (GtkLabel *label, + GtkJustification jtype); +void gtk_label_set_pattern (GtkLabel *label, + const gchar *pattern); +void gtk_label_set_line_wrap (GtkLabel *label, + gboolean wrap); +void gtk_label_get (GtkLabel *label, + char **str); /* Convenience function to set the name and pattern by parsing * a string with embedded underscores, and return the appropriate diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c index 6a749f2d5..eace09ef8 100644 --- a/gtk/gtknotebook.c +++ b/gtk/gtknotebook.c @@ -1955,7 +1955,7 @@ gtk_notebook_update_labels (GtkNotebook *notebook) GTK_WIDGET (notebook)); } else - gtk_label_set (GTK_LABEL (page->tab_label), string); + gtk_label_set_text (GTK_LABEL (page->tab_label), string); } if (GTK_WIDGET_VISIBLE (page->child) && @@ -1968,10 +1968,10 @@ gtk_notebook_update_labels (GtkNotebook *notebook) if (notebook->menu && page->default_menu) { if (page->tab_label && GTK_IS_LABEL (page->tab_label)) - gtk_label_set (GTK_LABEL (page->menu_label), + gtk_label_set_text (GTK_LABEL (page->menu_label), GTK_LABEL (page->tab_label)->label); else - gtk_label_set (GTK_LABEL (page->menu_label), string); + gtk_label_set_text (GTK_LABEL (page->menu_label), string); } } } diff --git a/gtk/gtkstatusbar.c b/gtk/gtkstatusbar.c index 9cca6fd55..d5aa931b2 100644 --- a/gtk/gtkstatusbar.c +++ b/gtk/gtkstatusbar.c @@ -155,7 +155,7 @@ gtk_statusbar_update (GtkStatusbar *statusbar, if (!text) text = ""; - gtk_label_set (GTK_LABEL (statusbar->label), text); + gtk_label_set_text (GTK_LABEL (statusbar->label), text); } guint diff --git a/gtk/gtktipsquery.c b/gtk/gtktipsquery.c index 2c8b03767..53707d78c 100644 --- a/gtk/gtktipsquery.c +++ b/gtk/gtktipsquery.c @@ -173,7 +173,7 @@ gtk_tips_query_init (GtkTipsQuery *tips_query) tips_query->last_crossed = NULL; tips_query->query_cursor = NULL; - gtk_label_set (GTK_LABEL (tips_query), tips_query->label_inactive); + gtk_label_set_text (GTK_LABEL (tips_query), tips_query->label_inactive); } static void @@ -367,7 +367,7 @@ gtk_tips_query_real_stop_query (GtkTipsQuery *tips_query) tips_query->last_crossed = NULL; } - gtk_label_set (GTK_LABEL (tips_query), tips_query->label_inactive); + gtk_label_set_text (GTK_LABEL (tips_query), tips_query->label_inactive); } static void @@ -383,7 +383,7 @@ gtk_tips_query_widget_entered (GtkTipsQuery *tips_query, tip_text = tips_query->label_no_tip; if (!g_str_equal (GTK_LABEL (tips_query)->label, (gchar*) tip_text)) - gtk_label_set (GTK_LABEL (tips_query), tip_text); + gtk_label_set_text (GTK_LABEL (tips_query), tip_text); } static void diff --git a/gtk/testgtk.c b/gtk/testgtk.c index 72e8d05e2..00b68bd1b 100644 --- a/gtk/testgtk.c +++ b/gtk/testgtk.c @@ -1622,6 +1622,96 @@ create_handle_box (void) gtk_widget_destroy (window); } +/* + * Label Demo + */ +void create_labels (void) +{ + static GtkWidget *window = NULL; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *frame; + GtkWidget *label; + + if (!window) + { + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + gtk_window_set_title (GTK_WINDOW (window), "Label"); + vbox = gtk_vbox_new (FALSE, 5); + hbox = gtk_hbox_new (FALSE, 5); + gtk_container_add (GTK_CONTAINER (window), hbox); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (window), 5); + + frame = gtk_frame_new ("Normal Label"); + label = gtk_label_new ("This is a Normal label"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Multi-line Label"); + label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Left Justified Label"); + label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Right Justified Label"); + label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + vbox = gtk_vbox_new (FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + frame = gtk_frame_new ("Line wrapped label"); + label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\ + "up the entire "/* big space to test spacing */\ + "width allocated to it, but automatically wraps the words to fit. "\ + "The time has come, for all good men, to come to the aid of their party. "\ + "The sixth sheik's six sheep's sick.\n"\ + " It supports multiple paragraphs correctly, and correctly adds "\ + "many extra spaces. "); + + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Filled, wrapped label"); + label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\ + "up the entire width allocated to it. Here is a seneance to prove "\ + "my point. Here is another sentence. "\ + "Here comes the sun, do de do de do.\n"\ + " This is a new paragraph.\n"\ + " This is another newer, longer, better paragraph. It is coming to an end, "\ + "unfortunately."); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Underlined label"); + label = gtk_label_new ("This label is underlined!\n" + "This one is underlined in ÆüËܸì¤ÎÆþÍÑquite a funky fashion"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); + gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + } + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show_all (window); + else + gtk_widget_destroy (window); +} + /* * Reparent demo */ @@ -1755,9 +1845,9 @@ uposition_configure (GtkWidget *window) gdk_window_get_root_origin (window->window, &upositionx, &upositiony); sprintf (buffer, "%d", upositionx); - gtk_label_set (lx, buffer); + gtk_label_set_text (lx, buffer); sprintf (buffer, "%d", upositiony); - gtk_label_set (ly, buffer); + gtk_label_set_text (ly, buffer); return FALSE; } @@ -1935,7 +2025,7 @@ tips_query_widget_entered (GtkTipsQuery *tips_query, { if (GTK_TOGGLE_BUTTON (toggle)->active) { - gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); + gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); /* don't let GtkTipsQuery reset it's label */ gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered"); } @@ -2772,7 +2862,7 @@ get_value (GtkWidget *widget, gpointer data) else sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value_as_float (spin)); - gtk_label_set (label, buf); + gtk_label_set_text (label, buf); } static void @@ -2939,7 +3029,7 @@ create_spins (void) gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0); - gtk_label_set (GTK_LABEL (val_label), "0"); + gtk_label_set_text (GTK_LABEL (val_label), "0"); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0); @@ -3026,9 +3116,9 @@ set_cursor (GtkWidget *spinner, while (vals && vals->value != c) vals++; if (vals) - gtk_label_set (GTK_LABEL (label), vals->value_nick); + gtk_label_set_text (GTK_LABEL (label), vals->value_nick); else - gtk_label_set (GTK_LABEL (label), ""); + gtk_label_set_text (GTK_LABEL (label), ""); cursor = gdk_cursor_new (c); gdk_window_set_cursor (widget->window, cursor); @@ -4153,16 +4243,16 @@ void after_press (GtkCTree *ctree, gpointer data) char buf[80]; sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); - gtk_label_set (GTK_LABEL (sel_label), buf); + gtk_label_set_text (GTK_LABEL (sel_label), buf); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); - gtk_label_set (GTK_LABEL (vis_label), buf); + gtk_label_set_text (GTK_LABEL (vis_label), buf); sprintf (buf, "%d", books); - gtk_label_set (GTK_LABEL (book_label), buf); + gtk_label_set_text (GTK_LABEL (book_label), buf); sprintf (buf, "%d", pages); - gtk_label_set (GTK_LABEL (page_label), buf); + gtk_label_set_text (GTK_LABEL (page_label), buf); } void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent, @@ -6930,7 +7020,7 @@ progress_value_changed (GtkAdjustment *adj, ProgressData *pdata) else sprintf (buf, "%.0f%%", 100 * gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar))); - gtk_label_set (GTK_LABEL (pdata->label), buf); + gtk_label_set_text (GTK_LABEL (pdata->label), buf); } static void @@ -7795,7 +7885,7 @@ timeout_test (GtkWidget *label) static char buffer[32]; sprintf (buffer, "count: %d", ++count); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); return TRUE; } @@ -7902,7 +7992,7 @@ idle_test (GtkWidget *label) static char buffer[32]; sprintf (buffer, "count: %d", ++count); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); return TRUE; } @@ -8347,6 +8437,7 @@ create_main_window (void) { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, { "item factory", create_item_factory }, + { "labels", create_labels }, { "layout", create_layout }, { "list", create_list }, { "menus", create_menus }, diff --git a/gtk/testthreads.c b/gtk/testthreads.c index c89ad5885..999c5e0d4 100644 --- a/gtk/testthreads.c +++ b/gtk/testthreads.c @@ -82,7 +82,7 @@ counter (void *data) while (!flag) { sprintf(buffer, "%d", counter); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); gtk_threads_leave(); counter++; /* Give someone else a chance to get the lock next time. diff --git a/tests/testgtk.c b/tests/testgtk.c index 72e8d05e2..00b68bd1b 100644 --- a/tests/testgtk.c +++ b/tests/testgtk.c @@ -1622,6 +1622,96 @@ create_handle_box (void) gtk_widget_destroy (window); } +/* + * Label Demo + */ +void create_labels (void) +{ + static GtkWidget *window = NULL; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *frame; + GtkWidget *label; + + if (!window) + { + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + gtk_window_set_title (GTK_WINDOW (window), "Label"); + vbox = gtk_vbox_new (FALSE, 5); + hbox = gtk_hbox_new (FALSE, 5); + gtk_container_add (GTK_CONTAINER (window), hbox); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (window), 5); + + frame = gtk_frame_new ("Normal Label"); + label = gtk_label_new ("This is a Normal label"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Multi-line Label"); + label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Left Justified Label"); + label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Right Justified Label"); + label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + vbox = gtk_vbox_new (FALSE, 5); + gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); + frame = gtk_frame_new ("Line wrapped label"); + label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\ + "up the entire "/* big space to test spacing */\ + "width allocated to it, but automatically wraps the words to fit. "\ + "The time has come, for all good men, to come to the aid of their party. "\ + "The sixth sheik's six sheep's sick.\n"\ + " It supports multiple paragraphs correctly, and correctly adds "\ + "many extra spaces. "); + + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Filled, wrapped label"); + label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\ + "up the entire width allocated to it. Here is a seneance to prove "\ + "my point. Here is another sentence. "\ + "Here comes the sun, do de do de do.\n"\ + " This is a new paragraph.\n"\ + " This is another newer, longer, better paragraph. It is coming to an end, "\ + "unfortunately."); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + frame = gtk_frame_new ("Underlined label"); + label = gtk_label_new ("This label is underlined!\n" + "This one is underlined in ÆüËܸì¤ÎÆþÍÑquite a funky fashion"); + gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); + gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____"); + gtk_container_add (GTK_CONTAINER (frame), label); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + + } + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show_all (window); + else + gtk_widget_destroy (window); +} + /* * Reparent demo */ @@ -1755,9 +1845,9 @@ uposition_configure (GtkWidget *window) gdk_window_get_root_origin (window->window, &upositionx, &upositiony); sprintf (buffer, "%d", upositionx); - gtk_label_set (lx, buffer); + gtk_label_set_text (lx, buffer); sprintf (buffer, "%d", upositiony); - gtk_label_set (ly, buffer); + gtk_label_set_text (ly, buffer); return FALSE; } @@ -1935,7 +2025,7 @@ tips_query_widget_entered (GtkTipsQuery *tips_query, { if (GTK_TOGGLE_BUTTON (toggle)->active) { - gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); + gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); /* don't let GtkTipsQuery reset it's label */ gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered"); } @@ -2772,7 +2862,7 @@ get_value (GtkWidget *widget, gpointer data) else sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value_as_float (spin)); - gtk_label_set (label, buf); + gtk_label_set_text (label, buf); } static void @@ -2939,7 +3029,7 @@ create_spins (void) gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0); - gtk_label_set (GTK_LABEL (val_label), "0"); + gtk_label_set_text (GTK_LABEL (val_label), "0"); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0); @@ -3026,9 +3116,9 @@ set_cursor (GtkWidget *spinner, while (vals && vals->value != c) vals++; if (vals) - gtk_label_set (GTK_LABEL (label), vals->value_nick); + gtk_label_set_text (GTK_LABEL (label), vals->value_nick); else - gtk_label_set (GTK_LABEL (label), ""); + gtk_label_set_text (GTK_LABEL (label), ""); cursor = gdk_cursor_new (c); gdk_window_set_cursor (widget->window, cursor); @@ -4153,16 +4243,16 @@ void after_press (GtkCTree *ctree, gpointer data) char buf[80]; sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); - gtk_label_set (GTK_LABEL (sel_label), buf); + gtk_label_set_text (GTK_LABEL (sel_label), buf); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); - gtk_label_set (GTK_LABEL (vis_label), buf); + gtk_label_set_text (GTK_LABEL (vis_label), buf); sprintf (buf, "%d", books); - gtk_label_set (GTK_LABEL (book_label), buf); + gtk_label_set_text (GTK_LABEL (book_label), buf); sprintf (buf, "%d", pages); - gtk_label_set (GTK_LABEL (page_label), buf); + gtk_label_set_text (GTK_LABEL (page_label), buf); } void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent, @@ -6930,7 +7020,7 @@ progress_value_changed (GtkAdjustment *adj, ProgressData *pdata) else sprintf (buf, "%.0f%%", 100 * gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar))); - gtk_label_set (GTK_LABEL (pdata->label), buf); + gtk_label_set_text (GTK_LABEL (pdata->label), buf); } static void @@ -7795,7 +7885,7 @@ timeout_test (GtkWidget *label) static char buffer[32]; sprintf (buffer, "count: %d", ++count); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); return TRUE; } @@ -7902,7 +7992,7 @@ idle_test (GtkWidget *label) static char buffer[32]; sprintf (buffer, "count: %d", ++count); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); return TRUE; } @@ -8347,6 +8437,7 @@ create_main_window (void) { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, { "item factory", create_item_factory }, + { "labels", create_labels }, { "layout", create_layout }, { "list", create_list }, { "menus", create_menus }, diff --git a/tests/testthreads.c b/tests/testthreads.c index c89ad5885..999c5e0d4 100644 --- a/tests/testthreads.c +++ b/tests/testthreads.c @@ -82,7 +82,7 @@ counter (void *data) while (!flag) { sprintf(buffer, "%d", counter); - gtk_label_set (GTK_LABEL (label), buffer); + gtk_label_set_text (GTK_LABEL (label), buffer); gtk_threads_leave(); counter++; /* Give someone else a chance to get the lock next time.