+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
+Tue Dec 15 14:30:35 1998 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdk.h gdk/gdkfonts.c: Added gdk_text_extents_wc()
+
+ * Patch from Jonathan Blanford <jrb@redhat.com> to add line wrapping
+ to label. (Based on patch from Jeff Dairiki
+ <dairiki@mac-ceope.apl.washington.edu> 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 <otaylor@redhat.com>
* gtk/gtkwidget.h: Added GTK_USER_DRAW flag.
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,
}
+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; i<text_length; i++)
+ text_8bit[i] = text[i];
+
+ XTextExtents (xfont, text_8bit, text_length,
+ &direction, &font_ascent, &font_descent,
+ &overall);
+ g_free (text_8bit);
+
+ if (lbearing)
+ *lbearing = overall.lbearing;
+ if (rbearing)
+ *rbearing = overall.rbearing;
+ if (width)
+ *width = overall.width;
+ if (ascent)
+ *ascent = overall.ascent;
+ if (descent)
+ *descent = overall.descent;
+ break;
+ }
+ case GDK_FONT_FONTSET:
+ fontset = (XFontSet) private->xfont;
+ 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,
}
+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; i<text_length; i++)
+ text_8bit[i] = text[i];
+
+ XTextExtents (xfont, text_8bit, text_length,
+ &direction, &font_ascent, &font_descent,
+ &overall);
+ g_free (text_8bit);
+
+ if (lbearing)
+ *lbearing = overall.lbearing;
+ if (rbearing)
+ *rbearing = overall.rbearing;
+ if (width)
+ *width = overall.width;
+ if (ascent)
+ *ascent = overall.ascent;
+ if (descent)
+ *descent = overall.descent;
+ break;
+ }
+ case GDK_FONT_FONTSET:
+ fontset = (XFontSet) private->xfont;
+ 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,
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);
}
"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:
#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
}
+++ /dev/null
-/* 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);
-}
+++ /dev/null
-/* 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 <gdk/gdk.h>
-#include <gtk/gtkwindow.h>
-
-
-#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__ */
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
{
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);
}
/* 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);
}
/**********************************************************************/
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.");
}
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.");
}
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);
}
/* 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);
}
-/* 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
*
* 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 <string.h>
#include "gtklabel.h"
#include "gdk/gdkkeysyms.h"
+#include "gdk/gdki18n.h"
enum {
ARG_0,
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);
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)
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));
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))
{
}
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)
{
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;i<line->length;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;j<line->length;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
*/
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)
*q = 0;
*r = 0;
- gtk_label_set (label, name);
gtk_label_set_pattern (label, pattern);
- g_free (name);
g_free (pattern);
return accel_key;
*
* 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__
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))
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
};
-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
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) &&
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);
}
}
}
if (!text)
text = "";
- gtk_label_set (GTK_LABEL (statusbar->label), text);
+ gtk_label_set_text (GTK_LABEL (statusbar->label), text);
}
guint
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
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
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
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
*/
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;
}
{
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");
}
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
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);
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), "<unknown>");
+ gtk_label_set_text (GTK_LABEL (label), "<unknown>");
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
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,
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
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;
}
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;
}
{ "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 },
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.
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
*/
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;
}
{
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");
}
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
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);
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), "<unknown>");
+ gtk_label_set_text (GTK_LABEL (label), "<unknown>");
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
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,
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
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;
}
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;
}
{ "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 },
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.
projects / ~andy / gtk / commitdiff