/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_accel_label_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
gboolean translatable, context;
gchar *comments;
if (data->create_widget)
{
const gchar *label_text = gtk_label_get_label (GTK_LABEL (widget));
glade_util_get_translation_properties (widget, Label, &translatable,
&comments, &context);
source_add_translator_comments (data, translatable, comments);
source_add (data, " %s = gtk_accel_label_new (%s);\n", data->wname,
source_make_string_full (label_text,
data->use_gettext && translatable,
context));
}
gb_widget_write_standard_source (widget, data);
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
source_add (data,
" gtk_label_set_use_underline (GTK_LABEL (%s), TRUE);\n",
data->wname);
gb_label_write_standard_source (widget, data,
Label, UseUnderline, UseMarkup,
Justify, Wrap, Selectable,
XAlign, YAlign, XPad, YPad,
FocusTarget, Ellipsize, WidthChars,
SingleLineMode, Angle);
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
if (GTK_IS_LABEL (button->priv->label_widget))
{
label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
}
else if (button->priv->label_text)
{
label = button->priv->label_text;
use_mnemonic = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (GTK_IS_IMAGE (button->priv->icon_widget))
{
menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
gtk_widget_get_settings (GTK_WIDGET (button)));
}
else if (button->priv->stock_id)
{
menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_label_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
if (data->create_widget)
{
const gchar *label_text = gtk_label_get_label (GTK_LABEL (widget));
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
source_add (data, " %s = gtk_label_new_with_mnemonic (%s);\n",
data->wname,
source_make_string (label_text, data->use_gettext));
else
source_add (data, " %s = gtk_label_new (%s);\n",
data->wname,
source_make_string (label_text, data->use_gettext));
}
gb_widget_write_standard_source (widget, data);
gb_label_write_standard_source (widget, data,
Label, UseUnderline, UseMarkup,
Justify, Wrap, Selectable,
XAlign, YAlign, XPad, YPad,
FocusTarget);
}
/**
\brief Speical function to obtain the text assigned to the button widget.
**/
Tcl_Obj *gnoclCgetButtonText ( Tcl_Interp *interp, GtkButton *button )
{
Tcl_Obj *obj = NULL;
if ( gtk_button_get_use_stock ( button ) )
{
const char *st = gtk_button_get_label ( button );
if ( st == NULL )
{
obj = Tcl_NewStringObj ( "", 0 );
}
else
{
obj = Tcl_NewStringObj ( "%#", 2 );
Tcl_AppendObjToObj ( obj, gnoclGtkToStockName ( st ) );
}
}
else
{
GtkLabel *label = GTK_LABEL ( gnoclFindChild ( GTK_WIDGET ( button ), GTK_TYPE_LABEL ) );
Tcl_Obj *old = Tcl_NewStringObj ( gtk_label_get_label ( label ), -1 );
assert ( label );
if ( gtk_label_get_use_markup ( label ) )
{
obj = Tcl_NewStringObj ( "%<", 2 );
Tcl_AppendObjToObj ( obj, old );
}
else if ( gtk_label_get_use_underline ( label ) )
{
obj = Tcl_NewStringObj ( "%_", 2 );
Tcl_AppendObjToObj ( obj, old );
}
else
{
obj = old;
}
}
return obj;
}
/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_accel_label_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
if (data->create_widget)
{
const gchar *label_text = gtk_label_get_label (GTK_LABEL (widget));
source_add (data, " %s = gtk_accel_label_new (%s);\n", data->wname,
source_make_string (label_text, data->use_gettext));
}
gb_widget_write_standard_source (widget, data);
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
source_add (data, " gtk_label_set_use_underline (%s, TRUE);\n",
data->wname);
}
void
gb_label_write_standard_source (GtkWidget * widget,
GbWidgetWriteSourceData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
GtkWidget *accel_target = NULL;
gint i;
if (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p))
source_add (data, " gtk_label_set_use_markup (GTK_LABEL (%s), TRUE);\n",
data->wname);
/* If there is an underlined accelerator, set up the accel signal.
If the label is in a button or something similar, this is now setup
automatically by GTK+. If the accelerator is being used to set focus
to something like a GtkEntry, we need to set the mnemonic_widget. */
if (gtk_label_get_use_underline (GTK_LABEL (widget))
&& !gb_label_find_mnemonic_widget (widget))
{
gchar *target_name = gtk_object_get_data (GTK_OBJECT (widget),
focus_target_p);
if (target_name)
accel_target = glade_util_find_widget (gtk_widget_get_toplevel (widget), target_name);
if (!accel_target)
accel_target = glade_util_find_default_accelerator_target (widget);
if (accel_target)
{
target_name = (gchar*) gtk_widget_get_name (accel_target);
target_name = source_create_valid_identifier (target_name);
source_add_to_buffer (data, GLADE_ACCELERATORS,
" gtk_label_set_mnemonic_widget (GTK_LABEL (%s), %s);\n",
data->wname, target_name);
g_free (target_name);
}
}
if (GTK_LABEL (widget)->jtype != GTK_JUSTIFY_CENTER)
{
for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]);
i++)
{
if (GbJustifyValues[i] == GTK_LABEL (widget)->jtype)
source_add (data,
" gtk_label_set_justify (GTK_LABEL (%s), %s);\n",
data->wname, GbJustifySymbols[i]);
}
}
if (GTK_LABEL (widget)->wrap)
source_add (data, " gtk_label_set_line_wrap (GTK_LABEL (%s), TRUE);\n",
data->wname);
if (gtk_label_get_selectable (GTK_LABEL (widget)))
source_add (data, " gtk_label_set_selectable (GTK_LABEL (%s), TRUE);\n",
data->wname);
if (fabs (GTK_MISC (widget)->xalign - 0.5) > 0.0001
|| fabs (GTK_MISC (widget)->yalign - 0.5) > 0.0001)
source_add (data, " gtk_misc_set_alignment (GTK_MISC (%s), %g, %g);\n",
data->wname, GTK_MISC (widget)->xalign, GTK_MISC (widget)->yalign);
if (GTK_MISC (widget)->xpad != 0 || GTK_MISC (widget)->ypad != 0)
source_add (data, " gtk_misc_set_padding (GTK_MISC (%s), %i, %i);\n",
data->wname, GTK_MISC (widget)->xpad, GTK_MISC (widget)->ypad);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
void
gb_label_set_standard_properties (GtkWidget * widget,
GbWidgetSetArgData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
gchar *label, *justify, *accel_target;
const gchar *label_text;
gfloat xalign, yalign;
gint xpad, ypad, i;
gboolean wrap, selectable, set_alignment = FALSE, set_padding = FALSE;
gboolean use_underline, use_markup;
gboolean set_label = FALSE;
use_underline = gb_widget_input_bool (data, use_underline_p);
if (data->apply)
gtk_label_set_use_underline (GTK_LABEL (widget), use_underline);
use_markup = gb_widget_input_bool (data, use_markup_p);
if (data->apply)
{
set_label = TRUE;
gtk_object_set_data (GTK_OBJECT (widget), use_markup_p,
GINT_TO_POINTER (use_markup));
}
label = gb_widget_input_text (data, label_p);
if (data->apply)
{
set_label = TRUE;
label_text = label;
}
else
{
label_text = gtk_label_get_label (GTK_LABEL (widget));
}
if (set_label)
{
gboolean prev_use_markup;
use_markup = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
use_markup_p));
/* We try to parse the markup here, and if it isn't valid, we will
turn use_markup off and show it as plain text. */
if (use_markup)
{
GError *error = NULL;
gunichar accel_marker = 0;
PangoAttrList *attrs = NULL;
gunichar accel_char = 0;
gchar *text = NULL;
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
accel_marker = '_';
/* We check it is valid markup. If it isn't we will set "use_markup"
to FALSE. Note that we don't need attrs, text, or accel_char but
it seems to crash otherwise. */
if (!pango_parse_markup (label_text, -1, accel_marker, &attrs, &text,
&accel_char, &error))
{
use_markup = FALSE;
g_error_free (error);
}
else
{
if (attrs)
pango_attr_list_unref (attrs);
g_free (text);
}
}
/* If we are turning use_markup off, we want to do that before setting
the text. If we are turning it on, we want to do it after. */
prev_use_markup = gtk_label_get_use_markup (GTK_LABEL (widget));
if (!use_markup && prev_use_markup)
gtk_label_set_use_markup (GTK_LABEL (widget), use_markup);
gtk_label_set_label (GTK_LABEL (widget), label_text);
if (use_markup && !prev_use_markup)
gtk_label_set_use_markup (GTK_LABEL (widget), use_markup);
}
if (data->action == GB_APPLYING)
g_free (label);
justify = gb_widget_input_choice (data, justify_p);
if (data->apply)
{
for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]);
i++)
{
if (!strcmp (justify, GbJustifyChoices[i])
|| !strcmp (justify, GbJustifySymbols[i]))
{
gtk_label_set_justify (GTK_LABEL (widget), GbJustifyValues[i]);
break;
}
}
}
wrap = gb_widget_input_bool (data, wrap_p);
if (data->apply)
gtk_label_set_line_wrap (GTK_LABEL (widget), wrap);
selectable = gb_widget_input_bool (data, selectable_p);
if (data->apply)
gtk_label_set_selectable (GTK_LABEL (widget), selectable);
xalign = gb_widget_input_float (data, xalign_p);
if (data->apply)
set_alignment = TRUE;
else
xalign = GTK_MISC (widget)->xalign;
yalign = gb_widget_input_float (data, yalign_p);
if (data->apply)
set_alignment = TRUE;
else
yalign = GTK_MISC (widget)->yalign;
if (set_alignment)
gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign);
xpad = gb_widget_input_int (data, xpad_p);
if (data->apply)
set_padding = TRUE;
else
xpad = GTK_MISC (widget)->xpad;
ypad = gb_widget_input_int (data, ypad_p);
if (data->apply)
set_padding = TRUE;
else
ypad = GTK_MISC (widget)->ypad;
if (set_padding)
gtk_misc_set_padding (GTK_MISC (widget), xpad, ypad);
/* Labels not in buttons may have a focus target widget. */
accel_target = gb_widget_input_combo (data, focus_target_p);
if (data->apply)
{
if (!gb_label_find_mnemonic_widget (widget))
{
if (!strcmp (accel_target, _("Auto")))
accel_target = NULL;
gtk_object_set_data_full (GTK_OBJECT (widget), focus_target_p,
g_strdup (accel_target),
accel_target ? g_free : NULL);
}
}
}
void
gb_label_get_standard_properties (GtkWidget * widget,
GbWidgetGetArgData * data,
const char *label_p,
const char *use_underline_p,
const char *use_markup_p,
const char *justify_p,
const char *wrap_p,
const char *selectable_p,
const char *xalign_p,
const char *yalign_p,
const char *xpad_p,
const char *ypad_p,
const char *focus_target_p)
{
const gchar *label_text;
gint i;
label_text = gtk_label_get_label (GTK_LABEL (widget));
gb_widget_output_translatable_text (data, label_p, label_text);
gb_widget_output_bool (data, use_underline_p,
gtk_label_get_use_underline (GTK_LABEL (widget)));
gb_widget_output_bool (data, use_markup_p,
GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)));
for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++)
{
if (GbJustifyValues[i] == GTK_LABEL (widget)->jtype)
gb_widget_output_choice (data, justify_p, i, GbJustifySymbols[i]);
}
gb_widget_output_bool (data, wrap_p, GTK_LABEL (widget)->wrap);
gb_widget_output_bool (data, selectable_p,
gtk_label_get_selectable (GTK_LABEL (widget)));
gb_widget_output_float (data, xalign_p, GTK_MISC (widget)->xalign);
gb_widget_output_float (data, yalign_p, GTK_MISC (widget)->yalign);
gb_widget_output_int (data, xpad_p, GTK_MISC (widget)->xpad);
gb_widget_output_int (data, ypad_p, GTK_MISC (widget)->ypad);
/* Labels not in buttons may have a focus target widget. */
if (!gb_label_find_mnemonic_widget (widget))
{
gchar *accel_target;
accel_target = gtk_object_get_data (GTK_OBJECT (widget), focus_target_p);
/* If we're showing we need to display the list of possible focus target
widgets. We walk the tree of widgets in this component, and if a
widget has CAN_FOCUS set, we add it to the list. */
if (data->action == GB_SHOWING)
{
GList *focus_targets = NULL, *standard_items = NULL;
GtkWidget *item, *combo;
property_set_visible (focus_target_p, TRUE);
gb_label_get_focus_targets (gtk_widget_get_toplevel (widget),
&focus_targets);
property_set_combo_strings (focus_target_p, focus_targets);
g_list_free (focus_targets);
combo = property_get_value_widget (focus_target_p);
item = gtk_list_item_new_with_label (_("Auto"));
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
item = gtk_list_item_new ();
gtk_widget_set_sensitive (item, FALSE);
gtk_widget_show (item);
standard_items = g_list_append (standard_items, item);
gtk_combo_set_item_string (GTK_COMBO (combo), GTK_ITEM (item), "");
gtk_list_prepend_items (GTK_LIST (GTK_COMBO (combo)->list),
standard_items);
if (!accel_target)
{
accel_target = _("Auto");
}
gb_widget_output_combo (data, focus_target_p, accel_target);
}
else
{
/* When saving, we only save the property if it has been set. */
if (accel_target)
{
/* First check that the widget is still there, and if it isn't
just skip it. */
if (glade_util_find_widget (gtk_widget_get_toplevel (widget),
accel_target))
{
gb_widget_output_combo (data, focus_target_p, accel_target);
}
}
else
{
/* If no target has been set, and the label has an underlined
key, we try to find a default target and save that. */
if (gtk_label_get_use_underline (GTK_LABEL (widget)))
{
GtkWidget *accel_target;
accel_target = glade_util_find_default_accelerator_target (widget);
if (accel_target)
{
gb_widget_output_string (data, focus_target_p, gtk_widget_get_name (accel_target));
}
}
}
}
}
else
{
if (data->action == GB_SHOWING)
{
property_set_visible (focus_target_p, FALSE);
}
}
}
static gboolean
gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (item);
GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item);
GtkWidget *menu_item = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
GtkWidget *label_widget;
const gchar *label_text;
const gchar *stock_id;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
label_widget = gtk_tool_button_get_label_widget (tool_button);
label_text = gtk_tool_button_get_label (tool_button);
stock_id = gtk_tool_button_get_stock_id (tool_button);
if (GTK_IS_LABEL (label_widget))
{
label = gtk_label_get_label (GTK_LABEL (label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (label_widget));
}
else if (label_text)
{
label = label_text;
use_mnemonic = gtk_tool_button_get_use_underline (tool_button);
}
else if (stock_id && gtk_stock_lookup (stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_check_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->priv->active);
if (GTK_IS_RADIO_TOOL_BUTTON (toggle_tool_button))
{
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_item),
TRUE);
}
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object (G_CALLBACK (menu_item_activated),
G_OBJECT (toggle_tool_button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
Php::Value GtkLabel_::get_use_underline()
{
gboolean ret = gtk_label_get_use_underline (GTK_LABEL(instance));
return ret;
}
