gtk2/gtk/gtklabel.c
Manish Singh f2322ebeb4 quell some warnings with g_hash_table_new
* gdk/gdkcolor.c:
(gdk_colormap_new) (gdk_colormap_get_system):
quell some warnings with g_hash_table_new

* gtk/gtkaccelgroup.c (gtk_accel_group_add): free the GtkSignalQuery when
we're done with it

* gtk/itemfactory.c:
(gtk_item_factory_from_path):
(gtk_item_factory_create_item): free some strings

* gtk/gtklabel.c:
(gtk_label_finalize): free label->pattern when done
(gtk_label_parse_uline): null terminate pattern string, delete some duplicated
code

* gtk/testthreads.c: add #include <unistd.h> for sleep()

-Yosh
1998-08-29 22:27:47 +00:00

636 lines
15 KiB
C

/* 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 <string.h>
#include "gtklabel.h"
#include "gdk/gdkkeysyms.h"
enum {
ARG_0,
ARG_LABEL,
ARG_PATTERN,
ARG_JUSTIFY
};
typedef struct _GtkLabelRow GtkLabelRow;
struct _GtkLabelRow {
gint index;
gint width;
gint height;
gint len;
};
GMemChunk *row_mem_chunk = NULL;
static void gtk_label_class_init (GtkLabelClass *klass);
static void gtk_label_init (GtkLabel *label);
static void gtk_label_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static void gtk_label_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static void gtk_label_finalize (GtkObject *object);
static void gtk_label_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static gint gtk_label_expose (GtkWidget *widget,
GdkEventExpose *event);
static void gtk_label_state_changed (GtkWidget *widget,
guint previous_state);
static void gtk_label_style_set (GtkWidget *widget,
GtkStyle *previous_style);
static void gtk_label_free_rows (GtkLabel *label);
static GtkMiscClass *parent_class = NULL;
GtkType
gtk_label_get_type (void)
{
static GtkType label_type = 0;
if (!label_type)
{
GtkTypeInfo label_info =
{
"GtkLabel",
sizeof (GtkLabel),
sizeof (GtkLabelClass),
(GtkClassInitFunc) gtk_label_class_init,
(GtkObjectInitFunc) gtk_label_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
label_type = gtk_type_unique (gtk_misc_get_type (), &label_info);
gtk_type_set_chunk_alloc (label_type, 32);
}
return label_type;
}
static void
gtk_label_class_init (GtkLabelClass *class)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
parent_class = gtk_type_class (gtk_misc_get_type ());
gtk_object_add_arg_type ("GtkLabel::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
gtk_object_add_arg_type ("GtkLabel::pattern", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_PATTERN);
gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
object_class->set_arg = gtk_label_set_arg;
object_class->get_arg = gtk_label_get_arg;
object_class->finalize = gtk_label_finalize;
widget_class->size_request = gtk_label_size_request;
widget_class->expose_event = gtk_label_expose;
widget_class->style_set = gtk_label_style_set;
widget_class->state_changed = gtk_label_state_changed;
}
static void
gtk_label_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
GtkLabel *label;
label = GTK_LABEL (object);
switch (arg_id)
{
case ARG_LABEL:
gtk_label_set (label, GTK_VALUE_STRING (*arg) ? GTK_VALUE_STRING (*arg) : "");
break;
case ARG_PATTERN:
gtk_label_set_pattern (label, GTK_VALUE_STRING (*arg));
break;
case ARG_JUSTIFY:
gtk_label_set_justify (label, GTK_VALUE_ENUM (*arg));
break;
default:
break;
}
}
static void
gtk_label_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
GtkLabel *label;
label = GTK_LABEL (object);
switch (arg_id)
{
case ARG_LABEL:
GTK_VALUE_STRING (*arg) = g_strdup (label->label);
break;
case ARG_PATTERN:
GTK_VALUE_STRING (*arg) = g_strdup (label->pattern);
break;
case ARG_JUSTIFY:
GTK_VALUE_ENUM (*arg) = label->jtype;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
gtk_label_init (GtkLabel *label)
{
GTK_WIDGET_SET_FLAGS (label, GTK_NO_WINDOW);
label->label = NULL;
label->row = NULL;
label->max_width = 0;
label->jtype = GTK_JUSTIFY_CENTER;
label->needs_clear = FALSE;
label->pattern = NULL;
gtk_label_set (label, "");
}
GtkWidget*
gtk_label_new (const gchar *str)
{
GtkLabel *label;
g_return_val_if_fail (str != NULL, NULL);
label = gtk_type_new (gtk_label_get_type ());
gtk_label_set (label, str);
return GTK_WIDGET (label);
}
void
gtk_label_set (GtkLabel *label,
const gchar *str)
{
char* p;
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);
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);
if (GTK_WIDGET_VISIBLE (label))
{
if (GTK_WIDGET_MAPPED (label))
gdk_window_clear_area (GTK_WIDGET (label)->window,
GTK_WIDGET (label)->allocation.x,
GTK_WIDGET (label)->allocation.y,
GTK_WIDGET (label)->allocation.width,
GTK_WIDGET (label)->allocation.height);
gtk_widget_queue_resize (GTK_WIDGET (label));
}
}
void
gtk_label_set_pattern (GtkLabel *label,
const gchar *pattern)
{
g_return_if_fail (label != NULL);
g_return_if_fail (GTK_IS_LABEL (label));
if (label->pattern)
g_free (label->pattern);
label->pattern = g_strdup (pattern);
if (GTK_WIDGET_VISIBLE (label))
{
if (GTK_WIDGET_MAPPED (label))
gdk_window_clear_area (GTK_WIDGET (label)->window,
GTK_WIDGET (label)->allocation.x,
GTK_WIDGET (label)->allocation.y,
GTK_WIDGET (label)->allocation.width,
GTK_WIDGET (label)->allocation.height);
gtk_widget_queue_resize (GTK_WIDGET (label));
}
}
void
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)
{
label->jtype = jtype;
if (GTK_WIDGET_VISIBLE (label))
{
if (GTK_WIDGET_MAPPED (label))
gdk_window_clear_area (GTK_WIDGET (label)->window,
GTK_WIDGET (label)->allocation.x,
GTK_WIDGET (label)->allocation.y,
GTK_WIDGET (label)->allocation.width,
GTK_WIDGET (label)->allocation.height);
gtk_widget_queue_resize (GTK_WIDGET (label));
}
}
}
void
gtk_label_get (GtkLabel *label,
gchar **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)
{
GtkLabel *label;
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_LABEL (object));
label = GTK_LABEL (object);
g_free (label->label);
if (label->pattern) g_free (label->pattern);
gtk_label_free_rows (label);
(* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
}
static gint
gtk_label_process_row (GtkLabel *label,
GtkLabelRow *row,
gint x, gint y,
gboolean draw)
{
GtkWidget *widget = GTK_WIDGET (label);
char lastc;
gint i, j;
gint offset;
gint height;
gint pattern_length;
if (label->pattern)
pattern_length = strlen (label->pattern);
else
pattern_length = 0;
offset = 0;
height = widget->style->font->ascent + widget->style->font->descent;
if (draw)
{
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);
}
if (label->pattern && (row->index < pattern_length))
lastc = label->pattern[0];
else
lastc = ' ';
j = 0;
for (i=1; i<=row->len; i++)
{
char c;
if (label->pattern && (row->index + i < pattern_length))
c = label->pattern[row->index+i];
else
c = ' ';
if ((i == row->len) || (lastc != c))
{
gint width = 0;
if (lastc == '_')
{
gint descent;
gint rbearing;
gint lbearing;
gdk_text_extents (widget->style->font,
&label->label[row->index+j], i - j,
&lbearing, &rbearing, &width, NULL, &descent);
if (draw)
{
if (widget->state == GTK_STATE_INSENSITIVE)
gdk_draw_line (widget->window,
widget->style->white_gc,
offset + x + lbearing, y + descent + 2,
offset + x + rbearing + 1, y + descent + 2);
gdk_draw_line (widget->window,
widget->style->fg_gc[widget->state],
offset + x + lbearing - 1, y + descent + 1,
offset + x + rbearing, y + descent + 1);
}
height = MAX (height,
widget->style->font->ascent + descent + 2);
}
else if (i != row->len)
{
width = gdk_text_width (widget->style->font,
&label->label[row->index+j],
i - j);
}
if (draw)
{
if (widget->state == GTK_STATE_INSENSITIVE)
gdk_draw_text (widget->window, widget->style->font,
widget->style->white_gc,
offset + x + 1, y + 1,
&label->label[row->index+j], i - j);
gdk_draw_text (widget->window, widget->style->font,
widget->style->fg_gc[widget->state],
offset + x, y,
&label->label[row->index+j], i - j);
}
offset += width;
if (i != row->len)
{
lastc = c;
j = i;
}
}
}
return height;
}
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)
{
GtkLabelRow *row = tmp_list->data;
row->width = gdk_text_width (GTK_WIDGET (label)->style->font,
&label->label [row->index],
row->len);
width = MAX (width, row->width);
requisition->height += gtk_label_process_row (label, row, 0, 0, FALSE) + 2;
tmp_list = tmp_list->next;
}
label->max_width = width;
requisition->width = width + label->misc.xpad * 2;
}
static gint
gtk_label_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkLabel *label;
GtkMisc *misc;
GSList *tmp_list;
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);
/*
* GC Clipping
*/
gdk_gc_set_clip_rectangle (widget->style->white_gc, &event->area);
gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state], &event->area);
/* We clear the whole allocation here so that if a partial
* expose is triggered we don't just clear part and mess up
* when the queued redraw comes along. (There will always
* be a complete queued redraw when the needs_clear flag
* is set.)
*/
if (label->needs_clear)
{
gdk_window_clear_area (widget->window,
widget->allocation.x,
widget->allocation.y,
widget->allocation.width,
widget->allocation.height);
label->needs_clear = FALSE;
}
x = widget->allocation.x + misc->xpad +
(widget->allocation.width - (label->max_width + label->misc.xpad * 2))
* 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 += gtk_label_process_row (label, tmp_list->data, x, y, TRUE) + 2;
tmp_list = tmp_list->next;
}
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;
}
static void
gtk_label_state_changed (GtkWidget *widget,
guint previous_state)
{
if (GTK_WIDGET_DRAWABLE (widget))
GTK_LABEL (widget)->needs_clear = TRUE;
}
static void
gtk_label_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
if (GTK_WIDGET_DRAWABLE (widget))
GTK_LABEL (widget)->needs_clear = TRUE;
}
guint
gtk_label_parse_uline (GtkLabel *label,
const gchar *string)
{
guint accel_key = GDK_VoidSymbol;
const gchar *p;
gchar *q, *r;
gchar *name, *pattern;
gint length;
gboolean underscore;
length = strlen (string);
name = g_new (gchar, length+1);
pattern = g_new (gchar, length+1);
underscore = FALSE;
p = string;
q = name;
r = pattern;
while (*p)
{
if (underscore)
{
if (*p == '_')
*r++ = ' ';
else
{
*r++ = '_';
if (accel_key == GDK_VoidSymbol)
accel_key = gdk_keyval_to_lower (*p);
}
*q++ = *p;
underscore = FALSE;
}
else
{
if (*p == '_')
underscore = TRUE;
else
{
*q++ = *p;
*r++ = ' ';
}
}
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;
}