+2005-09-01 Matthias Clasen <mclasen@redhat.com>
+
+ * gdk/*.c: Intern some more strings.
+ * gtk/gtkintl.h:
+ * gtk/*.c: Define an I_() macro and use it instead of the
+ bulky g_intern_static_string().
+
2005-08-31 Matthias Clasen <mclasen@redhat.com>
-
+
+ * gtk/gtkbindings.c (binding_signal_new): Intern the signal name
+ instead of copying it.
+
+ * gtk/gtktypeutils.c (gtk_identifier_get_type): Some more string interning.
+
* gtk/*.c: Also intern static strings passed to
g_object_set_data().
+2005-09-01 Matthias Clasen <mclasen@redhat.com>
+
+ * gdk/*.c: Intern some more strings.
+ * gtk/gtkintl.h:
+ * gtk/*.c: Define an I_() macro and use it instead of the
+ bulky g_intern_static_string().
+
2005-08-31 Matthias Clasen <mclasen@redhat.com>
-
+
+ * gtk/gtkbindings.c (binding_signal_new): Intern the signal name
+ instead of copying it.
+
+ * gtk/gtktypeutils.c (gtk_identifier_get_type): Some more string interning.
+
* gtk/*.c: Also intern static strings passed to
g_object_set_data().
m4_define([gtk_binary_version], [2.4.0])
# required versions of other packages
-m4_define([glib_required_version], [2.7.1])
+m4_define([glib_required_version], [2.9.0])
m4_define([pango_required_version], [1.9.0])
m4_define([atk_required_version], [1.0.1])
m4_define([cairo_required_version], [0.9.2])
* Since: 2.2
*/
signals[CLOSED] =
- g_signal_new ("closed",
+ g_signal_new (g_intern_static_string ("closed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkDisplayClass, closed),
* Since: 2.2
*/
signals[DISPLAY_OPENED] =
- g_signal_new ("display_opened",
+ g_signal_new (g_intern_static_string ("display_opened"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkDisplayManagerClass, display_opened),
g_signal_handlers_disconnect_by_func (renderer->priv->screen,
(gpointer)on_renderer_display_closed,
renderer);
- g_object_set_data (G_OBJECT (renderer->priv->screen), "gdk-pango-renderer", NULL);
+ g_object_set_data (G_OBJECT (renderer->priv->screen),
+ g_intern_static_string ("gdk-pango-renderer"), NULL);
}
/**
if (!renderer)
{
renderer = gdk_pango_renderer_new (screen);
- g_object_set_data_full (G_OBJECT (screen), "gdk-pango-renderer", renderer,
+ g_object_set_data_full (G_OBJECT (screen),
+ g_intern_static_string ("gdk-pango-renderer"), renderer,
(GDestroyNotify)g_object_unref);
g_signal_connect (gdk_screen_get_display (screen), "closed",
g_param_spec_pointer ("font-options",
P_("Font options"),
P_("The default font options for the screen"),
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE|G_PARAM_STATIC_NAME|
+ G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
g_object_class_install_property (object_class,
PROP_RESOLUTION,
-G_MAXDOUBLE,
G_MAXDOUBLE,
-1.0,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE|G_PARAM_STATIC_NAME|
+ G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
/**
* GdkScreen::size-changed:
* Since: 2.2
*/
signals[SIZE_CHANGED] =
- g_signal_new ("size_changed",
+ g_signal_new (g_intern_static_string ("size_changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkScreenClass, size_changed),
parent_class = g_type_class_peek_parent (klass);
signals[WINDOW_MANAGER_CHANGED] =
- g_signal_new ("window_manager_changed",
+ g_signal_new (g_intern_static_string ("window_manager_changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkScreenX11Class, window_manager_changed),
if (activate_url_hook != NULL)
{
g_object_set_data_full (G_OBJECT (priv->website_button),
- g_intern_static_string ("url"),
+ I_("url"),
g_strdup (website), g_free);
if (priv->website_label == NULL)
gtk_about_dialog_set_website_label (about, website);
{
priv->website = NULL;
g_object_set_data (G_OBJECT (priv->website_button),
- g_intern_static_string ("url"), NULL);
+ I_("url"), NULL);
gtk_widget_hide (priv->website_button);
}
g_free (tmp);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
g_object_set_data_full (G_OBJECT (button),
- g_intern_static_string ("url"),
+ I_("url"),
g_strdup (url), g_free);
set_link_button_text (about, button, text);
{
q1++;
q0++;
- link_type = g_intern_static_string ("email");
+ link_type = I_("email");
}
else
- link_type = g_intern_static_string ("url");
+ link_type = I_("url");
link = g_strndup (q1, q2 - q1);
tag = gtk_text_buffer_create_tag (buffer, NULL,
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
g_object_set_data_full (G_OBJECT (parent),
- g_intern_static_string ("gtk-about-dialog"),
+ I_("gtk-about-dialog"),
dialog, g_object_unref);
}
else
(GInstanceInitFunc) gtk_accel_group_init,
};
- object_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkAccelGroup"),
+ object_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkAccelGroup"),
&object_info, 0);
}
* Returns: %TRUE if the accelerator was activated
*/
signal_accel_activate =
- g_signal_new ("accel_activate",
+ g_signal_new (I_("accel_activate"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_DETAILED,
0,
* their visual representation if the @accel_closure is theirs.
*/
signal_accel_changed =
- g_signal_new ("accel_changed",
+ g_signal_new (I_("accel_changed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED,
G_STRUCT_OFFSET (GtkAccelGroupClass, accel_changed),
};
accel_label_type =
- g_type_register_static (GTK_TYPE_LABEL, g_intern_static_string ("GtkAccelLabel"),
+ g_type_register_static (GTK_TYPE_LABEL, I_("GtkAccelLabel"),
&accel_label_info, 0);
}
#include "gtkmarshalers.h"
#include "gtkwindow.h" /* in lack of GtkAcceleratable */
+#include "gtkintl.h"
#include "gtkalias.h"
#include <glib/gstdio.h>
*
* Since: 2.4
*/
- accel_map_signals[CHANGED] = g_signal_new ("changed",
+ accel_map_signals[CHANGED] = g_signal_new (I_("changed"),
G_TYPE_FROM_CLASS (accel_map_class),
G_SIGNAL_DETAILED|G_SIGNAL_RUN_LAST,
0,
#include <string.h>
#include "gtkwidget.h"
+#include "gtkintl.h"
#include "gtkaccessible.h"
#include "gtkalias.h"
};
accessible_type =
- g_type_register_static (ATK_TYPE_OBJECT, g_intern_static_string ("GtkAccessible"),
+ g_type_register_static (ATK_TYPE_OBJECT, I_("GtkAccessible"),
&accessible_info, 0);
}
};
type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkAction"),
+ I_("GtkAction"),
&type_info, 0);
}
return type;
* Since: 2.4
*/
action_signals[ACTIVATE] =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkActionClass, activate), NULL, NULL,
GtkWidget *proxy)
{
g_object_ref (action);
- g_object_set_data_full (G_OBJECT (proxy), g_intern_static_string ("gtk-action"), action,
+ g_object_set_data_full (G_OBJECT (proxy), I_("gtk-action"), action,
g_object_unref);
/* add this widget to the list of proxies */
disconnect_proxy (GtkAction *action,
GtkWidget *proxy)
{
- g_object_set_data (G_OBJECT (proxy), g_intern_static_string ("gtk-action"), NULL);
+ g_object_set_data (G_OBJECT (proxy), I_("gtk-action"), NULL);
/* remove proxy from list of proxies */
g_signal_handlers_disconnect_by_func (proxy,
(GInstanceInitFunc) gtk_action_group_init,
};
- type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkActionGroup"),
+ type = g_type_register_static (G_TYPE_OBJECT, I_("GtkActionGroup"),
&type_info, 0);
}
* Since: 2.4
*/
action_group_signals[CONNECT_PROXY] =
- g_signal_new ("connect_proxy",
+ g_signal_new (I_("connect_proxy"),
G_OBJECT_CLASS_TYPE (klass),
0, 0, NULL, NULL,
_gtk_marshal_VOID__OBJECT_OBJECT,
* Since: 2.4
*/
action_group_signals[DISCONNECT_PROXY] =
- g_signal_new ("disconnect_proxy",
+ g_signal_new (I_("disconnect_proxy"),
G_OBJECT_CLASS_TYPE (klass),
0, 0, NULL, NULL,
_gtk_marshal_VOID__OBJECT_OBJECT,
* Since: 2.4
*/
action_group_signals[PRE_ACTIVATE] =
- g_signal_new ("pre_activate",
+ g_signal_new (I_("pre_activate"),
G_OBJECT_CLASS_TYPE (klass),
0, 0, NULL, NULL,
_gtk_marshal_VOID__OBJECT,
* Since: 2.4
*/
action_group_signals[POST_ACTIVATE] =
- g_signal_new ("post_activate",
+ g_signal_new (I_("post_activate"),
G_OBJECT_CLASS_TYPE (klass),
0, 0, NULL, NULL,
_gtk_marshal_VOID__OBJECT,
};
adjustment_type =
- g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkAdjustment"),
+ g_type_register_static (GTK_TYPE_OBJECT, I_("GtkAdjustment"),
&adjustment_info, 0);
}
adjustment_signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkAdjustmentClass, changed),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
adjustment_signals[VALUE_CHANGED] =
- g_signal_new ("value_changed",
+ g_signal_new (I_("value_changed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkAdjustmentClass, value_changed),
(GInstanceInitFunc) gtk_alignment_init,
};
- alignment_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkAlignment"),
+ alignment_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkAlignment"),
&alignment_info, 0);
}
(GInstanceInitFunc) gtk_arrow_init,
};
- arrow_type = g_type_register_static (GTK_TYPE_MISC, g_intern_static_string ("GtkArrow"),
+ arrow_type = g_type_register_static (GTK_TYPE_MISC, I_("GtkArrow"),
&arrow_info, 0);
}
};
aspect_frame_type =
- g_type_register_static (GTK_TYPE_FRAME, g_intern_static_string ("GtkAspectFrame"),
+ g_type_register_static (GTK_TYPE_FRAME, I_("GtkAspectFrame"),
&aspect_frame_info, 0);
}
};
button_box_type =
- g_type_register_static (GTK_TYPE_BOX, g_intern_static_string ("GtkButtonBox"),
+ g_type_register_static (GTK_TYPE_BOX, I_("GtkButtonBox"),
&button_box_info, G_TYPE_FLAG_ABSTRACT);
}
#include <config.h>
#include "gtkbin.h"
+#include "gtkintl.h"
#include "gtkalias.h"
NULL, /* value_table */
};
- bin_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkBin"),
+ bin_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkBin"),
&bin_info, G_TYPE_FLAG_ABSTRACT);
}
signal = g_new (GtkBindingSignal, 1);
signal->next = NULL;
- signal->signal_name = g_strdup (signal_name);
+ signal->signal_name = g_intern_string (signal_name);
signal->n_args = n_args;
signal->args = g_new0 (GtkBindingArg, n_args);
g_free (sig->args[i].d.string_data);
}
g_free (sig->args);
- g_free (sig->signal_name);
g_free (sig);
}
NULL, /* value_table */
};
- box_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkBox"),
+ box_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkBox"),
&box_info, G_TYPE_FLAG_ABSTRACT);
}
(GInstanceInitFunc) gtk_button_init,
};
- button_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkButton"),
+ button_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkButton"),
&button_info, 0);
}
* @Deprecated: Use the GtkWidget::button-press-event signal.
*/
button_signals[PRESSED] =
- g_signal_new ("pressed",
+ g_signal_new (I_("pressed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkButtonClass, pressed),
* @Deprecated: Use the GtkWidget::button-release-event signal.
*/
button_signals[RELEASED] =
- g_signal_new ("released",
+ g_signal_new (I_("released"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkButtonClass, released),
* Emitted when the button has been activated (pressed and released).
*/
button_signals[CLICKED] =
- g_signal_new ("clicked",
+ g_signal_new (I_("clicked"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkButtonClass, clicked),
* @Deprecated: Use the GtkWidget::enter-notify-event signal.
*/
button_signals[ENTER] =
- g_signal_new ("enter",
+ g_signal_new (I_("enter"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkButtonClass, enter),
* @Deprecated: Use the GtkWidget::leave-notify-event signal.
*/
button_signals[LEAVE] =
- g_signal_new ("leave",
+ g_signal_new (I_("leave"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkButtonClass, leave),
* "clicked" signal.
*/
button_signals[ACTIVATE] =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkButtonClass, activate),
g_signal_connect (settings, "notify::gtk-button-images",
G_CALLBACK (gtk_button_setting_changed), 0);
g_object_set_data (G_OBJECT (settings),
- g_intern_static_string ("gtk-button-connection"),
+ I_("gtk-button-connection"),
GUINT_TO_POINTER (show_image_connection));
show_image_change_notify (GTK_BUTTON (widget));
GTK_PARAM_READWRITE));
gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
- g_signal_new ("month_changed",
+ g_signal_new (I_("month_changed"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, month_changed),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[DAY_SELECTED_SIGNAL] =
- g_signal_new ("day_selected",
+ g_signal_new (I_("day_selected"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, day_selected),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
- g_signal_new ("day_selected_double_click",
+ g_signal_new (I_("day_selected_double_click"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, day_selected_double_click),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[PREV_MONTH_SIGNAL] =
- g_signal_new ("prev_month",
+ g_signal_new (I_("prev_month"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, prev_month),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[NEXT_MONTH_SIGNAL] =
- g_signal_new ("next_month",
+ g_signal_new (I_("next_month"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, next_month),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[PREV_YEAR_SIGNAL] =
- g_signal_new ("prev_year",
+ g_signal_new (I_("prev_year"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, prev_year),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gtk_calendar_signals[NEXT_YEAR_SIGNAL] =
- g_signal_new ("next_year",
+ g_signal_new (I_("next_year"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarClass, next_year),
GdkDragAction suggested_action)
{
g_object_set_data (G_OBJECT (context),
- g_intern_static_string ("gtk-calendar-status-pending"),
+ I_("gtk-calendar-status-pending"),
GINT_TO_POINTER (suggested_action));
}
#include <config.h>
#include "gtkcelleditable.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_cell_editable_base_init (gpointer g_class);
};
cell_editable_type =
- g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkCellEditable"),
+ g_type_register_static (G_TYPE_INTERFACE, I_("GtkCellEditable"),
&cell_editable_info, 0);
g_type_interface_add_prerequisite (cell_editable_type, GTK_TYPE_WIDGET);
if (! initialized)
{
- g_signal_new ("editing_done",
+ g_signal_new (I_("editing_done"),
GTK_TYPE_CELL_EDITABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCellEditableIface, editing_done),
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_signal_new ("remove_widget",
+ g_signal_new (I_("remove_widget"),
GTK_TYPE_CELL_EDITABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCellEditableIface, remove_widget),
#include <config.h>
#include "gtkcelllayout.h"
+#include "gtkintl.h"
#include "gtkalias.h"
GType
};
cell_layout_type =
- g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkCellLayout"),
+ g_type_register_static (G_TYPE_INTERFACE, I_("GtkCellLayout"),
&cell_layout_info, 0);
g_type_interface_add_prerequisite (cell_layout_type, G_TYPE_OBJECT);
NULL, /* value_table */
};
- cell_type = g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkCellRenderer"),
+ cell_type = g_type_register_static (GTK_TYPE_OBJECT, I_("GtkCellRenderer"),
&cell_info, G_TYPE_FLAG_ABSTRACT);
}
* Since: 2.4
*/
cell_renderer_signals[EDITING_CANCELED] =
- g_signal_new ("editing-canceled",
+ g_signal_new (I_("editing-canceled"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled),
* Since: 2.6
*/
cell_renderer_signals[EDITING_STARTED] =
- g_signal_new ("editing-started",
+ g_signal_new (I_("editing-started"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCellRendererClass, editing_started),
g_object_set (combo, "has-frame", FALSE, NULL);
g_object_set_data_full (G_OBJECT (combo),
- g_intern_static_string (GTK_CELL_RENDERER_COMBO_PATH),
+ I_(GTK_CELL_RENDERER_COMBO_PATH),
g_strdup (path), g_free);
gtk_widget_show (combo);
};
cell_pixbuf_type =
- g_type_register_static (GTK_TYPE_CELL_RENDERER, g_intern_static_string ("GtkCellRendererPixbuf"),
+ g_type_register_static (GTK_TYPE_CELL_RENDERER, I_("GtkCellRendererPixbuf"),
&cell_pixbuf_info, 0);
}
};
cell_text_type =
- g_type_register_static (GTK_TYPE_CELL_RENDERER, g_intern_static_string ("GtkCellRendererText"),
+ g_type_register_static (GTK_TYPE_CELL_RENDERER, I_("GtkCellRendererText"),
&cell_text_info, 0);
}
P_("Whether this tag affects the ellipsize mode"));
text_cell_renderer_signals [EDITED] =
- g_signal_new ("edited",
+ g_signal_new (I_("edited"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCellRendererTextClass, edited),
if (celltext->text)
gtk_entry_set_text (GTK_ENTRY (priv->entry), celltext->text);
- g_object_set_data_full (G_OBJECT (priv->entry), g_intern_static_string (GTK_CELL_RENDERER_TEXT_PATH), g_strdup (path), g_free);
+ g_object_set_data_full (G_OBJECT (priv->entry), I_(GTK_CELL_RENDERER_TEXT_PATH), g_strdup (path), g_free);
gtk_editable_select_region (GTK_EDITABLE (priv->entry), 0, -1);
};
cell_toggle_type =
- g_type_register_static (GTK_TYPE_CELL_RENDERER, g_intern_static_string ("GtkCellRendererToggle"),
+ g_type_register_static (GTK_TYPE_CELL_RENDERER, I_("GtkCellRendererToggle"),
&cell_toggle_info, 0);
}
* The ::toggled signal is emitted when the cell is toggled.
**/
toggle_cell_signals[TOGGLED] =
- g_signal_new ("toggled",
+ g_signal_new (I_("toggled"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCellRendererToggleClass, toggled),
NULL
};
- cell_view_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkCellView"),
+ cell_view_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkCellView"),
&cell_view_info, 0);
g_type_add_interface_static (cell_view_type, GTK_TYPE_CELL_LAYOUT,
};
check_button_type =
- g_type_register_static (GTK_TYPE_TOGGLE_BUTTON, g_intern_static_string ("GtkCheckButton"),
+ g_type_register_static (GTK_TYPE_TOGGLE_BUTTON, I_("GtkCheckButton"),
&check_button_info, 0);
}
};
check_menu_item_type =
- g_type_register_static (GTK_TYPE_MENU_ITEM, g_intern_static_string ("GtkCheckMenuItem"),
+ g_type_register_static (GTK_TYPE_MENU_ITEM, I_("GtkCheckMenuItem"),
&check_menu_item_info, 0);
}
klass->draw_indicator = gtk_real_check_menu_item_draw_indicator;
check_menu_item_signals[TOGGLED] =
- g_signal_new ("toggled",
+ g_signal_new (I_("toggled"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCheckMenuItemClass, toggled),
#include "gtkinvisible.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#ifdef GDK_WINDOWING_X11
(GInstanceInitFunc) NULL,
};
- clipboard_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkClipboard"),
+ clipboard_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkClipboard"),
&clipboard_info, 0);
}
class->owner_change = gtk_clipboard_owner_change;
clipboard_signals[OWNER_CHANGE] =
- g_signal_new ("owner_change",
+ g_signal_new (I_("owner_change"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkClipboardClass, owner_change),
clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list");
clipboards = g_slist_remove (clipboards, clipboard);
- g_object_set_data (G_OBJECT (clipboard->display), g_intern_static_string ("gtk-clipboard-list"), clipboards);
+ g_object_set_data (G_OBJECT (clipboard->display), I_("gtk-clipboard-list"), clipboards);
if (g_main_loop_is_running (clipboard->store_loop))
{
clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
g_object_run_dispose (G_OBJECT (clipboard));
clipboards = g_slist_remove (clipboards, clipboard);
- g_object_set_data (G_OBJECT (display), g_intern_static_string ("gtk-clipboard-list"), clipboards);
+ g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards);
g_object_unref (clipboard);
}
if (!clip_widget)
{
clip_widget = make_clipboard_widget (display, TRUE);
- g_object_set_data (G_OBJECT (display), g_intern_static_string ("gtk-clipboard-widget"), clip_widget);
+ g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-widget"), clip_widget);
}
return clip_widget;
clipboard->n_cached_targets = -1;
clipboard->n_storable_targets = -1;
clipboards = g_slist_prepend (clipboards, clipboard);
- g_object_set_data (G_OBJECT (display), g_intern_static_string ("gtk-clipboard-list"), clipboards);
+ g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards);
g_signal_connect (display, "closed",
G_CALLBACK (clipboard_display_closed), clipboard);
gdk_display_request_selection_notification (display, selection);
#include "gtkbindings.h"
#include "gtkdnd.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include <gdk/gdkkeysyms.h>
#include "gtkalias.h"
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkCList");
+ I_("GtkCList");
clist_type = gtk_type_unique (GTK_TYPE_CONTAINER, &clist_info);
}
ARG_SORT_TYPE);
widget_class->set_scroll_adjustments_signal =
- gtk_signal_new ("set_scroll_adjustments",
+ gtk_signal_new (I_("set_scroll_adjustments"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, set_scroll_adjustments),
GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
clist_signals[SELECT_ROW] =
- gtk_signal_new ("select_row",
+ gtk_signal_new (I_("select_row"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, select_row),
GTK_TYPE_INT,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
clist_signals[UNSELECT_ROW] =
- gtk_signal_new ("unselect_row",
+ gtk_signal_new (I_("unselect_row"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, unselect_row),
GTK_TYPE_NONE, 3, GTK_TYPE_INT,
GTK_TYPE_INT, GDK_TYPE_EVENT);
clist_signals[ROW_MOVE] =
- gtk_signal_new ("row_move",
+ gtk_signal_new (I_("row_move"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, row_move),
_gtk_marshal_VOID__INT_INT,
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
clist_signals[CLICK_COLUMN] =
- gtk_signal_new ("click_column",
+ gtk_signal_new (I_("click_column"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, click_column),
_gtk_marshal_VOID__INT,
GTK_TYPE_NONE, 1, GTK_TYPE_INT);
clist_signals[RESIZE_COLUMN] =
- gtk_signal_new ("resize_column",
+ gtk_signal_new (I_("resize_column"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, resize_column),
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
clist_signals[TOGGLE_FOCUS_ROW] =
- gtk_signal_new ("toggle_focus_row",
+ gtk_signal_new (I_("toggle_focus_row"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, toggle_focus_row),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[SELECT_ALL] =
- gtk_signal_new ("select_all",
+ gtk_signal_new (I_("select_all"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, select_all),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[UNSELECT_ALL] =
- gtk_signal_new ("unselect_all",
+ gtk_signal_new (I_("unselect_all"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, unselect_all),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[UNDO_SELECTION] =
- gtk_signal_new ("undo_selection",
+ gtk_signal_new (I_("undo_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, undo_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[START_SELECTION] =
- gtk_signal_new ("start_selection",
+ gtk_signal_new (I_("start_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, start_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[END_SELECTION] =
- gtk_signal_new ("end_selection",
+ gtk_signal_new (I_("end_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, end_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[TOGGLE_ADD_MODE] =
- gtk_signal_new ("toggle_add_mode",
+ gtk_signal_new (I_("toggle_add_mode"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, toggle_add_mode),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
clist_signals[EXTEND_SELECTION] =
- gtk_signal_new ("extend_selection",
+ gtk_signal_new (I_("extend_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, extend_selection),
GTK_TYPE_NONE, 3,
GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT, GTK_TYPE_BOOL);
clist_signals[SCROLL_VERTICAL] =
- gtk_signal_new ("scroll_vertical",
+ gtk_signal_new (I_("scroll_vertical"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, scroll_vertical),
_gtk_marshal_VOID__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
clist_signals[SCROLL_HORIZONTAL] =
- gtk_signal_new ("scroll_horizontal",
+ gtk_signal_new (I_("scroll_horizontal"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, scroll_horizontal),
_gtk_marshal_VOID__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
clist_signals[ABORT_COLUMN_RESIZE] =
- gtk_signal_new ("abort_column_resize",
+ gtk_signal_new (I_("abort_column_resize"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCListClass, abort_column_resize),
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
- "scroll_vertical", 2,
+ "scroll_vertical", 2,
GTK_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
GTK_TYPE_FLOAT, 0.0);
gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
};
color_button_type =
- g_type_register_static (GTK_TYPE_BUTTON, g_intern_static_string ("GtkColorButton"),
+ g_type_register_static (GTK_TYPE_BUTTON, I_("GtkColorButton"),
&color_button_info, 0);
}
*
* Since: 2.4
*/
- color_button_signals[COLOR_SET] = g_signal_new ("color_set",
+ color_button_signals[COLOR_SET] = g_signal_new (I_("color_set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkColorButtonClass, color_set),
GdkDragContext *context,
gpointer data)
{
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("gtk-color-selection-drag-window"), NULL);
+ g_object_set_data (G_OBJECT (widget), I_("gtk-color-selection-drag-window"), NULL);
}
static void
GdkDragContext *context,
gpointer data)
{
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("gtk-color-selection-drag-window"), NULL);
+ g_object_set_data (G_OBJECT (widget), I_("gtk-color-selection-drag-window"), NULL);
}
static GdkColor *
G_CALLBACK (palette_drag_handle),
colorsel);
- g_object_set_data (G_OBJECT (drawing_area), g_intern_static_string ("color_set"),
+ g_object_set_data (G_OBJECT (drawing_area), I_("color_set"),
GINT_TO_POINTER (1));
}
new_color[2] = color[2];
new_color[3] = 1.0;
- g_object_set_data_full (G_OBJECT (drawing_area), g_intern_static_string ("color_val"), new_color, (GDestroyNotify)g_free);
+ g_object_set_data_full (G_OBJECT (drawing_area), I_("color_val"), new_color, (GDestroyNotify)g_free);
}
static gboolean
GtkWidget *mi;
g_object_set_data (G_OBJECT (drawing_area),
- g_intern_static_string ("gtk-color-sel"),
+ I_("gtk-color-sel"),
colorsel);
menu = gtk_menu_new ();
gpointer data)
{
g_object_set_data (G_OBJECT (drawing_area),
- g_intern_static_string ("gtk-colorsel-have-pointer"),
+ I_("gtk-colorsel-have-pointer"),
GUINT_TO_POINTER (TRUE));
return FALSE;
gpointer data)
{
g_object_set_data (G_OBJECT (drawing_area),
- g_intern_static_string ("gtk-colorsel-have-pointer"),
+ I_("gtk-colorsel-have-pointer"),
NULL);
return FALSE;
GTK_WIDGET_SET_FLAGS (retval, GTK_CAN_FOCUS);
- g_object_set_data (G_OBJECT (retval), g_intern_static_string ("color_set"), GINT_TO_POINTER (0));
+ g_object_set_data (G_OBJECT (retval), I_("color_set"), GINT_TO_POINTER (0));
gtk_widget_set_events (retval, GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_EXPOSURE_MASK
{
adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 1.0, 1.0));
}
- g_object_set_data (G_OBJECT (adjust), g_intern_static_string ("COLORSEL"), colorsel);
+ g_object_set_data (G_OBJECT (adjust), I_("COLORSEL"), colorsel);
*spinbutton = gtk_spin_button_new (adjust, 10.0, 0);
gtk_tooltips_set_tip (priv->tooltips, *spinbutton, tooltip, NULL);
};
color_selection_type =
- g_type_register_static (GTK_TYPE_VBOX, g_intern_static_string ("GtkColorSelection"),
+ g_type_register_static (GTK_TYPE_VBOX, I_("GtkColorSelection"),
&color_selection_info, 0);
}
GTK_PARAM_READWRITE));
color_selection_signals[COLOR_CHANGED] =
- g_signal_new ("color_changed",
+ g_signal_new (I_("color_changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkColorSelectionClass, color_changed),
button = gtk_button_new ();
gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
- g_object_set_data (G_OBJECT (button), g_intern_static_string ("COLORSEL"), colorsel);
+ g_object_set_data (G_OBJECT (button), I_("COLORSEL"), colorsel);
g_signal_connect (button, "clicked",
G_CALLBACK (get_screen_color), NULL);
picker_image = gtk_image_new_from_stock (GTK_STOCK_COLOR_PICKER, GTK_ICON_SIZE_BUTTON);
gtk_misc_set_alignment (GTK_MISC (priv->opacity_label), 1.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_label, 0, 1, 4, 5);
adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 255.0, 1.0, 1.0, 0.0));
- g_object_set_data (G_OBJECT (adjust), g_intern_static_string ("COLORSEL"), colorsel);
+ g_object_set_data (G_OBJECT (adjust), I_("COLORSEL"), colorsel);
priv->opacity_slider = gtk_hscale_new (adjust);
gtk_tooltips_set_tip (priv->tooltips,
priv->opacity_slider,
};
color_selection_dialog_type =
- g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkColorSelectionDialog"),
+ g_type_register_static (GTK_TYPE_DIALOG, I_("GtkColorSelectionDialog"),
&colorsel_diag_info, 0);
}
GtkWidget *label;
gchar *ltext = NULL;
- ltext = g_object_get_data (G_OBJECT (li), g_intern_static_string (gtk_combo_string_key));
+ ltext = g_object_get_data (G_OBJECT (li), I_(gtk_combo_string_key));
if (!ltext)
{
label = GTK_BIN (li)->child;
(GInstanceInitFunc) gtk_combo_init,
};
- combo_type = g_type_register_static (GTK_TYPE_HBOX, g_intern_static_string ("GtkCombo"),
+ combo_type = g_type_register_static (GTK_TYPE_HBOX, I_("GtkCombo"),
&combo_info, 0);
}
g_return_if_fail (GTK_IS_COMBO (combo));
g_return_if_fail (item != NULL);
- g_object_set_data_full (G_OBJECT (item), g_intern_static_string (gtk_combo_string_key),
+ g_object_set_data_full (G_OBJECT (item), I_(gtk_combo_string_key),
g_strdup (item_value), g_free);
}
};
combo_box_type = g_type_register_static (GTK_TYPE_BIN,
- g_intern_static_string ("GtkComboBox"),
+ I_("GtkComboBox"),
&combo_box_info,
0);
* Since: 2.4
*/
combo_box_signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkComboBoxClass, changed),
item = gtk_separator_menu_item_new ();
path = gtk_tree_model_get_path (model, &iter);
g_object_set_data_full (G_OBJECT (item),
- g_intern_static_string ("gtk-combo-box-item-path"),
+ I_("gtk-combo-box-item-path"),
gtk_tree_row_reference_new (model, path),
(GDestroyNotify)gtk_tree_row_reference_free);
gtk_tree_path_free (path);
{
item = gtk_separator_menu_item_new ();
g_object_set_data_full (G_OBJECT (item),
- g_intern_static_string ("gtk-combo-box-item-path"),
+ I_("gtk-combo-box-item-path"),
gtk_tree_row_reference_new (model, path),
(GDestroyNotify)gtk_tree_row_reference_free);
}
};
combo_box_entry_type = g_type_register_static (GTK_TYPE_COMBO_BOX,
- g_intern_static_string ("GtkComboBoxEntry"),
+ I_("GtkComboBoxEntry"),
&combo_box_entry_info,
0);
}
};
container_type =
- g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkContainer"),
+ g_type_register_static (GTK_TYPE_WIDGET, I_("GtkContainer"),
&container_info, G_TYPE_FLAG_ABSTRACT);
}
GTK_TYPE_WIDGET,
GTK_PARAM_WRITABLE));
container_signals[ADD] =
- g_signal_new ("add",
+ g_signal_new (I_("add"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, add),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
container_signals[REMOVE] =
- g_signal_new ("remove",
+ g_signal_new (I_("remove"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, remove),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
container_signals[CHECK_RESIZE] =
- g_signal_new ("check_resize",
+ g_signal_new (I_("check_resize"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkContainerClass, check_resize),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
container_signals[SET_FOCUS_CHILD] =
- g_signal_new ("set-focus-child",
+ g_signal_new (I_("set-focus-child"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkContainerClass, set_focus_child),
user_data);
g_object_set_data (G_OBJECT (container),
- g_intern_static_string ("gtk-container-focus-chain"),
+ I_("gtk-container-focus-chain"),
chain);
}
chain = g_list_reverse (chain);
g_object_set_data (G_OBJECT (container),
- g_intern_static_string ("gtk-container-focus-chain"),
+ I_("gtk-container-focus-chain"),
chain);
}
container->has_focus_chain = FALSE;
g_object_set_data (G_OBJECT (container),
- g_intern_static_string ("gtk-container-focus-chain"),
+ I_("gtk-container-focus-chain"),
NULL);
tmp_list = chain;
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkdnd.h"
+#include "gtkintl.h"
#include <gdk/gdkkeysyms.h>
#include "gtkalias.h"
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkCTree");
+ I_("GtkCTree");
ctree_type = gtk_type_unique (GTK_TYPE_CLIST, &ctree_info);
}
ARG_EXPANDER_STYLE);
ctree_signals[TREE_SELECT_ROW] =
- gtk_signal_new ("tree_select_row",
+ gtk_signal_new (I_("tree_select_row"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
GTK_TYPE_CTREE_NODE,
GTK_TYPE_INT);
ctree_signals[TREE_UNSELECT_ROW] =
- gtk_signal_new ("tree_unselect_row",
+ gtk_signal_new (I_("tree_unselect_row"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
GTK_TYPE_CTREE_NODE,
GTK_TYPE_INT);
ctree_signals[TREE_EXPAND] =
- gtk_signal_new ("tree_expand",
+ gtk_signal_new (I_("tree_expand"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
GTK_TYPE_NONE, 1,
GTK_TYPE_CTREE_NODE);
ctree_signals[TREE_COLLAPSE] =
- gtk_signal_new ("tree_collapse",
+ gtk_signal_new (I_("tree_collapse"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
GTK_TYPE_NONE, 1,
GTK_TYPE_CTREE_NODE);
ctree_signals[TREE_MOVE] =
- gtk_signal_new ("tree_move",
+ gtk_signal_new (I_("tree_move"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
GTK_TYPE_CTREE_NODE,
GTK_TYPE_CTREE_NODE);
ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
- gtk_signal_new ("change_focus_row_expansion",
+ gtk_signal_new (I_("change_focus_row_expansion"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkCTreeClass,
(GInstanceInitFunc) gtk_curve_init,
};
- curve_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, g_intern_static_string ("GtkCurve"),
+ curve_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, I_("GtkCurve"),
&curve_info, 0);
}
return curve_type;
GTK_PARAM_READWRITE));
curve_type_changed_signal =
- g_signal_new ("curve_type_changed",
+ g_signal_new (I_("curve_type_changed"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCurveClass, curve_type_changed),
(GInstanceInitFunc) gtk_dialog_init,
};
- dialog_type = g_type_register_static (GTK_TYPE_WINDOW, g_intern_static_string ("GtkDialog"),
+ dialog_type = g_type_register_static (GTK_TYPE_WINDOW, I_("GtkDialog"),
&dialog_info, 0);
}
GTK_PARAM_READWRITE));
dialog_signals[RESPONSE] =
- g_signal_new ("response",
+ g_signal_new (I_("response"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkDialogClass, response),
G_TYPE_INT);
dialog_signals[CLOSE] =
- g_signal_new ("close",
+ g_signal_new (I_("close"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkDialogClass, close),
ad = g_new (ResponseData, 1);
g_object_set_data_full (G_OBJECT (widget),
- g_intern_static_string ("gtk-dialog-response-data"),
+ I_("gtk-dialog-response-data"),
ad,
g_free);
}
#include "gtkplug.h"
#include "gtkstock.h"
#include "gtkwindow.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static GSList *source_widgets = NULL;
{
can_change_screen = can_change_screen != FALSE;
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("gtk-dnd-can-change-screen"),
+ g_object_set_data (G_OBJECT (widget), I_("gtk-dnd-can-change-screen"),
GUINT_TO_POINTER (can_change_screen));
}
result = drag_widgets->data;
drag_widgets = drag_widgets->next;
g_object_set_data (G_OBJECT (screen),
- g_intern_static_string ("gtk-dnd-ipc-widgets"),
+ I_("gtk-dnd-ipc-widgets"),
drag_widgets);
g_slist_free_1 (tmp);
}
"gtk-dnd-ipc-widgets");
drag_widgets = g_slist_prepend (drag_widgets, widget);
g_object_set_data (G_OBJECT (screen),
- g_intern_static_string ("gtk-dnd-ipc-widgets"),
+ I_("gtk-dnd-ipc-widgets"),
drag_widgets);
}
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (gtk_drag_selection_received), widget);
- g_object_set_data (G_OBJECT (selection_widget), g_intern_static_string ("drag-context"), context);
+ g_object_set_data (G_OBJECT (selection_widget), I_("drag-context"), context);
gtk_selection_convert (selection_widget,
gdk_drag_get_selection (context),
g_object_ref (context);
- g_object_set_data (G_OBJECT (selection_widget), g_intern_static_string ("drag-context"), context);
+ g_object_set_data (G_OBJECT (selection_widget), I_("drag-context"), context);
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (gtk_drag_selection_received),
NULL);
g_signal_connect (widget, "hierarchy_changed",
G_CALLBACK (gtk_drag_dest_hierarchy_changed), site);
- g_object_set_data_full (G_OBJECT (widget), g_intern_static_string ("gtk-drag-dest"),
+ g_object_set_data_full (G_OBJECT (widget), I_("gtk-drag-dest"),
site, gtk_drag_dest_site_destroy);
}
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("gtk-drag-dest"), NULL);
+ g_object_set_data (G_OBJECT (widget), I_("gtk-drag-dest"), NULL);
}
/**
gtk_drag_selection_received,
data);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("drag-context"), NULL);
+ g_object_set_data (G_OBJECT (widget), I_("drag-context"), NULL);
g_object_unref (context);
gtk_drag_release_ipc_widget (widget);
info = gtk_drag_get_source_info (context, TRUE);
info->ipc_widget = ipc_widget;
- g_object_set_data (G_OBJECT (info->ipc_widget), g_intern_static_string ("gtk-info"), info);
+ g_object_set_data (G_OBJECT (info->ipc_widget), I_("gtk-info"), info);
info->widget = gtk_widget_ref (widget);
site);
g_object_set_data_full (G_OBJECT (widget),
- g_intern_static_string ("gtk-site-data"),
+ I_("gtk-site-data"),
site, gtk_drag_source_site_destroy);
}
g_signal_handlers_disconnect_by_func (widget,
gtk_drag_source_event_cb,
site);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string ("gtk-site-data"), NULL);
+ g_object_set_data (G_OBJECT (widget), I_("gtk-site-data"), NULL);
}
}
info);
gtk_selection_remove_all (info->ipc_widget);
- g_object_set_data (G_OBJECT (info->ipc_widget), g_intern_static_string ("gtk-info"), NULL);
+ g_object_set_data (G_OBJECT (info->ipc_widget), I_("gtk-info"), NULL);
source_widgets = g_slist_remove (source_widgets, info->ipc_widget);
gtk_drag_release_ipc_widget (info->ipc_widget);
#include <config.h>
#include "gtkdrawingarea.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
drawing_area_type =
- g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkDrawingArea"),
+ g_type_register_static (GTK_TYPE_WIDGET, I_("GtkDrawingArea"),
&drawing_area_info, 0);
}
#include "gtkeditable.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
NULL, /* base_finalize */
};
- editable_type = g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkEditable"),
+ editable_type = g_type_register_static (G_TYPE_INTERFACE, I_("GtkEditable"),
&editable_info, 0);
}
if (! initialized)
{
- g_signal_new ("insert_text",
+ g_signal_new (I_("insert_text"),
GTK_TYPE_EDITABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEditableClass, insert_text),
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_POINTER);
- g_signal_new ("delete_text",
+ g_signal_new (I_("delete_text"),
GTK_TYPE_EDITABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEditableClass, delete_text),
G_TYPE_NONE, 2,
G_TYPE_INT,
G_TYPE_INT);
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
GTK_TYPE_EDITABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEditableClass, changed),
NULL /* interface_data */
};
- entry_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkEntry"),
+ entry_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkEntry"),
&entry_info, 0);
g_type_add_interface_static (entry_type,
GTK_PARAM_READWRITE));
signals[POPULATE_POPUP] =
- g_signal_new ("populate_popup",
+ g_signal_new (I_("populate_popup"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEntryClass, populate_popup),
/* Action signals */
signals[ACTIVATE] =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, activate),
widget_class->activate_signal = signals[ACTIVATE];
signals[MOVE_CURSOR] =
- g_signal_new ("move_cursor",
+ g_signal_new (I_("move_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, move_cursor),
G_TYPE_BOOLEAN);
signals[INSERT_AT_CURSOR] =
- g_signal_new ("insert_at_cursor",
+ g_signal_new (I_("insert_at_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, insert_at_cursor),
G_TYPE_STRING);
signals[DELETE_FROM_CURSOR] =
- g_signal_new ("delete_from_cursor",
+ g_signal_new (I_("delete_from_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, delete_from_cursor),
G_TYPE_INT);
signals[BACKSPACE] =
- g_signal_new ("backspace",
+ g_signal_new (I_("backspace"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, backspace),
G_TYPE_NONE, 0);
signals[CUT_CLIPBOARD] =
- g_signal_new ("cut_clipboard",
+ g_signal_new (I_("cut_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, cut_clipboard),
G_TYPE_NONE, 0);
signals[COPY_CLIPBOARD] =
- g_signal_new ("copy_clipboard",
+ g_signal_new (I_("copy_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, copy_clipboard),
G_TYPE_NONE, 0);
signals[PASTE_CLIPBOARD] =
- g_signal_new ("paste_clipboard",
+ g_signal_new (I_("paste_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, paste_clipboard),
G_TYPE_NONE, 0);
signals[TOGGLE_OVERWRITE] =
- g_signal_new ("toggle_overwrite",
+ g_signal_new (I_("toggle_overwrite"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkEntryClass, toggle_overwrite),
{
GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
- g_object_set_data (G_OBJECT (menuitem), g_intern_static_string ("gtk-signal"), (char *)signal);
+ g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_cb), entry);
if (!completion)
{
- g_object_set_data (G_OBJECT (entry), g_intern_static_string (GTK_ENTRY_COMPLETION_KEY), NULL);
+ g_object_set_data (G_OBJECT (entry), I_(GTK_ENTRY_COMPLETION_KEY), NULL);
return;
}
connect_completion_signals (entry, completion);
completion->priv->entry = GTK_WIDGET (entry);
- g_object_set_data (G_OBJECT (entry), g_intern_static_string (GTK_ENTRY_COMPLETION_KEY), completion);
+ g_object_set_data (G_OBJECT (entry), I_(GTK_ENTRY_COMPLETION_KEY), completion);
}
/**
};
entry_completion_type =
- g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkEntryCompletion"),
+ g_type_register_static (G_TYPE_OBJECT, I_("GtkEntryCompletion"),
&entry_completion_info, 0);
g_type_add_interface_static (entry_completion_type,
* Since: 2.6
*/
entry_completion_signals[INSERT_PREFIX] =
- g_signal_new ("insert_prefix",
+ g_signal_new (I_("insert_prefix"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEntryCompletionClass, insert_prefix),
* Since: 2.4
*/
entry_completion_signals[MATCH_SELECTED] =
- g_signal_new ("match_selected",
+ g_signal_new (I_("match_selected"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEntryCompletionClass, match_selected),
* Since: 2.4
*/
entry_completion_signals[ACTION_ACTIVATED] =
- g_signal_new ("action_activated",
+ g_signal_new (I_("action_activated"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkEntryCompletionClass, action_activated),
(GInstanceInitFunc) gtk_event_box_init,
};
- event_box_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkEventBox"),
+ event_box_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkEventBox"),
&event_box_info, 0);
}
};
expander_type = g_type_register_static (GTK_TYPE_BIN,
- g_intern_static_string ("GtkExpander"),
+ I_("GtkExpander"),
&expander_info, 0);
}
GTK_PARAM_READABLE));
widget_class->activate_signal =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkExpanderClass, activate),
};
file_chooser_type = g_type_register_static (G_TYPE_INTERFACE,
- g_intern_static_string ("GtkFileChooser"),
+ I_("GtkFileChooser"),
&file_chooser_info, 0);
g_type_interface_add_prerequisite (file_chooser_type, GTK_TYPE_WIDGET);
* gtk_file_chooser_set_current_folder_uri(),
* gtk_file_chooser_get_current_folder_uri().
*/
- g_signal_new ("current-folder-changed",
+ g_signal_new (I_("current-folder-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserIface, current_folder_changed),
* gtk_file_chooser_unselect_uri(), gtk_file_chooser_get_uri(),
* gtk_file_chooser_get_uris().
*/
- g_signal_new ("selection-changed",
+ g_signal_new (I_("selection-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserIface, selection_changed),
* gtk_file_chooser_get_preview_filename(),
* gtk_file_chooser_get_preview_uri().
*/
- g_signal_new ("update-preview",
+ g_signal_new (I_("update-preview"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserIface, update_preview),
* gtk_file_chooser_get_filenames(), gtk_file_chooser_get_uri(),
* gtk_file_chooser_get_uris().
*/
- g_signal_new ("file-activated",
+ g_signal_new (I_("file-activated"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserIface, file_activated),
G_TYPE_NONE, 0);
/* Documented in the docbook files */
- g_signal_new ("confirm-overwrite",
+ g_signal_new (I_("confirm-overwrite"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserIface, confirm_overwrite),
NULL /* interface_data */
};
- file_chooser_default_type = g_type_register_static (GTK_TYPE_VBOX, g_intern_static_string ("GtkFileChooserDefault"),
+ file_chooser_default_type = g_type_register_static (GTK_TYPE_VBOX, I_("GtkFileChooserDefault"),
&file_chooser_default_info, 0);
g_type_add_interface_static (file_chooser_default_type,
widget_class->screen_changed = gtk_file_chooser_default_screen_changed;
signals[LOCATION_POPUP] =
- _gtk_binding_signal_new ("location-popup",
+ _gtk_binding_signal_new (I_("location-popup"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_CALLBACK (location_popup_handler),
_gtk_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
signals[UP_FOLDER] =
- _gtk_binding_signal_new ("up-folder",
+ _gtk_binding_signal_new (I_("up-folder"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_CALLBACK (up_folder_handler),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[DOWN_FOLDER] =
- _gtk_binding_signal_new ("down-folder",
+ _gtk_binding_signal_new (I_("down-folder"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_CALLBACK (down_folder_handler),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[HOME_FOLDER] =
- _gtk_binding_signal_new ("home-folder",
+ _gtk_binding_signal_new (I_("home-folder"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_CALLBACK (home_folder_handler),
/* Tree/list view */
impl->browse_files_tree_view = gtk_tree_view_new ();
- g_object_set_data (G_OBJECT (impl->browse_files_tree_view), g_intern_static_string ("GtkFileChooserDefault"), impl);
+ g_object_set_data (G_OBJECT (impl->browse_files_tree_view), I_("GtkFileChooserDefault"), impl);
atk_object_set_name (gtk_widget_get_accessible (impl->browse_files_tree_view), _("Files"));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (impl->browse_files_tree_view), TRUE);
#include "gtkfilechooserembed.h"
#include "gtkfilesystem.h"
#include "gtktypebuiltins.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include <stdarg.h>
NULL /* interface_data */
};
- file_chooser_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkFileChooserDialog"),
+ file_chooser_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, I_("GtkFileChooserDialog"),
&file_chooser_dialog_info, 0);
g_type_add_interface_static (file_chooser_dialog_type,
GTK_TYPE_FILE_CHOOSER,
#include <config.h>
#include "gtkfilechooserembed.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_file_chooser_embed_class_init (gpointer g_iface);
g_return_if_fail (GTK_IS_FILE_CHOOSER_EMBED (receiver));
g_return_if_fail (GTK_IS_FILE_CHOOSER_EMBED (delegate));
- g_object_set_data (G_OBJECT (receiver), g_intern_static_string ("gtk-file-chooser-embed-delegate"), delegate);
+ g_object_set_data (G_OBJECT (receiver), I_("gtk-file-chooser-embed-delegate"), delegate);
g_signal_connect (delegate, "default_size_changed",
G_CALLBACK (delegate_default_size_changed), receiver);
};
file_chooser_embed_type = g_type_register_static (G_TYPE_INTERFACE,
- g_intern_static_string ("GtkFileChooserEmbed"),
+ I_("GtkFileChooserEmbed"),
&file_chooser_embed_info, 0);
g_type_interface_add_prerequisite (file_chooser_embed_type, GTK_TYPE_WIDGET);
{
GType iface_type = G_TYPE_FROM_INTERFACE (g_iface);
- g_signal_new ("default-size-changed",
+ g_signal_new (I_("default-size-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileChooserEmbedIface, default_size_changed),
#include "gtkentry.h"
#include "gtkfilechooserentry.h"
#include "gtkmain.h"
+#include "gtkintl.h"
#include "gtkalias.h"
typedef struct _GtkFileChooserEntryClass GtkFileChooserEntryClass;
};
- file_chooser_entry_type = g_type_register_static (GTK_TYPE_ENTRY, g_intern_static_string ("GtkFileChooserEntry"),
+ file_chooser_entry_type = g_type_register_static (GTK_TYPE_ENTRY, I_("GtkFileChooserEntry"),
&file_chooser_entry_info, 0);
g_type_add_interface_static (file_chooser_entry_type,
GTK_TYPE_EDITABLE,
#include "gtkfilechooser.h"
#include "gtkfilesystem.h"
#include "gtktypebuiltins.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static gboolean delegate_set_current_folder (GtkFileChooser *chooser,
g_return_if_fail (GTK_IS_FILE_CHOOSER (receiver));
g_return_if_fail (GTK_IS_FILE_CHOOSER (delegate));
- g_object_set_data (G_OBJECT (receiver), g_intern_static_string ("gtk-file-chooser-delegate"), delegate);
+ g_object_set_data (G_OBJECT (receiver), I_("gtk-file-chooser-delegate"), delegate);
g_signal_connect (delegate, "notify",
G_CALLBACK (delegate_notify), receiver);
g_signal_connect (delegate, "current-folder-changed",
#include "gtkfilechooserutils.h"
#include "gtktypebuiltins.h"
#include "gtkfilechooserembed.h"
+#include "gtkintl.h"
#include "gtkalias.h"
struct _GtkFileChooserWidgetPrivate
NULL /* interface_data */
};
- file_chooser_widget_type = g_type_register_static (GTK_TYPE_VBOX, g_intern_static_string ("GtkFileChooserWidget"),
+ file_chooser_widget_type = g_type_register_static (GTK_TYPE_VBOX, I_("GtkFileChooserWidget"),
&file_chooser_widget_info, 0);
g_type_add_interface_static (file_chooser_widget_type,
#include "gtkfilefilter.h"
#include "gtkobject.h"
+#include "gtkintl.h"
#include "gtkprivate.h"
#include "gtkalias.h"
NULL /* init */
};
- file_filter_type = g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkFileFilter"),
+ file_filter_type = g_type_register_static (GTK_TYPE_OBJECT, I_("GtkFileFilter"),
&file_filter_info, 0);
}
};
file_selection_type =
- g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkFileSelection"),
+ g_type_register_static (GTK_TYPE_DIALOG, I_("GtkFileSelection"),
&filesel_info, 0);
}
"Are you sure that you want to select it?"), filename_utf8, hostname);
g_free (filename_utf8);
- g_object_set_data_full (G_OBJECT (dialog), g_intern_static_string ("gtk-fs-dnd-filename"), g_strdup (filename), g_free);
+ g_object_set_data_full (G_OBJECT (dialog), I_("gtk-fs-dnd-filename"), g_strdup (filename), g_free);
g_signal_connect_data (dialog, "response",
(GCallback) dnd_really_drop,
#include "gtkfilesystem.h"
#include "gtkicontheme.h"
#include "gtkmodules.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include <string.h>
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkFileInfo"),
+ our_type = g_boxed_type_register_static (I_("GtkFileInfo"),
(GBoxedCopyFunc) gtk_file_info_copy,
(GBoxedFreeFunc) gtk_file_info_free);
};
file_system_type = g_type_register_static (G_TYPE_INTERFACE,
- g_intern_static_string ("GtkFileSystem"),
+ I_("GtkFileSystem"),
&file_system_info, 0);
g_type_interface_add_prerequisite (file_system_type, G_TYPE_OBJECT);
{
GType iface_type = G_TYPE_FROM_INTERFACE (g_class);
- g_signal_new ("volumes-changed",
+ g_signal_new (I_("volumes-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileSystemIface, volumes_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_signal_new ("bookmarks-changed",
+ g_signal_new (I_("bookmarks-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileSystemIface, bookmarks_changed),
};
file_folder_type = g_type_register_static (G_TYPE_INTERFACE,
- g_intern_static_string ("GtkFileFolder"),
+ I_("GtkFileFolder"),
&file_folder_info, 0);
g_type_interface_add_prerequisite (file_folder_type, G_TYPE_OBJECT);
{
GType iface_type = G_TYPE_FROM_INTERFACE (g_class);
- g_signal_new ("deleted",
+ g_signal_new (I_("deleted"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileFolderIface, deleted),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
- g_signal_new ("files-added",
+ g_signal_new (I_("files-added"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileFolderIface, files_added),
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
- g_signal_new ("files-changed",
+ g_signal_new (I_("files-changed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileFolderIface, files_changed),
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
- g_signal_new ("files-removed",
+ g_signal_new (I_("files-removed"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileFolderIface, files_removed),
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
- g_signal_new ("finished-loading",
+ g_signal_new (I_("finished-loading"),
iface_type,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileFolderIface, finished_loading),
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkFilePath"),
+ our_type = g_boxed_type_register_static (I_("GtkFilePath"),
(GBoxedCopyFunc) gtk_file_path_real_copy,
(GBoxedFreeFunc) gtk_file_path_real_free);
};
file_system_model_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkFileSystemModel"),
+ I_("GtkFileSystemModel"),
&file_system_model_info, 0);
g_type_add_interface_static (file_system_model_type,
GTK_TYPE_TREE_MODEL,
gobject_class->finalize = gtk_file_system_model_finalize;
file_system_model_signals[FINISHED_LOADING] =
- g_signal_new ("finished-loading",
+ g_signal_new (I_("finished-loading"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkFileSystemModelClass, finished_loading),
g_signal_connect (node->folder, "files-removed",
G_CALLBACK (files_removed_callback), node);
- g_object_set_data (G_OBJECT (node->folder), g_intern_static_string ("model-node"), node);
+ g_object_set_data (G_OBJECT (node->folder), I_("model-node"), node);
}
if (is_folder && !has_children)
};
file_system_unix_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkFileSystemUnix"),
+ I_("GtkFileSystemUnix"),
&file_system_unix_info, 0);
g_type_add_interface_static (file_system_unix_type,
GTK_TYPE_FILE_SYSTEM,
cache = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)icon_cache_element_free);
- g_object_set_data_full (G_OBJECT (icon_theme), g_intern_static_string ("gtk-file-icon-cache"),
+ g_object_set_data_full (G_OBJECT (icon_theme), I_("gtk-file-icon-cache"),
cache, (GDestroyNotify)g_hash_table_destroy);
}
(GDestroyNotify)g_free,
(GDestroyNotify)icon_cache_element_free);
- g_object_set_data_full (G_OBJECT (icon_theme), g_intern_static_string ("gtk-file-icon-cache"),
+ g_object_set_data_full (G_OBJECT (icon_theme), I_("gtk-file-icon-cache"),
cache, (GDestroyNotify)g_hash_table_destroy);
g_signal_connect (icon_theme, "changed",
G_CALLBACK (icon_theme_changed), NULL);
};
file_folder_unix_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkFileFolderUnix"),
+ I_("GtkFileFolderUnix"),
&file_folder_unix_info, 0);
g_type_add_interface_static (file_folder_unix_type,
GTK_TYPE_FILE_FOLDER,
};
file_system_win32_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkFileSystemWin32"),
+ I_("GtkFileSystemWin32"),
&file_system_win32_info, 0);
g_type_add_interface_static (file_system_win32_type,
GTK_TYPE_FILE_SYSTEM,
};
file_folder_win32_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkFileFolderWin32"),
+ I_("GtkFileFolderWin32"),
&file_folder_win32_info, 0);
g_type_add_interface_static (file_folder_win32_type,
GTK_TYPE_FILE_FOLDER,
(GInstanceInitFunc) gtk_fixed_init,
};
- fixed_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkFixed"),
+ fixed_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkFixed"),
&fixed_info, 0);
}
};
font_button_type =
- g_type_register_static (GTK_TYPE_BUTTON, g_intern_static_string ("GtkFontButton"),
+ g_type_register_static (GTK_TYPE_BUTTON, I_("GtkFontButton"),
&font_button_info, 0);
}
*
* Since: 2.4
*/
- font_button_signals[FONT_SET] = g_signal_new ("font-set",
+ font_button_signals[FONT_SET] = g_signal_new (I_("font-set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkFontButtonClass, font_set),
};
font_selection_type =
- g_type_register_static (GTK_TYPE_VBOX, g_intern_static_string ("GtkFontSelection"),
+ g_type_register_static (GTK_TYPE_VBOX, I_("GtkFontSelection"),
&fontsel_type_info, 0);
}
};
font_selection_dialog_type =
- g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkFontSelectionDialog"),
+ g_type_register_static (GTK_TYPE_DIALOG, I_("GtkFontSelectionDialog"),
&fontsel_diag_info, 0);
}
(GInstanceInitFunc) gtk_frame_init,
};
- frame_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkFrame"),
+ frame_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkFrame"),
&frame_info, 0);
}
(GInstanceInitFunc) gtk_gamma_curve_init,
};
- gamma_curve_type = g_type_register_static (GTK_TYPE_VBOX, g_intern_static_string ("GtkGammaCurve"),
+ gamma_curve_type = g_type_register_static (GTK_TYPE_VBOX, I_("GtkGammaCurve"),
&gamma_curve_info, 0);
}
return gamma_curve_type;
for (i = 0; i < 3; ++i)
{
curve->button[i] = gtk_toggle_button_new ();
- g_object_set_data (G_OBJECT (curve->button[i]), g_intern_static_string ("_GtkGammaCurveIndex"),
+ g_object_set_data (G_OBJECT (curve->button[i]), I_("_GtkGammaCurveIndex"),
GINT_TO_POINTER (i));
gtk_container_add (GTK_CONTAINER (vbox), curve->button[i]);
g_signal_connect (curve->button[i], "realize",
for (i = 3; i < 5; ++i)
{
curve->button[i] = gtk_button_new ();
- g_object_set_data (G_OBJECT (curve->button[i]), g_intern_static_string ("_GtkGammaCurveIndex"),
+ g_object_set_data (G_OBJECT (curve->button[i]), I_("_GtkGammaCurveIndex"),
GINT_TO_POINTER (i));
gtk_container_add (GTK_CONTAINER (vbox), curve->button[i]);
g_signal_connect (curve->button[i], "realize",
#include <config.h>
#include "gtkgc.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GEqualFunc) gtk_gc_drawable_equal,
NULL, free_gc_drawable);
g_object_set_data_full (G_OBJECT (screen),
- g_intern_static_string ("gtk-gc-drawable-ht"), ht,
+ I_("gtk-gc-drawable-ht"), ht,
(GDestroyNotify)g_hash_table_destroy);
}
(GInstanceInitFunc) gtk_handle_box_init,
};
- handle_box_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkHandleBox"),
+ handle_box_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkHandleBox"),
&handle_box_info, 0);
}
class->child_detached = NULL;
handle_box_signals[SIGNAL_CHILD_ATTACHED] =
- g_signal_new ("child_attached",
+ g_signal_new (I_("child_attached"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkHandleBoxClass, child_attached),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
handle_box_signals[SIGNAL_CHILD_DETACHED] =
- g_signal_new ("child_detached",
+ g_signal_new (I_("child_detached"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkHandleBoxClass, child_detached),
#include <config.h>
#include "gtkhbbox.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
hbutton_box_type =
- g_type_register_static (GTK_TYPE_BUTTON_BOX, g_intern_static_string ("GtkHButtonBox"),
+ g_type_register_static (GTK_TYPE_BUTTON_BOX, I_("GtkHButtonBox"),
&hbutton_box_info, 0);
}
#include <config.h>
#include "gtkhbox.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GInstanceInitFunc) gtk_hbox_init,
};
- hbox_type = g_type_register_static (GTK_TYPE_BOX, g_intern_static_string ("GtkHBox"),
+ hbox_type = g_type_register_static (GTK_TYPE_BOX, I_("GtkHBox"),
&hbox_info, 0);
}
#include <config.h>
#include "gtkhpaned.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_hpaned_class_init (GtkHPanedClass *klass);
(GInstanceInitFunc) gtk_hpaned_init,
};
- hpaned_type = g_type_register_static (GTK_TYPE_PANED, g_intern_static_string ("GtkHPaned"),
+ hpaned_type = g_type_register_static (GTK_TYPE_PANED, I_("GtkHPaned"),
&hpaned_info, 0);
}
#include <glib/gprintf.h>
#include <string.h>
#include "gtkhruler.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GInstanceInitFunc) gtk_hruler_init,
};
- hruler_type = g_type_register_static (GTK_TYPE_RULER, g_intern_static_string ("GtkHRuler"),
+ hruler_type = g_type_register_static (GTK_TYPE_RULER, I_("GtkHRuler"),
&hruler_info, 0);
}
(GInstanceInitFunc) gtk_hscale_init,
};
- hscale_type = g_type_register_static (GTK_TYPE_SCALE, g_intern_static_string ("GtkHScale"),
+ hscale_type = g_type_register_static (GTK_TYPE_SCALE, I_("GtkHScale"),
&hscale_info, 0);
}
};
hscrollbar_type =
- g_type_register_static (GTK_TYPE_SCROLLBAR, g_intern_static_string ("GtkHScrollbar"),
+ g_type_register_static (GTK_TYPE_SCROLLBAR, I_("GtkHScrollbar"),
&hscrollbar_info, 0);
}
#include <config.h>
#include "gtkhseparator.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
hseparator_type =
- g_type_register_static (GTK_TYPE_SEPARATOR, g_intern_static_string ("GtkHSeparator"),
+ g_type_register_static (GTK_TYPE_SEPARATOR, I_("GtkHSeparator"),
&hseparator_info, 0);
}
#include "gtkbindings.h"
#include "gtkcontainer.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
/*
(GInstanceInitFunc) gtk_hsv_init,
};
- hsv_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkHSV"),
+ hsv_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkHSV"),
&hsv_info, 0);
}
hsv_class->move = gtk_hsv_move;
hsv_signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkHSVClass, changed),
G_TYPE_NONE, 0);
hsv_signals[MOVE] =
- g_signal_new ("move",
+ g_signal_new (I_("move"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkHSVClass, move),
};
icon_factory_type =
- g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkIconFactory"),
+ g_type_register_static (G_TYPE_OBJECT, I_("GtkIconFactory"),
&icon_factory_info, 0);
}
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkIconSet"),
+ our_type = g_boxed_type_register_static (I_("GtkIconSet"),
(GBoxedCopyFunc) gtk_icon_set_ref,
(GBoxedFreeFunc) gtk_icon_set_unref);
(GInstanceInitFunc) gtk_icon_theme_init,
};
- type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkIconTheme"), &info, 0);
+ type = g_type_register_static (G_TYPE_OBJECT, I_("GtkIconTheme"), &info, 0);
}
return type;
priv = icon_theme->priv;
priv->is_screen_singleton = TRUE;
- g_object_set_data (G_OBJECT (screen), g_intern_static_string ("gtk-icon-theme"), icon_theme);
+ g_object_set_data (G_OBJECT (screen), I_("gtk-icon-theme"), icon_theme);
}
return icon_theme;
* that a change has occurred in the contents of the current
* icon theme.
**/
- signal_changed = g_signal_new ("changed",
+ signal_changed = g_signal_new (I_("changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIconThemeClass, changed),
if (was_screen_singleton)
{
- g_object_set_data (G_OBJECT (screen), g_intern_static_string ("gtk-icon-theme"), NULL);
+ g_object_set_data (G_OBJECT (screen), I_("gtk-icon-theme"), NULL);
priv->is_screen_singleton = FALSE;
}
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkIconInfo"),
+ our_type = g_boxed_type_register_static (I_("GtkIconInfo"),
(GBoxedCopyFunc) gtk_icon_info_copy,
(GBoxedFreeFunc) gtk_icon_info_free);
/* Signals */
widget_class->set_scroll_adjustments_signal =
- g_signal_new ("set_scroll_adjustments",
+ g_signal_new (I_("set_scroll_adjustments"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIconViewClass, set_scroll_adjustments),
GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
icon_view_signals[ITEM_ACTIVATED] =
- g_signal_new ("item_activated",
+ g_signal_new (I_("item_activated"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIconViewClass, item_activated),
GTK_TYPE_TREE_PATH);
icon_view_signals[SELECTION_CHANGED] =
- g_signal_new ("selection_changed",
+ g_signal_new (I_("selection_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkIconViewClass, selection_changed),
G_TYPE_NONE, 0);
icon_view_signals[SELECT_ALL] =
- g_signal_new ("select_all",
+ g_signal_new (I_("select_all"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, select_all),
G_TYPE_NONE, 0);
icon_view_signals[UNSELECT_ALL] =
- g_signal_new ("unselect_all",
+ g_signal_new (I_("unselect_all"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, unselect_all),
G_TYPE_NONE, 0);
icon_view_signals[SELECT_CURSOR_ITEM] =
- g_signal_new ("select_cursor_item",
+ g_signal_new (I_("select_cursor_item"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, select_cursor_item),
G_TYPE_NONE, 0);
icon_view_signals[TOGGLE_CURSOR_ITEM] =
- g_signal_new ("toggle_cursor_item",
+ g_signal_new (I_("toggle_cursor_item"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, toggle_cursor_item),
G_TYPE_NONE, 0);
icon_view_signals[ACTIVATE_CURSOR_ITEM] =
- g_signal_new ("activate_cursor_item",
+ g_signal_new (I_("activate_cursor_item"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, activate_cursor_item),
G_TYPE_BOOLEAN, 0);
icon_view_signals[MOVE_CURSOR] =
- g_signal_new ("move_cursor",
+ g_signal_new (I_("move_cursor"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIconViewClass, move_cursor),
G_TYPE_INT);
/* Key bindings */
- gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, "select_all", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect_all", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK, "toggle_cursor_item", 0);
-
- gtk_binding_entry_add_signal (binding_set, GDK_space, 0, "activate_cursor_item", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "activate_cursor_item", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0, "activate_cursor_item", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "activate_cursor_item", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK,
+ "select_all", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
+ "unselect_all", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
+ "toggle_cursor_item", 0);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_space, 0,
+ "activate_cursor_item", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_Return, 0,
+ "activate_cursor_item", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0,
+ "activate_cursor_item", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0,
+ "activate_cursor_item", 0);
gtk_icon_view_add_move_binding (binding_set, GDK_Up, 0,
GTK_MOVEMENT_DISPLAY_LINES, -1);
{
gtk_binding_entry_add_signal (binding_set, keyval, modmask,
- "move_cursor", 2,
+ I_("move_cursor"), 2,
G_TYPE_ENUM, step,
G_TYPE_INT, count);
GdkDragAction suggested_action)
{
g_object_set_data (G_OBJECT (context),
- g_intern_static_string ("gtk-icon-view-status-pending"),
+ I_("gtk-icon-view-status-pending"),
GINT_TO_POINTER (suggested_action));
}
{
if (source_row)
g_object_set_data_full (G_OBJECT (context),
- g_intern_static_string ("gtk-icon-view-source-row"),
+ I_("gtk-icon-view-source-row"),
gtk_tree_row_reference_new (model, source_row),
(GDestroyNotify) gtk_tree_row_reference_free);
else
g_object_set_data_full (G_OBJECT (context),
- g_intern_static_string ("gtk-icon-view-source-row"),
+ I_("gtk-icon-view-source-row"),
NULL, NULL);
}
if (!dest_row)
{
g_object_set_data_full (G_OBJECT (context),
- g_intern_static_string ("gtk-icon-view-dest-row"),
+ I_("gtk-icon-view-dest-row"),
NULL, NULL);
return;
}
dr->empty_view_drop = empty_view_drop;
dr->drop_append_mode = drop_append_mode;
g_object_set_data_full (G_OBJECT (context),
- g_intern_static_string ("gtk-icon-view-dest-row"),
+ I_("gtk-icon-view-dest-row"),
dr, (GDestroyNotify) dest_row_free);
}
};
type = g_type_register_static (ATK_TYPE_OBJECT,
- g_intern_static_string ("GtkIconViewItemAccessible"), &tinfo, 0);
+ I_("GtkIconViewItemAccessible"), &tinfo, 0);
g_type_add_interface_static (type, ATK_TYPE_COMPONENT,
&atk_component_info);
g_type_add_interface_static (type, ATK_TYPE_ACTION,
(GInstanceInitFunc) gtk_image_init,
};
- image_type = g_type_register_static (GTK_TYPE_MISC, g_intern_static_string ("GtkImage"),
+ image_type = g_type_register_static (GTK_TYPE_MISC, I_("GtkImage"),
&image_info, 0);
}
};
image_menu_item_type =
- g_type_register_static (GTK_TYPE_MENU_ITEM, g_intern_static_string ("GtkImageMenuItem"),
+ g_type_register_static (GTK_TYPE_MENU_ITEM, I_("GtkImageMenuItem"),
&image_menu_item_info, 0);
}
g_signal_connect (settings, "notify::gtk-menu-images",
G_CALLBACK (gtk_image_menu_item_setting_changed), 0);
g_object_set_data (G_OBJECT (settings),
- g_intern_static_string ("gtk-image-menu-item-connection"),
+ I_("gtk-image-menu-item-connection"),
GUINT_TO_POINTER (show_image_connection));
show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget));
#include "gtkimcontext.h"
#include "gtkmain.h" /* For _gtk_boolean_handled_accumulator */
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
enum {
};
im_context_type =
- g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkIMContext"),
+ g_type_register_static (G_TYPE_OBJECT, I_("GtkIMContext"),
&im_context_info, G_TYPE_FLAG_ABSTRACT);
}
klass->set_surrounding = gtk_im_context_real_set_surrounding;
im_context_signals[PREEDIT_START] =
- g_signal_new ("preedit_start",
+ g_signal_new (I_("preedit_start"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, preedit_start),
G_TYPE_NONE, 0);
im_context_signals[PREEDIT_END] =
- g_signal_new ("preedit_end",
+ g_signal_new (I_("preedit_end"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, preedit_end),
G_TYPE_NONE, 0);
im_context_signals[PREEDIT_CHANGED] =
- g_signal_new ("preedit_changed",
+ g_signal_new (I_("preedit_changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, preedit_changed),
G_TYPE_NONE, 0);
im_context_signals[COMMIT] =
- g_signal_new ("commit",
+ g_signal_new (I_("commit"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, commit),
G_TYPE_STRING);
im_context_signals[RETRIEVE_SURROUNDING] =
- g_signal_new ("retrieve_surrounding",
+ g_signal_new (I_("retrieve_surrounding"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, retrieve_surrounding),
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
im_context_signals[DELETE_SURROUNDING] =
- g_signal_new ("delete_surrounding",
+ g_signal_new (I_("delete_surrounding"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkIMContextClass, delete_surrounding),
if (!info)
{
info = &local_info;
- g_object_set_data (G_OBJECT (context), g_intern_static_string ("gtk-im-surrounding-info"), info);
+ g_object_set_data (G_OBJECT (context), I_("gtk-im-surrounding-info"), info);
info_is_local = TRUE;
}
if (info_is_local)
{
g_free (info->text);
- g_object_set_data (G_OBJECT (context), g_intern_static_string ("gtk-im-surrounding-info"), NULL);
+ g_object_set_data (G_OBJECT (context), I_("gtk-im-surrounding-info"), NULL);
}
return result;
#include <gdk/gdkkeysyms.h>
#include "gtkaccelgroup.h"
#include "gtkimcontextsimple.h"
+#include "gtkintl.h"
#include "gtkalias.h"
typedef struct _GtkComposeTable GtkComposeTable;
};
im_context_simple_type =
- g_type_register_static (GTK_TYPE_IM_CONTEXT, g_intern_static_string ("GtkIMContextSimple"),
+ g_type_register_static (GTK_TYPE_IM_CONTEXT, I_("GtkIMContextSimple"),
&im_context_simple_info, 0);
}
};
im_module_type =
- g_type_register_static (G_TYPE_TYPE_MODULE, g_intern_static_string ("GtkIMModule"),
+ g_type_register_static (G_TYPE_TYPE_MODULE, I_("GtkIMModule"),
&im_module_info, 0);
}
};
im_multicontext_type =
- g_type_register_static (GTK_TYPE_IM_CONTEXT, g_intern_static_string ("GtkIMMulticontext"),
+ g_type_register_static (GTK_TYPE_IM_CONTEXT, I_("GtkIMMulticontext"),
&im_multicontext_info, 0);
}
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
- g_object_set_data (G_OBJECT (menuitem), g_intern_static_string ("gtk-context-id"),
+ g_object_set_data (G_OBJECT (menuitem), I_("gtk-context-id"),
(char *)contexts[i]->context_id);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_cb), context);
};
input_dialog_type =
- g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkInputDialog"),
+ g_type_register_static (GTK_TYPE_DIALOG, I_("GtkInputDialog"),
&input_dialog_info, 0);
}
klass->disable_device = NULL;
input_dialog_signals[ENABLE_DEVICE] =
- g_signal_new ("enable_device",
+ g_signal_new (I_("enable_device"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkInputDialogClass, enable_device),
GDK_TYPE_DEVICE);
input_dialog_signals[DISABLE_DEVICE] =
- g_signal_new ("disable_device",
+ g_signal_new (I_("disable_device"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkInputDialogClass, disable_device),
#define P_(String) (String)
#endif
+/* not really I18N-related, but also a string marker macro */
+#define I_(string) g_intern_static_string (string)
+
#endif
(GInstanceInitFunc) gtk_invisible_init,
};
- invisible_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkInvisible"),
+ invisible_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkInvisible"),
&invisible_info, 0);
}
#include <config.h>
#include "gtkitem.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
NULL, /* value_table */
};
- item_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkItem"),
+ item_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkItem"),
&item_info, G_TYPE_FLAG_ABSTRACT);
}
class->toggle = NULL;
item_signals[SELECT] =
- g_signal_new ("select",
+ g_signal_new (I_("select"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkItemClass, select),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
item_signals[DESELECT] =
- g_signal_new ("deselect",
+ g_signal_new (I_("deselect"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkItemClass, deselect),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
item_signals[TOGGLE] =
- g_signal_new ("toggle",
+ g_signal_new (I_("toggle"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkItemClass, toggle),
#include "gtk/gtkimage.h"
#include "gtk/gtkstock.h"
#include "gtk/gtkiconfactory.h"
+#include "gtkintl.h"
#include <string.h>
#include <fcntl.h>
#ifdef HAVE_UNISTD_H
};
item_factory_type =
- g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkItemFactory"),
+ g_type_register_static (GTK_TYPE_OBJECT, I_("GtkItemFactory"),
&item_factory_info, 0);
}
(GInstanceInitFunc) gtk_label_init,
};
- label_type = g_type_register_static (GTK_TYPE_MISC, g_intern_static_string ("GtkLabel"),
+ label_type = g_type_register_static (GTK_TYPE_MISC, I_("GtkLabel"),
&label_info, 0);
}
class->copy_clipboard = gtk_label_copy_clipboard;
signals[MOVE_CURSOR] =
- g_signal_new ("move_cursor",
+ g_signal_new (I_("move_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkLabelClass, move_cursor),
G_TYPE_BOOLEAN);
signals[COPY_CLIPBOARD] =
- g_signal_new ("copy_clipboard",
+ g_signal_new (I_("copy_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkLabelClass, copy_clipboard),
G_TYPE_NONE, 0);
signals[POPULATE_POPUP] =
- g_signal_new ("populate_popup",
+ g_signal_new (I_("populate_popup"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkLabelClass, populate_popup),
}
done:
- g_object_set_data (G_OBJECT (label), g_intern_static_string ("gtk-mnemonic-menu"), mnemonic_menu);
+ g_object_set_data (G_OBJECT (label), I_("gtk-mnemonic-menu"), mnemonic_menu);
}
static void
if (!wrap_width)
{
wrap_width = g_new0 (LabelWrapWidth, 1);
- g_object_set_data_full (G_OBJECT (style), g_intern_static_string ("gtk-label-wrap-width"),
+ g_object_set_data_full (G_OBJECT (style), I_("gtk-label-wrap-width"),
wrap_width, label_wrap_width_free);
}
{
GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
- g_object_set_data (G_OBJECT (menuitem), g_intern_static_string ("gtk-signal"), (char *)signal);
+ g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_cb), label);
(GInstanceInitFunc) gtk_layout_init,
};
- layout_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkLayout"),
+ layout_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkLayout"),
&layout_info, 0);
}
class->set_scroll_adjustments = gtk_layout_set_adjustments;
widget_class->set_scroll_adjustments_signal =
- g_signal_new ("set_scroll_adjustments",
+ g_signal_new (I_("set_scroll_adjustments"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkLayoutClass, set_scroll_adjustments),
#include "gtksignal.h"
#include "gtklabel.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
enum {
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkList");
+ I_("GtkList");
list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);
}
class->unselect_child = gtk_real_list_unselect_child;
list_signals[SELECTION_CHANGED] =
- gtk_signal_new ("selection_changed",
+ gtk_signal_new (I_("selection_changed"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_signals[SELECT_CHILD] =
- gtk_signal_new ("select_child",
+ gtk_signal_new (I_("select_child"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, select_child),
GTK_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
list_signals[UNSELECT_CHILD] =
- gtk_signal_new ("unselect_child",
+ gtk_signal_new (I_("unselect_child"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
#include "gtklist.h"
#include "gtkmarshalers.h"
#include "gtksignal.h"
+#include "gtkintl.h"
#include <gdk/gdkkeysyms.h>
#include "gtkalias.h"
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkListItem");
+ I_("GtkListItem");
list_item_type = gtk_type_unique (gtk_item_get_type (), &list_item_info);
}
class->toggle_add_mode = NULL;
list_item_signals[TOGGLE_FOCUS_ROW] =
- gtk_signal_new ("toggle_focus_row",
+ gtk_signal_new (I_("toggle_focus_row"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_focus_row),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[SELECT_ALL] =
- gtk_signal_new ("select_all",
+ gtk_signal_new (I_("select_all"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, select_all),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[UNSELECT_ALL] =
- gtk_signal_new ("unselect_all",
+ gtk_signal_new (I_("unselect_all"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, unselect_all),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[UNDO_SELECTION] =
- gtk_signal_new ("undo_selection",
+ gtk_signal_new (I_("undo_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, undo_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[START_SELECTION] =
- gtk_signal_new ("start_selection",
+ gtk_signal_new (I_("start_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, start_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[END_SELECTION] =
- gtk_signal_new ("end_selection",
+ gtk_signal_new (I_("end_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, end_selection),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[TOGGLE_ADD_MODE] =
- gtk_signal_new ("toggle_add_mode",
+ gtk_signal_new (I_("toggle_add_mode"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_add_mode),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
list_item_signals[EXTEND_SELECTION] =
- gtk_signal_new ("extend_selection",
+ gtk_signal_new (I_("extend_selection"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, extend_selection),
GTK_TYPE_NONE, 3,
GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT, GTK_TYPE_BOOL);
list_item_signals[SCROLL_VERTICAL] =
- gtk_signal_new ("scroll_vertical",
+ gtk_signal_new (I_("scroll_vertical"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_vertical),
_gtk_marshal_VOID__ENUM_FLOAT,
GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
list_item_signals[SCROLL_HORIZONTAL] =
- gtk_signal_new ("scroll_horizontal",
+ gtk_signal_new (I_("scroll_horizontal"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_horizontal),
#include "gtktreedatalist.h"
#include "gtktreednd.h"
#include "gtksequence.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define GTK_LIST_STORE_IS_SORTED(list) (GTK_LIST_STORE (list)->sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
NULL
};
- list_store_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkListStore"),
+ list_store_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkListStore"),
&list_store_info, 0);
g_type_add_interface_static (list_store_type,
(GInstanceInitFunc) gtk_menu_init,
};
- menu_type = g_type_register_static (GTK_TYPE_MENU_SHELL, g_intern_static_string ("GtkMenu"),
+ menu_type = g_type_register_static (GTK_TYPE_MENU_SHELL, I_("GtkMenu"),
&menu_info, 0);
}
if (!ai)
{
ai = g_new0 (AttachInfo, 1);
- g_object_set_data_full (object, g_intern_static_string (ATTACH_INFO_KEY), ai, g_free);
+ g_object_set_data_full (object, I_(ATTACH_INFO_KEY), ai, g_free);
}
return ai;
menu_shell_class->move_current = gtk_menu_move_current;
menu_signals[MOVE_SCROLL] =
- _gtk_binding_signal_new ("move_scroll",
+ _gtk_binding_signal_new (I_("move_scroll"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_menu_real_move_scroll),
binding_set = gtk_binding_set_by_class (class);
gtk_binding_entry_add_signal (binding_set,
GDK_Up, 0,
- "move_current", 1,
+ I_("move_current"), 1,
GTK_TYPE_MENU_DIRECTION_TYPE,
GTK_MENU_DIR_PREV);
gtk_binding_entry_add_signal (binding_set,
attach_widget_screen_changed (attach_widget, NULL, menu);
data->detacher = detacher;
- g_object_set_data (G_OBJECT (menu), g_intern_static_string (attach_data_key), data);
+ g_object_set_data (G_OBJECT (menu), I_(attach_data_key), data);
list = g_object_steal_data (G_OBJECT (attach_widget), ATTACHED_MENUS);
if (!g_list_find (list, menu))
{
list = g_list_prepend (list, menu);
}
- g_object_set_data_full (G_OBJECT (attach_widget), g_intern_static_string (ATTACHED_MENUS), list, (GtkDestroyNotify) g_list_free);
+ g_object_set_data_full (G_OBJECT (attach_widget), I_(ATTACHED_MENUS), list, (GtkDestroyNotify) g_list_free);
if (GTK_WIDGET_STATE (menu) != GTK_STATE_NORMAL)
gtk_widget_set_state (GTK_WIDGET (menu), GTK_STATE_NORMAL);
g_warning ("gtk_menu_detach(): menu is not attached");
return;
}
- g_object_set_data (G_OBJECT (menu), g_intern_static_string (attach_data_key), NULL);
+ g_object_set_data (G_OBJECT (menu), I_(attach_data_key), NULL);
g_signal_handlers_disconnect_by_func (data->attach_widget,
(gpointer) attach_widget_screen_changed,
list = g_object_steal_data (G_OBJECT (data->attach_widget), ATTACHED_MENUS);
list = g_list_remove (list, menu);
if (list)
- g_object_set_data_full (G_OBJECT (data->attach_widget), g_intern_static_string (ATTACHED_MENUS), list, (GtkDestroyNotify) g_list_free);
+ g_object_set_data_full (G_OBJECT (data->attach_widget), I_(ATTACHED_MENUS), list, (GtkDestroyNotify) g_list_free);
else
- g_object_set_data (G_OBJECT (data->attach_widget), g_intern_static_string (ATTACHED_MENUS), NULL);
+ g_object_set_data (G_OBJECT (data->attach_widget), I_(ATTACHED_MENUS), NULL);
if (GTK_WIDGET_REALIZED (menu))
gtk_widget_unrealize (GTK_WIDGET (menu));
}
GTK_CONTAINER_CLASS (parent_class)->remove (container, widget);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string (ATTACH_INFO_KEY), NULL);
+ g_object_set_data (G_OBJECT (widget), I_(ATTACH_INFO_KEY), NULL);
menu_queue_resize (menu);
}
g_return_if_fail (GTK_IS_MENU (menu));
if (title)
- g_object_set_data_full (G_OBJECT (menu), g_intern_static_string ("gtk-menu-title"),
+ g_object_set_data_full (G_OBJECT (menu), I_("gtk-menu-title"),
g_strdup (title), (GtkDestroyNotify) g_free);
else
- g_object_set_data (G_OBJECT (menu), g_intern_static_string ("gtk-menu-title"), NULL);
+ g_object_set_data (G_OBJECT (menu), I_("gtk-menu-title"), NULL);
gtk_menu_update_title (menu);
g_object_notify (G_OBJECT (menu), "tearoff-title");
gdk_window_show (window);
- g_object_set_data (G_OBJECT (menu), g_intern_static_string ("gtk-menu-transfer-window"), window);
+ g_object_set_data (G_OBJECT (menu), I_("gtk-menu-transfer-window"), window);
}
return window;
{
gdk_window_set_user_data (window, NULL);
gdk_window_destroy (window);
- g_object_set_data (G_OBJECT (menu), g_intern_static_string ("gtk-menu-transfer-window"), NULL);
+ g_object_set_data (G_OBJECT (menu), I_("gtk-menu-transfer-window"), NULL);
}
}
g_return_if_fail (GTK_IS_MENU (menu));
g_return_if_fail (!screen || GDK_IS_SCREEN (screen));
- g_object_set_data (G_OBJECT (menu), g_intern_static_string ("gtk-menu-explicit-screen"), screen);
+ g_object_set_data (G_OBJECT (menu), I_("gtk-menu-explicit-screen"), screen);
if (screen)
{
NULL, /* instance_init */
};
- menu_bar_type = g_type_register_static (GTK_TYPE_MENU_SHELL, g_intern_static_string ("GtkMenuBar"),
+ menu_bar_type = g_type_register_static (GTK_TYPE_MENU_SHELL, I_("GtkMenuBar"),
&menu_bar_info, 0);
}
set_menu_bars (GtkWindow *window,
GList *menubars)
{
- g_object_set_data (G_OBJECT (window), g_intern_static_string ("gtk-menu-bar-list"), menubars);
+ g_object_set_data (G_OBJECT (window), I_("gtk-menu-bar-list"), menubars);
}
static gboolean
#include "gtkmenuitem.h"
#include "gtkseparatormenuitem.h"
#include "gtkprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
(GInstanceInitFunc) gtk_menu_item_init,
};
- menu_item_type = g_type_register_static (GTK_TYPE_ITEM, g_intern_static_string ("GtkMenuItem"),
+ menu_item_type = g_type_register_static (GTK_TYPE_ITEM, I_("GtkMenuItem"),
&menu_item_info, 0);
}
klass->hide_on_activate = TRUE;
menu_item_signals[ACTIVATE] =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkMenuItemClass, activate),
widget_class->activate_signal = menu_item_signals[ACTIVATE];
menu_item_signals[ACTIVATE_ITEM] =
- g_signal_new ("activate_item",
+ g_signal_new (I_("activate_item"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuItemClass, activate_item),
G_TYPE_NONE, 0);
menu_item_signals[TOGGLE_SIZE_REQUEST] =
- g_signal_new ("toggle_size_request",
+ g_signal_new (I_("toggle_size_request"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_request),
G_TYPE_POINTER);
menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
- g_signal_new ("toggle_size_allocate",
+ g_signal_new (I_("toggle_size_allocate"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
};
menu_shell_type =
- g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkMenuShell"),
+ g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkMenuShell"),
&menu_shell_info, G_TYPE_FLAG_ABSTRACT);
}
klass->insert = gtk_menu_shell_real_insert;
menu_shell_signals[DEACTIVATE] =
- g_signal_new ("deactivate",
+ g_signal_new (I_("deactivate"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuShellClass, deactivate),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
menu_shell_signals[SELECTION_DONE] =
- g_signal_new ("selection-done",
+ g_signal_new (I_("selection-done"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuShellClass, selection_done),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
menu_shell_signals[MOVE_CURRENT] =
- g_signal_new ("move_current",
+ g_signal_new (I_("move_current"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkMenuShellClass, move_current),
G_TYPE_NONE, 1,
GTK_TYPE_MENU_DIRECTION_TYPE);
menu_shell_signals[ACTIVATE_CURRENT] =
- g_signal_new ("activate_current",
+ g_signal_new (I_("activate_current"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkMenuShellClass, activate_current),
G_TYPE_NONE, 1,
G_TYPE_BOOLEAN);
menu_shell_signals[CANCEL] =
- g_signal_new ("cancel",
+ g_signal_new (I_("cancel"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkMenuShellClass, cancel),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
menu_shell_signals[CYCLE_FOCUS] =
- _gtk_binding_signal_new ("cycle_focus",
+ _gtk_binding_signal_new (I_("cycle_focus"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_real_menu_shell_cycle_focus),
};
type = g_type_register_static (GTK_TYPE_TOOL_BUTTON,
- g_intern_static_string ("GtkMenuToolButton"),
+ I_("GtkMenuToolButton"),
&info, 0);
}
toolitem_class->toolbar_reconfigured = gtk_menu_tool_button_toolbar_reconfigured;
signals[SHOW_MENU] =
- g_signal_new ("show-menu",
+ g_signal_new (I_("show-menu"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkMenuToolButtonClass, show_menu),
(GInstanceInitFunc) gtk_message_dialog_init,
};
- dialog_type = g_type_register_static (GTK_TYPE_DIALOG, g_intern_static_string ("GtkMessageDialog"),
+ dialog_type = g_type_register_static (GTK_TYPE_DIALOG, I_("GtkMessageDialog"),
&dialog_info, 0);
}
NULL, /* value_table */
};
- misc_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkMisc"),
+ misc_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkMisc"),
&misc_info, G_TYPE_FLAG_ABSTRACT);
}
#include "gtksettings.h"
#include "gtkdebug.h"
#include "gtkprivate.h" /* GTK_LIBDIR */
+#include "gtkintl.h"
#include <gmodule.h>
#include <pango/pango-utils.h> /* For pango_split_file_list */
settings = gtk_settings_get_for_screen (screen);
g_object_set_data_full (G_OBJECT (settings),
- g_intern_static_string ("gtk-modules"),
+ I_("gtk-modules"),
NULL, NULL);
}
}
new_modules = load_modules (modules);
g_object_set_data_full (G_OBJECT (settings),
- g_intern_static_string ("gtk-modules"),
+ I_("gtk-modules"),
new_modules,
settings_destroy_notify);
}
(GInstanceInitFunc) gtk_notebook_init,
};
- notebook_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkNotebook"),
+ notebook_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkNotebook"),
¬ebook_info, 0);
}
GTK_PARAM_READABLE));
notebook_signals[SWITCH_PAGE] =
- g_signal_new ("switch_page",
+ g_signal_new (I_("switch_page"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkNotebookClass, switch_page),
G_TYPE_POINTER,
G_TYPE_UINT);
notebook_signals[FOCUS_TAB] =
- g_signal_new ("focus_tab",
+ g_signal_new (I_("focus_tab"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkNotebookClass, focus_tab),
G_TYPE_BOOLEAN, 1,
GTK_TYPE_NOTEBOOK_TAB);
notebook_signals[SELECT_PAGE] =
- g_signal_new ("select_page",
+ g_signal_new (I_("select_page"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkNotebookClass, select_page),
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
notebook_signals[CHANGE_CURRENT_PAGE] =
- g_signal_new ("change_current_page",
+ g_signal_new (I_("change_current_page"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkNotebookClass, change_current_page),
G_TYPE_NONE, 1,
G_TYPE_INT);
notebook_signals[MOVE_FOCUS_OUT] =
- g_signal_new ("move_focus_out",
+ g_signal_new (I_("move_focus_out"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkNotebookClass, move_focus_out),
#include <string.h>
#include <stdio.h>
#include "gtkobject.h"
+#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtksignal.h"
#include "gtkprivate.h"
NULL, /* value_table */
};
- object_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkObject"),
+ object_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkObject"),
&object_info, G_TYPE_FLAG_ABSTRACT);
}
g_object_class_install_property (gobject_class,
PROP_USER_DATA,
- g_param_spec_pointer ("user-data", "User Data",
- "Anonymous User Data Pointer",
+ g_param_spec_pointer ("user-data",
+ P_("User Data"),
+ P_("Anonymous User Data Pointer"),
GTK_PARAM_READWRITE));
object_signals[DESTROY] =
- g_signal_new ("destroy",
+ g_signal_new (I_("destroy"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (GtkObjectClass, destroy),
switch (property_id)
{
case PROP_USER_DATA:
- g_object_set_data (G_OBJECT (object), g_intern_static_string ("user_data"), g_value_get_pointer (value));
+ g_object_set_data (G_OBJECT (object), I_("user_data"), g_value_get_pointer (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
#include "gtkmarshalers.h"
#include "gtkselection.h"
#include "gtksignal.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define MIN_EDITABLE_WIDTH 150
NULL /* interface_data */
};
- old_editable_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkOldEditable"),
+ old_editable_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkOldEditable"),
&old_editable_info, G_TYPE_FLAG_ABSTRACT);
g_type_add_interface_static (old_editable_type,
GTK_TYPE_EDITABLE,
class->set_position = NULL;
editable_signals[ACTIVATE] =
- gtk_signal_new ("activate",
+ gtk_signal_new (I_("activate"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, activate),
widget_class->activate_signal = editable_signals[ACTIVATE];
editable_signals[SET_EDITABLE] =
- gtk_signal_new ("set-editable",
+ gtk_signal_new (I_("set-editable"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, set_editable),
GTK_TYPE_BOOL);
editable_signals[MOVE_CURSOR] =
- gtk_signal_new ("move_cursor",
+ gtk_signal_new (I_("move_cursor"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, move_cursor),
GTK_TYPE_INT);
editable_signals[MOVE_WORD] =
- gtk_signal_new ("move_word",
+ gtk_signal_new (I_("move_word"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, move_word),
GTK_TYPE_INT);
editable_signals[MOVE_PAGE] =
- gtk_signal_new ("move_page",
+ gtk_signal_new (I_("move_page"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, move_page),
GTK_TYPE_INT);
editable_signals[MOVE_TO_ROW] =
- gtk_signal_new ("move_to_row",
+ gtk_signal_new (I_("move_to_row"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, move_to_row),
GTK_TYPE_INT);
editable_signals[MOVE_TO_COLUMN] =
- gtk_signal_new ("move_to_column",
+ gtk_signal_new (I_("move_to_column"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, move_to_column),
GTK_TYPE_INT);
editable_signals[KILL_CHAR] =
- gtk_signal_new ("kill_char",
+ gtk_signal_new (I_("kill_char"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, kill_char),
GTK_TYPE_INT);
editable_signals[KILL_WORD] =
- gtk_signal_new ("kill_word",
+ gtk_signal_new (I_("kill_word"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, kill_word),
GTK_TYPE_INT);
editable_signals[KILL_LINE] =
- gtk_signal_new ("kill_line",
+ gtk_signal_new (I_("kill_line"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, kill_line),
GTK_TYPE_INT);
editable_signals[CUT_CLIPBOARD] =
- gtk_signal_new ("cut_clipboard",
+ gtk_signal_new (I_("cut_clipboard"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, cut_clipboard),
GTK_TYPE_NONE, 0);
editable_signals[COPY_CLIPBOARD] =
- gtk_signal_new ("copy_clipboard",
+ gtk_signal_new (I_("copy_clipboard"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, copy_clipboard),
GTK_TYPE_NONE, 0);
editable_signals[PASTE_CLIPBOARD] =
- gtk_signal_new ("paste_clipboard",
+ gtk_signal_new (I_("paste_clipboard"),
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkOldEditableClass, paste_clipboard),
};
option_menu_type =
- g_type_register_static (GTK_TYPE_BUTTON, g_intern_static_string ("GtkOptionMenu"),
+ g_type_register_static (GTK_TYPE_BUTTON, I_("GtkOptionMenu"),
&option_menu_info, 0);
}
parent_class = g_type_class_peek_parent (class);
signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkOptionMenuClass, changed),
NULL, /* value_table */
};
- paned_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkPaned"),
+ paned_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkPaned"),
&paned_info, G_TYPE_FLAG_ABSTRACT);
}
GTK_PARAM_READWRITE));
signals [CYCLE_CHILD_FOCUS] =
- g_signal_new ("cycle_child_focus",
+ g_signal_new (I_("cycle_child_focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cycle_child_focus),
G_TYPE_BOOLEAN);
signals [TOGGLE_HANDLE_FOCUS] =
- g_signal_new ("toggle_handle_focus",
+ g_signal_new (I_("toggle_handle_focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, toggle_handle_focus),
G_TYPE_BOOLEAN, 0);
signals[MOVE_HANDLE] =
- g_signal_new ("move_handle",
+ g_signal_new (I_("move_handle"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, move_handle),
GTK_TYPE_SCROLL_TYPE);
signals [CYCLE_HANDLE_FOCUS] =
- g_signal_new ("cycle_handle_focus",
+ g_signal_new (I_("cycle_handle_focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cycle_handle_focus),
G_TYPE_BOOLEAN);
signals [ACCEPT_POSITION] =
- g_signal_new ("accept_position",
+ g_signal_new (I_("accept_position"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, accept_position),
G_TYPE_BOOLEAN, 0);
signals [CANCEL_POSITION] =
- g_signal_new ("cancel_position",
+ g_signal_new (I_("cancel_position"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPanedClass, cancel_position),
/* container_class->child_type = gtk_path_bar_child_type;*/
path_bar_signals [PATH_CLICKED] =
- g_signal_new ("path-clicked",
+ g_signal_new (I_("path-clicked"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkPathBarClass, path_clicked),
#include <math.h>
#include "gtkcontainer.h"
#include "gtkpixmap.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkPixmap");
+ I_("GtkPixmap");
pixmap_type = gtk_type_unique (GTK_TYPE_MISC, &pixmap_info);
}
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkplug.h"
+#include "gtkintl.h"
#include "gtkprivate.h"
#include "gtkplugprivate.h"
(GInstanceInitFunc) gtk_plug_init,
};
- plug_type = g_type_register_static (GTK_TYPE_WINDOW, g_intern_static_string ("GtkPlug"),
+ plug_type = g_type_register_static (GTK_TYPE_WINDOW, I_("GtkPlug"),
&plug_info, 0);
}
window_class->keys_changed = gtk_plug_keys_changed;
plug_signals[EMBEDDED] =
- g_signal_new ("embedded",
+ g_signal_new (I_("embedded"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkPlugClass, embedded),
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkPreview");
+ I_("GtkPreview");
preview_type = gtk_type_unique (GTK_TYPE_WIDGET, &preview_info);
}
(GInstanceInitFunc) gtk_progress_init,
};
- progress_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkProgress"),
+ progress_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkProgress"),
&progress_info, 0);
}
};
progress_bar_type =
- g_type_register_static (GTK_TYPE_PROGRESS, g_intern_static_string ("GtkProgressBar"),
+ g_type_register_static (GTK_TYPE_PROGRESS, I_("GtkProgressBar"),
&progress_bar_info, 0);
}
};
type = g_type_register_static (GTK_TYPE_TOGGLE_ACTION,
- g_intern_static_string ("GtkRadioAction"),
+ I_("GtkRadioAction"),
&type_info, 0);
}
return type;
* Since: 2.4
*/
radio_action_signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkRadioActionClass, changed), NULL, NULL,
};
radio_button_type =
- g_type_register_static (GTK_TYPE_CHECK_BUTTON, g_intern_static_string ("GtkRadioButton"),
+ g_type_register_static (GTK_TYPE_CHECK_BUTTON, I_("GtkRadioButton"),
&radio_button_info, 0);
}
*
* Since: 2.4
*/
- group_changed_signal = g_signal_new ("group-changed",
+ group_changed_signal = g_signal_new (I_("group-changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkRadioButtonClass, group_changed),
};
radio_menu_item_type =
- g_type_register_static (GTK_TYPE_CHECK_MENU_ITEM, g_intern_static_string ("GtkRadioMenuItem"),
+ g_type_register_static (GTK_TYPE_CHECK_MENU_ITEM, I_("GtkRadioMenuItem"),
&radio_menu_item_info, 0);
}
*
* Since: 2.4
*/
- group_changed_signal = g_signal_new ("group-changed",
+ group_changed_signal = g_signal_new (I_("group-changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkRadioMenuItemClass, group_changed),
};
type = g_type_register_static (GTK_TYPE_TOGGLE_TOOL_BUTTON,
- g_intern_static_string ("GtkRadioToolButton"), &type_info, 0);
+ I_("GtkRadioToolButton"), &type_info, 0);
}
return type;
}
NULL, /* value_table */
};
- range_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkRange"),
+ range_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkRange"),
&range_info, G_TYPE_FLAG_ABSTRACT);
}
class->stepper_detail = "stepper";
signals[VALUE_CHANGED] =
- g_signal_new ("value_changed",
+ g_signal_new (I_("value_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkRangeClass, value_changed),
G_TYPE_NONE, 0);
signals[ADJUST_BOUNDS] =
- g_signal_new ("adjust_bounds",
+ g_signal_new (I_("adjust_bounds"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkRangeClass, adjust_bounds),
G_TYPE_DOUBLE);
signals[MOVE_SLIDER] =
- g_signal_new ("move_slider",
+ g_signal_new (I_("move_slider"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkRangeClass, move_slider),
* Since: 2.6
*/
signals[CHANGE_VALUE] =
- g_signal_new ("change_value",
+ g_signal_new (I_("change_value"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkRangeClass, change_value),
(GInstanceInitFunc) gtk_rc_style_init,
};
- rc_style_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkRcStyle"),
+ rc_style_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkRcStyle"),
&rc_style_info, 0);
}
(GInstanceInitFunc) gtk_ruler_init,
};
- ruler_type = g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkRuler"),
+ ruler_type = g_type_register_static (GTK_TYPE_WIDGET, I_("GtkRuler"),
&ruler_info, 0);
}
NULL, /* value_table */
};
- scale_type = g_type_register_static (GTK_TYPE_RANGE, g_intern_static_string ("GtkScale"),
+ scale_type = g_type_register_static (GTK_TYPE_RANGE, I_("GtkScale"),
&scale_info, G_TYPE_FLAG_ABSTRACT);
}
}
-#define add_slider_binding(binding_set, keyval, mask, scroll) \
- gtk_binding_entry_add_signal (binding_set, keyval, mask, \
- "move_slider", 1, \
+#define add_slider_binding(binding_set, keyval, mask, scroll) \
+ gtk_binding_entry_add_signal (binding_set, keyval, mask, \
+ I_("move_slider"), 1, \
GTK_TYPE_SCROLL_TYPE, scroll)
static void
range_class->get_range_border = gtk_scale_get_range_border;
signals[FORMAT_VALUE] =
- g_signal_new ("format_value",
+ g_signal_new (I_("format_value"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkScaleClass, format_value),
};
scrollbar_type =
- g_type_register_static (GTK_TYPE_RANGE, g_intern_static_string ("GtkScrollbar"),
+ g_type_register_static (GTK_TYPE_RANGE, I_("GtkScrollbar"),
&scrollbar_info, G_TYPE_FLAG_ABSTRACT);
}
};
scrolled_window_type =
- g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkScrolledWindow"),
+ g_type_register_static (GTK_TYPE_BIN, I_("GtkScrolledWindow"),
&scrolled_window_info, 0);
}
GTK_PARAM_READABLE));
signals[SCROLL_CHILD] =
- g_signal_new ("scroll_child",
+ g_signal_new (I_("scroll_child"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),
GTK_TYPE_SCROLL_TYPE,
G_TYPE_BOOLEAN);
signals[MOVE_FOCUS_OUT] =
- g_signal_new ("move_focus_out",
+ g_signal_new (I_("move_focus_out"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),
#include "gtkmain.h"
#include "gtkselection.h"
+#include "gtkintl.h"
#include "gdk-pixbuf/gdk-pixbuf.h"
#ifdef GDK_WINDOWING_X11
sellist->list = gtk_target_list_new (NULL, 0);
lists = g_list_prepend (lists, sellist);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string (gtk_selection_handler_key), lists);
+ g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), lists);
return sellist->list;
}
}
g_list_free (lists);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string (gtk_selection_handler_key), NULL);
+ g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), NULL);
}
/**
tmp_list = tmp_list->next;
}
- g_object_set_data (G_OBJECT (widget), g_intern_static_string (gtk_selection_handler_key), lists);
+ g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), lists);
}
/**
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkSelectionData"),
+ our_type = g_boxed_type_register_static (I_("GtkSelectionData"),
(GBoxedCopyFunc) gtk_selection_data_copy,
(GBoxedFreeFunc) gtk_selection_data_free);
#include <config.h>
#include "gtkseparator.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
separator_type =
- g_type_register_static (GTK_TYPE_WIDGET, g_intern_static_string ("GtkSeparator"),
+ g_type_register_static (GTK_TYPE_WIDGET, I_("GtkSeparator"),
&separator_info, G_TYPE_FLAG_ABSTRACT);
}
};
type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
- g_intern_static_string ("GtkSeparatorToolItem"), &type_info, 0);
+ I_("GtkSeparatorToolItem"), &type_info, 0);
}
return type;
}
(GInstanceInitFunc) gtk_settings_init,
};
- settings_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkSettings"),
+ settings_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkSettings"),
&settings_info, 0);
}
{
settings = g_object_new (GTK_TYPE_SETTINGS, NULL);
settings->screen = screen;
- g_object_set_data (G_OBJECT (screen), g_intern_static_string ("gtk-settings"), settings);
+ g_object_set_data (G_OBJECT (screen), I_("gtk-settings"), settings);
gtk_rc_reparse_all_for_settings (settings, TRUE);
settings_update_double_click (settings);
(GInstanceInitFunc) gtk_size_group_init,
};
- size_group_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkSizeGroup"),
+ size_group_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkSizeGroup"),
&size_group_info, 0);
}
#include "gtksocket.h"
#include "gtksocketprivate.h"
#include "gtkdnd.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GInstanceInitFunc) gtk_socket_init,
};
- socket_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkSocket"),
+ socket_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkSocket"),
&socket_info, 0);
}
container_class->forall = gtk_socket_forall;
socket_signals[PLUG_ADDED] =
- g_signal_new ("plug_added",
+ g_signal_new (I_("plug_added"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSocketClass, plug_added),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
socket_signals[PLUG_REMOVED] =
- g_signal_new ("plug_removed",
+ g_signal_new (I_("plug_removed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSocketClass, plug_removed),
socket->active = FALSE;
socket->accel_group = gtk_accel_group_new ();
- g_object_set_data (G_OBJECT (socket->accel_group), g_intern_static_string ("gtk-socket"), socket);
+ g_object_set_data (G_OBJECT (socket->accel_group), I_("gtk-socket"), socket);
}
/**
};
spin_button_type =
- g_type_register_static (GTK_TYPE_ENTRY, g_intern_static_string ("GtkSpinButton"),
+ g_type_register_static (GTK_TYPE_ENTRY, I_("GtkSpinButton"),
&spin_button_info, 0);
g_type_add_interface_static (spin_button_type,
GTK_PARAM_READABLE),
gtk_rc_property_parse_enum);
spinbutton_signals[INPUT] =
- g_signal_new ("input",
+ g_signal_new (I_("input"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSpinButtonClass, input),
G_TYPE_POINTER);
spinbutton_signals[OUTPUT] =
- g_signal_new ("output",
+ g_signal_new (I_("output"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSpinButtonClass, output),
G_TYPE_BOOLEAN, 0);
spinbutton_signals[VALUE_CHANGED] =
- g_signal_new ("value_changed",
+ g_signal_new (I_("value_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkSpinButtonClass, value_changed),
/* Action signals */
spinbutton_signals[CHANGE_VALUE] =
- g_signal_new ("change_value",
+ g_signal_new (I_("change_value"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkSpinButtonClass, change_value),
(GInstanceInitFunc) gtk_statusbar_init,
};
- statusbar_type = g_type_register_static (GTK_TYPE_HBOX, g_intern_static_string ("GtkStatusbar"),
+ statusbar_type = g_type_register_static (GTK_TYPE_HBOX, I_("GtkStatusbar"),
&statusbar_info, 0);
}
TRUE,
GTK_PARAM_READWRITE));
statusbar_signals[SIGNAL_TEXT_PUSHED] =
- g_signal_new ("text_pushed",
+ g_signal_new (I_("text_pushed"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkStatusbarClass, text_pushed),
G_TYPE_UINT,
G_TYPE_STRING);
statusbar_signals[SIGNAL_TEXT_POPPED] =
- g_signal_new ("text_popped",
+ g_signal_new (I_("text_popped"),
G_OBJECT_CLASS_TYPE (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkStatusbarClass, text_popped),
* Since: 2.10
*/
status_icon_signals [ACTIVATE_SIGNAL] =
- g_signal_new ("activate",
+ g_signal_new (I_("activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkStatusIconClass, activate),
* Since: 2.10
*/
status_icon_signals [POPUP_MENU_SIGNAL] =
- g_signal_new ("popup-menu",
+ g_signal_new (I_("popup-menu"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkStatusIconClass, popup_menu),
* Since: 2.10
*/
status_icon_signals [SIZE_CHANGED_SIGNAL] =
- g_signal_new ("size-changed",
+ g_signal_new (I_("size-changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkStatusIconClass, size_changed),
#include "gtkthemes.h"
#include "gtkiconfactory.h"
#include "gtksettings.h" /* _gtk_settings_parse_convert() */
+#include "gtkintl.h"
#include "gtkalias.h"
#define LIGHTNESS_MULT 1.3
(GInstanceInitFunc) gtk_style_init,
};
- style_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkStyle"),
+ style_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkStyle"),
&style_info, 0);
}
*
* Since: 2.4
*/
- realize_signal = g_signal_new ("realize",
+ realize_signal = g_signal_new (I_("realize"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkStyleClass, realize),
*
* Since: 2.4
*/
- unrealize_signal = g_signal_new ("unrealize",
+ unrealize_signal = g_signal_new (I_("unrealize"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkStyleClass, unrealize),
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkBorder"),
+ our_type = g_boxed_type_register_static (I_("GtkBorder"),
(GBoxedCopyFunc) gtk_border_copy,
(GBoxedFreeFunc) gtk_border_free);
gtk_gc_release (cursor_info->secondary_gc);
g_free (cursor_info);
- g_object_set_data (G_OBJECT (style), g_intern_static_string ("gtk-style-cursor-info"), NULL);
+ g_object_set_data (G_OBJECT (style), I_("gtk-style-cursor-info"), NULL);
}
}
if (!cursor_info)
{
cursor_info = g_new (CursorInfo, 1);
- g_object_set_data (G_OBJECT (widget->style), g_intern_static_string ("gtk-style-cursor-info"), cursor_info);
+ g_object_set_data (G_OBJECT (widget->style), I_("gtk-style-cursor-info"), cursor_info);
cursor_info->primary_gc = NULL;
cursor_info->secondary_gc = NULL;
cursor_info->for_type = G_TYPE_INVALID;
(GInstanceInitFunc) gtk_table_init,
};
- table_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkTable"),
+ table_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkTable"),
&table_info, 0);
}
#include "gtkmenu.h"
#include "gtktearoffmenuitem.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define ARROW_SIZE 10
};
tearoff_menu_item_type =
- g_type_register_static (GTK_TYPE_MENU_ITEM, g_intern_static_string ("GtkTearoffMenuItem"),
+ g_type_register_static (GTK_TYPE_MENU_ITEM, I_("GtkTearoffMenuItem"),
&tearoff_menu_item_info, 0);
}
NULL /* interface_data */
};
- g_intern_static_string ("GtkText");
+ I_("GtkText");
text_type = gtk_type_unique (GTK_TYPE_OLD_EDITABLE, &text_info);
g_type_add_interface_static (text_type,
GTK_TYPE_EDITABLE,
GTK_PARAM_READWRITE));
widget_class->set_scroll_adjustments_signal =
- gtk_signal_new ("set_scroll_adjustments",
+ gtk_signal_new (I_("set_scroll_adjustments"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTextClass, set_scroll_adjustments),
(GInstanceInitFunc) gtk_text_buffer_init
};
- our_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextBuffer"),
+ our_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextBuffer"),
&our_info, 0);
}
GTK_PARAM_READWRITE));
signals[INSERT_TEXT] =
- g_signal_new ("insert_text",
+ g_signal_new (I_("insert_text"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, insert_text),
G_TYPE_INT);
signals[INSERT_PIXBUF] =
- g_signal_new ("insert_pixbuf",
+ g_signal_new (I_("insert_pixbuf"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, insert_pixbuf),
GDK_TYPE_PIXBUF);
signals[INSERT_CHILD_ANCHOR] =
- g_signal_new ("insert_child_anchor",
+ g_signal_new (I_("insert_child_anchor"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, insert_child_anchor),
* those don't have access to the deleted text.
*/
signals[DELETE_RANGE] =
- g_signal_new ("delete_range",
+ g_signal_new (I_("delete_range"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, delete_range),
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, changed),
0);
signals[MODIFIED_CHANGED] =
- g_signal_new ("modified_changed",
+ g_signal_new (I_("modified_changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, modified_changed),
0);
signals[MARK_SET] =
- g_signal_new ("mark_set",
+ g_signal_new (I_("mark_set"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, mark_set),
GTK_TYPE_TEXT_MARK);
signals[MARK_DELETED] =
- g_signal_new ("mark_deleted",
+ g_signal_new (I_("mark_deleted"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, mark_deleted),
GTK_TYPE_TEXT_MARK);
signals[APPLY_TAG] =
- g_signal_new ("apply_tag",
+ g_signal_new (I_("apply_tag"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, apply_tag),
GTK_TYPE_TEXT_ITER);
signals[REMOVE_TAG] =
- g_signal_new ("remove_tag",
+ g_signal_new (I_("remove_tag"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, remove_tag),
GTK_TYPE_TEXT_ITER);
signals[BEGIN_USER_ACTION] =
- g_signal_new ("begin_user_action",
+ g_signal_new (I_("begin_user_action"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, begin_user_action),
0);
signals[END_USER_ACTION] =
- g_signal_new ("end_user_action",
+ g_signal_new (I_("end_user_action"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextBufferClass, end_user_action),
contents = gtk_text_buffer_new (gtk_text_buffer_get_tag_table (buffer));
- g_object_set_data (G_OBJECT (contents), g_intern_static_string ("gtk-text-buffer-clipboard"), GINT_TO_POINTER (1));
+ g_object_set_data (G_OBJECT (contents), I_("gtk-text-buffer-clipboard"), GINT_TO_POINTER (1));
return contents;
}
#include "gtktextchild.h"
#include "gtktextbtree.h"
#include "gtktextlayout.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define CHECK_IN_BUFFER(anchor) \
GtkTextLayout *layout)
{
g_object_set_data (G_OBJECT (child),
- g_intern_static_string ("gtk-text-child-anchor-layout"),
+ I_("gtk-text-child-anchor-layout"),
layout);
}
(GInstanceInitFunc) gtk_text_child_anchor_init,
};
- object_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextChildAnchor"),
+ object_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextChildAnchor"),
&object_info, 0);
}
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
#include <config.h>
#include "gtktextdisplay.h"
+#include "gtkintl.h"
#include "gtkalias.h"
/* DO NOT go putting private headers in here. This file should only
* use the semi-public headers, as with gtktextview.c.
g_signal_handlers_disconnect_by_func (text_renderer->screen,
(gpointer)on_renderer_display_closed,
text_renderer);
- g_object_set_data (G_OBJECT (text_renderer->screen), g_intern_static_string ("gtk-text-renderer"), NULL);
+ g_object_set_data (G_OBJECT (text_renderer->screen), I_("gtk-text-renderer"), NULL);
}
static GtkTextRenderer *
text_renderer = g_object_new (GTK_TYPE_TEXT_RENDERER, "screen", screen, NULL);
text_renderer->screen = screen;
- g_object_set_data_full (G_OBJECT (screen), g_intern_static_string ("gtk-text-renderer"), text_renderer,
+ g_object_set_data_full (G_OBJECT (screen), I_("gtk-text-renderer"), text_renderer,
(GDestroyNotify)g_object_unref);
g_signal_connect (gdk_screen_get_display (screen), "closed",
#include "gtktextlayout.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include <stdlib.h>
(GInstanceInitFunc) gtk_text_layout_init
};
- our_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextLayout"),
+ our_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextLayout"),
&our_info, 0);
}
klass->free_line_data = gtk_text_layout_real_free_line_data;
signals[INVALIDATED] =
- g_signal_new ("invalidated",
+ g_signal_new (I_("invalidated"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextLayoutClass, invalidated),
0);
signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextLayoutClass, changed),
G_TYPE_INT);
signals[ALLOCATE_CHILD] =
- g_signal_new ("allocate_child",
+ g_signal_new (I_("allocate_child"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextLayoutClass, allocate_child),
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
#include <config.h>
#include "gtktextbtree.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_text_mark_init (GtkTextMark *mark);
(GInstanceInitFunc) gtk_text_mark_init,
};
- object_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextMark"),
+ object_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextMark"),
&object_info, 0);
}
(GInstanceInitFunc) gtk_text_tag_init
};
- our_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextTag"),
+ our_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextTag"),
&our_info, 0);
}
P_("Whether this tag affects the paragraph background color"));
signals[EVENT] =
- g_signal_new ("event",
+ g_signal_new (I_("event"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextTagClass, event),
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkTextAttributes"),
+ our_type = g_boxed_type_register_static (I_("GtkTextAttributes"),
(GBoxedCopyFunc) gtk_text_attributes_ref,
(GBoxedFreeFunc) gtk_text_attributes_unref);
#include "gtktexttagtable.h"
#include "gtkmarshalers.h"
#include "gtktextbuffer.h" /* just for the lame notify_will_remove_tag hack */
+#include "gtkintl.h"
#include "gtkalias.h"
#include <stdlib.h>
(GInstanceInitFunc) gtk_text_tag_table_init
};
- our_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTextTagTable"),
+ our_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTextTagTable"),
&our_info, 0);
}
object_class->finalize = gtk_text_tag_table_finalize;
signals[TAG_CHANGED] =
- g_signal_new ("tag_changed",
+ g_signal_new (I_("tag_changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextTagTableClass, tag_changed),
G_TYPE_BOOLEAN);
signals[TAG_ADDED] =
- g_signal_new ("tag_added",
+ g_signal_new (I_("tag_added"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextTagTableClass, tag_added),
GTK_TYPE_TEXT_TAG);
signals[TAG_REMOVED] =
- g_signal_new ("tag_removed",
+ g_signal_new (I_("tag_removed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextTagTableClass, tag_removed),
info->data = data;
menuitem = gtk_menu_item_new_with_mnemonic (_(bidi_menu_entries[i].label));
- g_object_set_data (G_OBJECT (menuitem), g_intern_static_string ("gtk-unicode-menu-entry"),
+ g_object_set_data (G_OBJECT (menuitem), I_("gtk-unicode-menu-entry"),
(gpointer)&bidi_menu_entries[i]);
g_signal_connect_data (menuitem, "activate",
(GInstanceInitFunc) gtk_text_view_init,
};
- our_type = g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkTextView"),
+ our_type = g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkTextView"),
&our_info, 0);
}
*
*/
signals[MOVE_CURSOR] =
- g_signal_new ("move_cursor",
+ g_signal_new (I_("move_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, move_cursor),
G_TYPE_BOOLEAN);
signals[PAGE_HORIZONTALLY] =
- g_signal_new ("page_horizontally",
+ g_signal_new (I_("page_horizontally"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, page_horizontally),
G_TYPE_BOOLEAN);
signals[MOVE_VIEWPORT] =
- _gtk_binding_signal_new ("move_viewport",
+ _gtk_binding_signal_new (I_("move_viewport"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_text_view_move_viewport),
G_TYPE_INT);
signals[SET_ANCHOR] =
- g_signal_new ("set_anchor",
+ g_signal_new (I_("set_anchor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, set_anchor),
G_TYPE_NONE, 0);
signals[INSERT_AT_CURSOR] =
- g_signal_new ("insert_at_cursor",
+ g_signal_new (I_("insert_at_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, insert_at_cursor),
G_TYPE_STRING);
signals[DELETE_FROM_CURSOR] =
- g_signal_new ("delete_from_cursor",
+ g_signal_new (I_("delete_from_cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, delete_from_cursor),
G_TYPE_INT);
signals[BACKSPACE] =
- g_signal_new ("backspace",
+ g_signal_new (I_("backspace"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, backspace),
G_TYPE_NONE, 0);
signals[CUT_CLIPBOARD] =
- g_signal_new ("cut_clipboard",
+ g_signal_new (I_("cut_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, cut_clipboard),
G_TYPE_NONE, 0);
signals[COPY_CLIPBOARD] =
- g_signal_new ("copy_clipboard",
+ g_signal_new (I_("copy_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, copy_clipboard),
G_TYPE_NONE, 0);
signals[PASTE_CLIPBOARD] =
- g_signal_new ("paste_clipboard",
+ g_signal_new (I_("paste_clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, paste_clipboard),
G_TYPE_NONE, 0);
signals[TOGGLE_OVERWRITE] =
- g_signal_new ("toggle_overwrite",
+ g_signal_new (I_("toggle_overwrite"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, toggle_overwrite),
G_TYPE_NONE, 0);
signals[MOVE_FOCUS] =
- g_signal_new ("move_focus",
+ g_signal_new (I_("move_focus"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, move_focus),
GTK_TYPE_DIRECTION_TYPE);
signals[SET_SCROLL_ADJUSTMENTS] =
- g_signal_new ("set_scroll_adjustments",
+ g_signal_new (I_("set_scroll_adjustments"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, set_scroll_adjustments),
widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS];
signals[POPULATE_POPUP] =
- g_signal_new ("populate_popup",
+ g_signal_new (I_("populate_popup"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextViewClass, populate_popup),
GTK_TYPE_MENU);
signals[SELECT_ALL] =
- _gtk_binding_signal_new ("select_all",
+ _gtk_binding_signal_new (I_("select_all"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_text_view_select_all),
{
GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
- g_object_set_data (G_OBJECT (menuitem), g_intern_static_string ("gtk-signal"), (char *)signal);
+ g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_cb), text_view);
g_object_ref (vc->anchor);
g_object_set_data (G_OBJECT (child),
- g_intern_static_string ("gtk-text-view-child"),
+ I_("gtk-text-view-child"),
vc);
gtk_text_child_anchor_register_child (anchor, child, layout);
vc->y = y;
g_object_set_data (G_OBJECT (child),
- g_intern_static_string ("gtk-text-view-child"),
+ I_("gtk-text-view-child"),
vc);
return vc;
text_view_child_free (GtkTextViewChild *child)
{
g_object_set_data (G_OBJECT (child->widget),
- g_intern_static_string ("gtk-text-view-child"), NULL);
+ I_("gtk-text-view-child"), NULL);
if (child->anchor)
{
};
theme_engine_type =
- g_type_register_static (G_TYPE_TYPE_MODULE, g_intern_static_string ("GtkThemeEngine"),
+ g_type_register_static (G_TYPE_TYPE_MODULE, I_("GtkThemeEngine"),
&theme_engine_info, 0);
}
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkTipsQuery");
+ I_("GtkTipsQuery");
tips_query_type = gtk_type_unique (gtk_label_get_type (), &tips_query_info);
}
gtk_object_add_arg_type ("GtkTipsQuery::label-no-tip", GTK_TYPE_STRING, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_LABEL_NO_TIP);
tips_query_signals[SIGNAL_START_QUERY] =
- gtk_signal_new ("start_query",
+ gtk_signal_new (I_("start_query"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, start_query),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
tips_query_signals[SIGNAL_STOP_QUERY] =
- gtk_signal_new ("stop_query",
+ gtk_signal_new (I_("stop_query"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, stop_query),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
tips_query_signals[SIGNAL_WIDGET_ENTERED] =
- gtk_signal_new ("widget_entered",
+ gtk_signal_new (I_("widget_entered"),
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_entered),
GTK_TYPE_STRING,
GTK_TYPE_STRING);
tips_query_signals[SIGNAL_WIDGET_SELECTED] =
- g_signal_new ("widget_selected",
+ g_signal_new (I_("widget_selected"),
G_TYPE_FROM_CLASS(object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkTipsQueryClass, widget_selected),
};
type = g_type_register_static (GTK_TYPE_ACTION,
- g_intern_static_string ("GtkToggleAction"),
+ I_("GtkToggleAction"),
&type_info, 0);
}
return type;
GTK_PARAM_READWRITE));
action_signals[TOGGLED] =
- g_signal_new ("toggled",
+ g_signal_new (I_("toggled"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToggleActionClass, toggled),
};
toggle_button_type =
- g_type_register_static (GTK_TYPE_BUTTON, g_intern_static_string ("GtkToggleButton"),
+ g_type_register_static (GTK_TYPE_BUTTON, I_("GtkToggleButton"),
&toggle_button_info, 0);
}
GTK_PARAM_READWRITE));
toggle_button_signals[TOGGLED] =
- g_signal_new ("toggled",
+ g_signal_new (I_("toggled"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToggleButtonClass, toggled),
};
type = g_type_register_static (GTK_TYPE_TOOL_BUTTON,
- g_intern_static_string ("GtkToggleToolButton"), &type_info, 0);
+ I_("GtkToggleToolButton"), &type_info, 0);
}
return type;
}
* Emitted whenever the toggle tool button changes state.
**/
toggle_signals[TOGGLED] =
- g_signal_new ("toggled",
+ g_signal_new (I_("toggled"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToggleToolButtonClass, toggled),
};
type = g_type_register_static (GTK_TYPE_CONTAINER,
- g_intern_static_string ("GtkToolbar"),
+ I_("GtkToolbar"),
&type_info, 0);
}
* Emitted when the orientation of the toolbar changes.
*/
toolbar_signals[ORIENTATION_CHANGED] =
- g_signal_new ("orientation-changed",
+ g_signal_new (I_("orientation-changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToolbarClass, orientation_changed),
* Emitted when the style of the toolbar changes.
*/
toolbar_signals[STYLE_CHANGED] =
- g_signal_new ("style-changed",
+ g_signal_new (I_("style-changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToolbarClass, style_changed),
* Return value: return %TRUE if the signal was handled, %FALSE if not
*/
toolbar_signals[POPUP_CONTEXT_MENU] =
- g_signal_new ("popup_context_menu",
+ g_signal_new (I_("popup_context_menu"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolbarClass, popup_context_menu),
* Return value: %TRUE if the signal was handled, %FALSE if not
*/
toolbar_signals[MOVE_FOCUS] =
- _gtk_binding_signal_new ("move_focus",
+ _gtk_binding_signal_new (I_("move_focus"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_toolbar_move_focus),
* Return value: %TRUE if the signal was handled, %FALSE if not
*/
toolbar_signals[FOCUS_HOME_OR_END] =
- _gtk_binding_signal_new ("focus_home_or_end",
+ _gtk_binding_signal_new (I_("focus_home_or_end"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (gtk_toolbar_focus_home_or_end),
};
type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
- g_intern_static_string ("GtkToolButton"),
+ I_("GtkToolButton"),
&type_info, 0);
}
return type;
* or activated with the keyboard.
**/
toolbutton_signals[CLICKED] =
- g_signal_new ("clicked",
+ g_signal_new (I_("clicked"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToolButtonClass, clicked),
};
type = g_type_register_static (GTK_TYPE_BIN,
- g_intern_static_string ("GtkToolItem"),
+ I_("GtkToolItem"),
&type_info, 0);
}
return type;
* Return value: %TRUE if the signal was handled, %FALSE if not
**/
toolitem_signals[CREATE_MENU_PROXY] =
- g_signal_new ("create_menu_proxy",
+ g_signal_new (I_("create_menu_proxy"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, create_menu_proxy),
* themselves accordingly.
**/
toolitem_signals[TOOLBAR_RECONFIGURED] =
- g_signal_new ("toolbar_reconfigured",
+ g_signal_new (I_("toolbar_reconfigured"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, toolbar_reconfigured),
* Return value: %TRUE if the signal was handled, %FALSE if not
**/
toolitem_signals[SET_TOOLTIP] =
- g_signal_new ("set_tooltip",
+ g_signal_new (I_("set_tooltip"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, set_tooltip),
#include "gtkwindow.h"
#include "gtkstyle.h"
#include "gtktooltips.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GInstanceInitFunc) gtk_tooltips_init,
};
- tooltips_type = g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkTooltips"),
+ tooltips_type = g_type_register_static (GTK_TYPE_OBJECT, I_("GtkTooltips"),
&tooltips_info, 0);
}
gtk_tooltips_widget_remove,
tooltipsdata);
- g_object_set_data (G_OBJECT (tooltipsdata->widget), g_intern_static_string (tooltips_data_key), NULL);
+ g_object_set_data (G_OBJECT (tooltipsdata->widget), I_(tooltips_data_key), NULL);
g_object_unref (tooltipsdata->widget);
g_free (tooltipsdata);
}
G_CALLBACK (gtk_tooltips_event_handler),
tooltipsdata);
- g_object_set_data (G_OBJECT (widget), g_intern_static_string (tooltips_data_key),
+ g_object_set_data (G_OBJECT (widget), I_(tooltips_data_key),
tooltipsdata);
g_signal_connect (widget, "unmap",
style = tooltips->tip_window->style;
widget = tooltips->active_tips_data->widget;
- g_object_set_data (G_OBJECT (tooltips->tip_window), g_intern_static_string (tooltips_info_key),
+ g_object_set_data (G_OBJECT (tooltips->tip_window), I_(tooltips_info_key),
tooltips);
keyboard_mode = get_keyboard_mode (widget);
{
GtkWidget *focus = GTK_WINDOW (toplevel)->focus_widget;
- g_object_set_data (G_OBJECT (toplevel), g_intern_static_string ("gtk-tooltips-keyboard-mode"), GUINT_TO_POINTER (TRUE));
+ g_object_set_data (G_OBJECT (toplevel), I_("gtk-tooltips-keyboard-mode"), GUINT_TO_POINTER (TRUE));
if (focus)
gtk_tooltips_show_tip (focus);
if (focus)
gtk_tooltips_hide_tip (focus);
- g_object_set_data (G_OBJECT (toplevel), g_intern_static_string ("gtk-tooltips-keyboard-mode"), GUINT_TO_POINTER (FALSE));
+ g_object_set_data (G_OBJECT (toplevel), I_("gtk-tooltips-keyboard-mode"), GUINT_TO_POINTER (FALSE));
}
}
#define GTK_ENABLE_BROKEN
#include "gtktree.h"
#include "gtktreeitem.h"
+#include "gtkintl.h"
#include "gtkalias.h"
enum {
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkTree");
+ I_("GtkTree");
tree_type = gtk_type_unique (gtk_container_get_type (), &tree_info);
}
class->unselect_child = gtk_real_tree_unselect_child;
tree_signals[SELECTION_CHANGED] =
- gtk_signal_new ("selection_changed",
+ gtk_signal_new (I_("selection_changed"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, selection_changed),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
tree_signals[SELECT_CHILD] =
- gtk_signal_new ("select_child",
+ gtk_signal_new (I_("select_child"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, select_child),
GTK_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
tree_signals[UNSELECT_CHILD] =
- gtk_signal_new ("unselect_child",
+ gtk_signal_new (I_("unselect_child"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeClass, unselect_child),
#include <config.h>
#include <string.h>
#include "gtktreednd.h"
+#include "gtkintl.h"
#include "gtkalias.h"
GType
NULL
};
- our_type = g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkTreeDragSource"),
+ our_type = g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeDragSource"),
&our_info, 0);
}
NULL
};
- our_type = g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkTreeDragDest"), &our_info, 0);
+ our_type = g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeDragDest"), &our_info, 0);
}
return our_type;
#define GTK_ENABLE_BROKEN
#include "gtktree.h"
#include "gtktreeitem.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include "tree_plus.xpm"
(GtkClassInitFunc) NULL,
};
- g_intern_static_string ("GtkTreeItem");
+ I_("GtkTreeItem");
tree_item_type = gtk_type_unique (gtk_item_get_type (), &tree_item_info);
}
class->collapse = gtk_real_tree_item_collapse;
tree_item_signals[EXPAND_TREE] =
- gtk_signal_new ("expand",
+ gtk_signal_new (I_("expand"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeItemClass, expand),
_gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
tree_item_signals[COLLAPSE_TREE] =
- gtk_signal_new ("collapse",
+ gtk_signal_new (I_("collapse"),
GTK_RUN_FIRST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkTreeItemClass, collapse),
#include "gtktreeview.h"
#include "gtktreeprivate.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
tree_model_type =
- g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkTreeModel"),
+ g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeModel"),
&tree_model_info, 0);
g_type_interface_add_prerequisite (tree_model_type, G_TYPE_OBJECT);
rows_reordered_params[2] = G_TYPE_POINTER;
tree_model_signals[ROW_CHANGED] =
- g_signal_new ("row_changed",
+ g_signal_new (I_("row_changed"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeModelIface, row_changed),
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, row_inserted_marshal);
tree_model_signals[ROW_INSERTED] =
- g_signal_newv ("row_inserted",
+ g_signal_newv (I_("row_inserted"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
row_inserted_params);
tree_model_signals[ROW_HAS_CHILD_TOGGLED] =
- g_signal_new ("row_has_child_toggled",
+ g_signal_new (I_("row_has_child_toggled"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeModelIface, row_has_child_toggled),
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, row_deleted_marshal);
tree_model_signals[ROW_DELETED] =
- g_signal_newv ("row_deleted",
+ g_signal_newv (I_("row_deleted"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
closure = g_closure_new_simple (sizeof (GClosure), NULL);
g_closure_set_marshal (closure, rows_reordered_marshal);
tree_model_signals[ROWS_REORDERED] =
- g_signal_newv ("rows_reordered",
+ g_signal_newv (I_("rows_reordered"),
GTK_TYPE_TREE_MODEL,
G_SIGNAL_RUN_FIRST,
closure,
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkTreePath"),
+ our_type = g_boxed_type_register_static (I_("GtkTreePath"),
(GBoxedCopyFunc) gtk_tree_path_copy,
(GBoxedFreeFunc) gtk_tree_path_free);
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkTreeIter"),
+ our_type = g_boxed_type_register_static (I_("GtkTreeIter"),
(GBoxedCopyFunc) gtk_tree_iter_copy,
(GBoxedFreeFunc) gtk_tree_iter_free);
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkTreeRowReference"),
+ our_type = g_boxed_type_register_static (I_("GtkTreeRowReference"),
(GBoxedCopyFunc) gtk_tree_row_reference_copy,
(GBoxedFreeFunc) gtk_tree_row_reference_free);
refs->list = NULL;
g_object_set_data_full (G_OBJECT (proxy),
- g_intern_static_string (ROW_REF_DATA_STRING),
+ I_(ROW_REF_DATA_STRING),
refs, release_row_references);
}
if (refs->list == NULL)
{
g_object_set_data (G_OBJECT (reference->proxy),
- g_intern_static_string (ROW_REF_DATA_STRING),
+ I_(ROW_REF_DATA_STRING),
NULL);
}
};
tree_model_filter_type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkTreeModelFilter"),
+ I_("GtkTreeModelFilter"),
&tree_model_filter_info, 0);
g_type_add_interface_static (tree_model_filter_type,
};
tree_model_sort_type =
- g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTreeModelSort"),
+ g_type_register_static (G_TYPE_OBJECT, I_("GtkTreeModelSort"),
&tree_model_sort_info, 0);
g_type_add_interface_static (tree_model_sort_type,
#include "gtktreeprivate.h"
#include "gtkrbtree.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_tree_selection_init (GtkTreeSelection *selection);
};
selection_type =
- g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTreeSelection"),
+ g_type_register_static (G_TYPE_OBJECT, I_("GtkTreeSelection"),
&selection_info, 0);
}
class->changed = NULL;
tree_selection_signals[CHANGED] =
- g_signal_new ("changed",
+ g_signal_new (I_("changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkTreeSelectionClass, changed),
#include <config.h>
#include "gtktreesortable.h"
#include "gtkmarshalers.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_tree_sortable_base_init (gpointer g_class);
};
tree_sortable_type =
- g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GtkTreeSortable"),
+ g_type_register_static (G_TYPE_INTERFACE, I_("GtkTreeSortable"),
&tree_sortable_info, 0);
g_type_interface_add_prerequisite (tree_sortable_type, GTK_TYPE_TREE_MODEL);
if (! initialized)
{
- g_signal_new ("sort_column_changed",
+ g_signal_new (I_("sort_column_changed"),
GTK_TYPE_TREE_SORTABLE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeSortableIface, sort_column_changed),
#include "gtktreestore.h"
#include "gtktreedatalist.h"
#include "gtktreednd.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#define G_NODE(node) ((GNode *)node)
NULL
};
- tree_store_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkTreeStore"),
+ tree_store_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkTreeStore"),
&tree_store_info, 0);
g_type_add_interface_static (tree_store_type,
};
tree_view_type =
- g_type_register_static (GTK_TYPE_CONTAINER, g_intern_static_string ("GtkTreeView"),
+ g_type_register_static (GTK_TYPE_CONTAINER, I_("GtkTreeView"),
&tree_view_info, 0);
}
/* Signals */
widget_class->set_scroll_adjustments_signal =
- g_signal_new ("set_scroll_adjustments",
+ g_signal_new (I_("set_scroll_adjustments"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
GTK_TYPE_ADJUSTMENT);
tree_view_signals[ROW_ACTIVATED] =
- g_signal_new ("row_activated",
+ g_signal_new (I_("row_activated"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
GTK_TYPE_TREE_VIEW_COLUMN);
tree_view_signals[TEST_EXPAND_ROW] =
- g_signal_new ("test_expand_row",
+ g_signal_new (I_("test_expand_row"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
GTK_TYPE_TREE_PATH);
tree_view_signals[TEST_COLLAPSE_ROW] =
- g_signal_new ("test_collapse_row",
+ g_signal_new (I_("test_collapse_row"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
GTK_TYPE_TREE_PATH);
tree_view_signals[ROW_EXPANDED] =
- g_signal_new ("row_expanded",
+ g_signal_new (I_("row_expanded"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
GTK_TYPE_TREE_PATH);
tree_view_signals[ROW_COLLAPSED] =
- g_signal_new ("row_collapsed",
+ g_signal_new (I_("row_collapsed"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
GTK_TYPE_TREE_PATH);
tree_view_signals[COLUMNS_CHANGED] =
- g_signal_new ("columns_changed",
+ g_signal_new (I_("columns_changed"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
G_TYPE_NONE, 0);
tree_view_signals[CURSOR_CHANGED] =
- g_signal_new ("cursor_changed",
+ g_signal_new (I_("cursor_changed"),
G_TYPE_FROM_CLASS (o_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
G_TYPE_NONE, 0);
tree_view_signals[MOVE_CURSOR] =
- g_signal_new ("move_cursor",
+ g_signal_new (I_("move_cursor"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
G_TYPE_INT);
tree_view_signals[SELECT_ALL] =
- g_signal_new ("select_all",
+ g_signal_new (I_("select_all"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
G_TYPE_BOOLEAN, 0);
tree_view_signals[UNSELECT_ALL] =
- g_signal_new ("unselect_all",
+ g_signal_new (I_("unselect_all"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
G_TYPE_BOOLEAN, 0);
tree_view_signals[SELECT_CURSOR_ROW] =
- g_signal_new ("select_cursor_row",
+ g_signal_new (I_("select_cursor_row"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
G_TYPE_BOOLEAN);
tree_view_signals[TOGGLE_CURSOR_ROW] =
- g_signal_new ("toggle_cursor_row",
+ g_signal_new (I_("toggle_cursor_row"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
G_TYPE_BOOLEAN, 0);
tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
- g_signal_new ("expand_collapse_cursor_row",
+ g_signal_new (I_("expand_collapse_cursor_row"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
G_TYPE_BOOLEAN);
tree_view_signals[SELECT_CURSOR_PARENT] =
- g_signal_new ("select_cursor_parent",
+ g_signal_new (I_("select_cursor_parent"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
G_TYPE_BOOLEAN, 0);
tree_view_signals[START_INTERACTIVE_SEARCH] =
- g_signal_new ("start_interactive_search",
+ g_signal_new (I_("start_interactive_search"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
GtkTreePath *source_row)
{
g_object_set_data_full (G_OBJECT (context),
- g_intern_static_string ("gtk-tree-view-source-row"),
+ I_("gtk-tree-view-source-row"),
source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
(GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
}
if (!dest_row)
{
- g_object_set_data_full (G_OBJECT (context), g_intern_static_string ("gtk-tree-view-dest-row"),
+ g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
NULL, NULL);
return;
}
dr->empty_view_drop = empty_view_drop;
dr->drop_append_mode = drop_append_mode;
- g_object_set_data_full (G_OBJECT (context), g_intern_static_string ("gtk-tree-view-dest-row"),
+ g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
dr, (GDestroyNotify) dest_row_free);
}
GdkDragAction suggested_action)
{
g_object_set_data (G_OBJECT (context),
- g_intern_static_string ("gtk-tree-view-status-pending"),
+ I_("gtk-tree-view-status-pending"),
GINT_TO_POINTER (suggested_action));
}
di = g_new0 (TreeViewDragInfo, 1);
g_object_set_data_full (G_OBJECT (tree_view),
- g_intern_static_string ("gtk-tree-view-drag-info"),
+ I_("gtk-tree-view-drag-info"),
di,
(GDestroyNotify) destroy_info);
}
static void
remove_info (GtkTreeView *tree_view)
{
- g_object_set_data (G_OBJECT (tree_view), g_intern_static_string ("gtk-tree-view-drag-info"), NULL);
+ g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
}
#if 0
};
tree_column_type =
- g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkTreeViewColumn"),
+ g_type_register_static (GTK_TYPE_OBJECT, I_("GtkTreeViewColumn"),
&tree_column_info, 0);
g_type_add_interface_static (tree_column_type,
object_class->get_property = gtk_tree_view_column_get_property;
tree_column_signals[CLICKED] =
- g_signal_new ("clicked",
+ g_signal_new (I_("clicked"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTreeViewColumnClass, clicked),
#include "gtktypeutils.h"
#include "gtkobject.h"
+#include "gtkintl.h"
#include "gtkalias.h"
if (our_type == 0)
{
GTypeInfo tinfo = { 0, };
- our_type = g_type_register_static (G_TYPE_STRING, "GtkIdentifier", &tinfo, 0);
+ our_type = g_type_register_static (G_TYPE_STRING, I_("GtkIdentifier"), &tinfo, 0);
}
return our_type;
};
type = g_type_register_static (G_TYPE_OBJECT,
- g_intern_static_string ("GtkUIManager"),
+ I_("GtkUIManager"),
&type_info, 0);
}
return type;
* Since: 2.4
*/
ui_manager_signals[ADD_WIDGET] =
- g_signal_new ("add_widget",
+ g_signal_new (I_("add_widget"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, add_widget),
* Since: 2.4
*/
ui_manager_signals[ACTIONS_CHANGED] =
- g_signal_new ("actions_changed",
+ g_signal_new (I_("actions_changed"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, actions_changed),
* Since: 2.4
*/
ui_manager_signals[CONNECT_PROXY] =
- g_signal_new ("connect_proxy",
+ g_signal_new (I_("connect_proxy"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, connect_proxy),
* Since: 2.4
*/
ui_manager_signals[DISCONNECT_PROXY] =
- g_signal_new ("disconnect_proxy",
+ g_signal_new (I_("disconnect_proxy"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, disconnect_proxy),
* Since: 2.4
*/
ui_manager_signals[PRE_ACTIVATE] =
- g_signal_new ("pre_activate",
+ g_signal_new (I_("pre_activate"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, pre_activate),
* Since: 2.4
*/
ui_manager_signals[POST_ACTIVATE] =
- g_signal_new ("post_activate",
+ g_signal_new (I_("post_activate"),
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (GtkUIManagerClass, post_activate),
gtk_menu_shell_append (GTK_MENU_SHELL (menu), tearoff);
filler = gtk_menu_item_new_with_label (_("Empty"));
g_object_set_data (G_OBJECT (filler),
- g_intern_static_string ("gtk-empty-menu-item"),
+ I_("gtk-empty-menu-item"),
GINT_TO_POINTER (TRUE));
gtk_widget_set_sensitive (filler, FALSE);
gtk_widget_set_no_show_all (filler, TRUE);
g_object_ref (info->proxy);
gtk_object_sink (GTK_OBJECT (info->proxy));
g_object_set_data (G_OBJECT (info->proxy),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (SEPARATOR_MODE_HIDDEN));
gtk_widget_set_no_show_all (info->proxy, TRUE);
gtk_menu_shell_insert (GTK_MENU_SHELL (menushell),
g_object_ref (info->extra);
gtk_object_sink (GTK_OBJECT (info->extra));
g_object_set_data (G_OBJECT (info->extra),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (SEPARATOR_MODE_HIDDEN));
gtk_widget_set_no_show_all (info->extra, TRUE);
gtk_menu_shell_insert (GTK_MENU_SHELL (menushell),
g_object_ref (info->proxy);
gtk_object_sink (GTK_OBJECT (info->proxy));
g_object_set_data (G_OBJECT (info->proxy),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (SEPARATOR_MODE_HIDDEN));
gtk_widget_set_no_show_all (info->proxy, TRUE);
g_object_ref (info->extra);
gtk_object_sink (GTK_OBJECT (info->extra));
g_object_set_data (G_OBJECT (info->extra),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (SEPARATOR_MODE_HIDDEN));
gtk_widget_set_no_show_all (info->extra, TRUE);
}
separator_mode = SEPARATOR_MODE_SMART;
g_object_set_data (G_OBJECT (info->proxy),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (separator_mode));
gtk_widget_show (info->proxy);
}
gtk_object_sink (GTK_OBJECT (info->proxy));
gtk_widget_set_no_show_all (info->proxy, TRUE);
g_object_set_data (G_OBJECT (info->proxy),
- g_intern_static_string ("gtk-separator-mode"),
+ I_("gtk-separator-mode"),
GINT_TO_POINTER (SEPARATOR_MODE_SMART));
gtk_menu_shell_insert (GTK_MENU_SHELL (menushell),
info->proxy, pos);
#include <config.h>
#include "gtkvbbox.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
vbutton_box_type =
- g_type_register_static (GTK_TYPE_BUTTON_BOX, g_intern_static_string ("GtkVButtonBox"),
+ g_type_register_static (GTK_TYPE_BUTTON_BOX, I_("GtkVButtonBox"),
&vbutton_box_info, 0);
}
#include <config.h>
#include "gtkvbox.h"
+#include "gtkintl.h"
#include "gtkalias.h"
(GInstanceInitFunc) gtk_vbox_init,
};
- vbox_type = g_type_register_static (GTK_TYPE_BOX, g_intern_static_string ("GtkVBox"),
+ vbox_type = g_type_register_static (GTK_TYPE_BOX, I_("GtkVBox"),
&vbox_info, 0);
}
(GInstanceInitFunc) gtk_viewport_init,
};
- viewport_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkViewport"),
+ viewport_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkViewport"),
&viewport_info, 0);
}
GTK_PARAM_READWRITE));
widget_class->set_scroll_adjustments_signal =
- g_signal_new ("set_scroll_adjustments",
+ g_signal_new (I_("set_scroll_adjustments"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkViewportClass, set_scroll_adjustments),
#include <config.h>
#include "gtkvpaned.h"
+#include "gtkintl.h"
#include "gtkalias.h"
static void gtk_vpaned_class_init (GtkVPanedClass *klass);
(GInstanceInitFunc) gtk_vpaned_init,
};
- vpaned_type = g_type_register_static (GTK_TYPE_PANED, g_intern_static_string ("GtkVPaned"),
+ vpaned_type = g_type_register_static (GTK_TYPE_PANED, I_("GtkVPaned"),
&vpaned_info, 0);
}
#include <math.h>
#include <string.h>
#include "gtkvruler.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include <glib/gprintf.h>
(GInstanceInitFunc) gtk_vruler_init,
};
- vruler_type = g_type_register_static (GTK_TYPE_RULER, g_intern_static_string ("GtkVRuler"),
+ vruler_type = g_type_register_static (GTK_TYPE_RULER, I_("GtkVRuler"),
&vruler_info, 0);
}
(GInstanceInitFunc) gtk_vscale_init,
};
- vscale_type = g_type_register_static (GTK_TYPE_SCALE, g_intern_static_string ("GtkVScale"),
+ vscale_type = g_type_register_static (GTK_TYPE_SCALE, I_("GtkVScale"),
&vscale_info, 0);
}
};
vscrollbar_type =
- g_type_register_static (GTK_TYPE_SCROLLBAR, g_intern_static_string ("GtkVScrollbar"),
+ g_type_register_static (GTK_TYPE_SCROLLBAR, I_("GtkVScrollbar"),
&vscrollbar_info, 0);
}
#include <config.h>
#include "gtkvseparator.h"
+#include "gtkintl.h"
#include "gtkalias.h"
};
vseparator_type =
- g_type_register_static (GTK_TYPE_SEPARATOR, g_intern_static_string ("GtkVSeparator"),
+ g_type_register_static (GTK_TYPE_SEPARATOR, I_("GtkVSeparator"),
&vseparator_info, 0);
}
NULL /* interface data */
};
- widget_type = g_type_register_static (GTK_TYPE_OBJECT, g_intern_static_string ("GtkWidget"),
+ widget_type = g_type_register_static (GTK_TYPE_OBJECT, I_("GtkWidget"),
&widget_info, G_TYPE_FLAG_ABSTRACT);
g_type_add_interface_static (widget_type, ATK_TYPE_IMPLEMENTOR,
FALSE,
GTK_PARAM_READWRITE));
widget_signals[SHOW] =
- g_signal_new ("show",
+ g_signal_new (I_("show"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, show),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[HIDE] =
- g_signal_new ("hide",
+ g_signal_new (I_("hide"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, hide),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[MAP] =
- g_signal_new ("map",
+ g_signal_new (I_("map"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, map),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[UNMAP] =
- g_signal_new ("unmap",
+ g_signal_new (I_("unmap"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, unmap),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[REALIZE] =
- g_signal_new ("realize",
+ g_signal_new (I_("realize"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, realize),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[UNREALIZE] =
- g_signal_new ("unrealize",
+ g_signal_new (I_("unrealize"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, unrealize),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[SIZE_REQUEST] =
- g_signal_new ("size_request",
+ g_signal_new (I_("size_request"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, size_request),
G_TYPE_NONE, 1,
GTK_TYPE_REQUISITION | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SIZE_ALLOCATE] =
- g_signal_new ("size_allocate",
+ g_signal_new (I_("size_allocate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, size_allocate),
G_TYPE_NONE, 1,
GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[STATE_CHANGED] =
- g_signal_new ("state_changed",
+ g_signal_new (I_("state_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, state_changed),
G_TYPE_NONE, 1,
GTK_TYPE_STATE_TYPE);
widget_signals[PARENT_SET] =
- g_signal_new ("parent_set",
+ g_signal_new (I_("parent_set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, parent_set),
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
widget_signals[HIERARCHY_CHANGED] =
- g_signal_new ("hierarchy_changed",
+ g_signal_new (I_("hierarchy_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, hierarchy_changed),
* gtk_widget_modify_base() also cause this signal to be emitted.
*/
widget_signals[STYLE_SET] =
- g_signal_new ("style_set",
+ g_signal_new (I_("style_set"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, style_set),
G_TYPE_NONE, 1,
GTK_TYPE_STYLE);
widget_signals[DIRECTION_CHANGED] =
- g_signal_new ("direction_changed",
+ g_signal_new (I_("direction_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, direction_changed),
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_DIRECTION);
widget_signals[GRAB_NOTIFY] =
- g_signal_new ("grab_notify",
+ g_signal_new (I_("grab_notify"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWidgetClass, grab_notify),
* changed on an object. The signal's detail holds the property name.
*/
widget_signals[CHILD_NOTIFY] =
- g_signal_new ("child_notify",
+ g_signal_new (I_("child_notify"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (GtkWidgetClass, child_notify),
G_TYPE_NONE, 1,
G_TYPE_PARAM);
widget_signals[MNEMONIC_ACTIVATE] =
- g_signal_new ("mnemonic_activate",
+ g_signal_new (I_("mnemonic_activate"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, mnemonic_activate),
G_TYPE_BOOLEAN, 1,
G_TYPE_BOOLEAN);
widget_signals[GRAB_FOCUS] =
- g_signal_new ("grab_focus",
+ g_signal_new (I_("grab_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, grab_focus),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
widget_signals[FOCUS] =
- g_signal_new ("focus",
+ g_signal_new (I_("focus"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus),
G_TYPE_BOOLEAN, 1,
GTK_TYPE_DIRECTION_TYPE);
widget_signals[EVENT] =
- g_signal_new ("event",
+ g_signal_new (I_("event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[EVENT_AFTER] =
- g_signal_new ("event-after",
+ g_signal_new (I_("event-after"),
G_TYPE_FROM_CLASS (gobject_class),
0,
0,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[BUTTON_PRESS_EVENT] =
- g_signal_new ("button_press_event",
+ g_signal_new (I_("button_press_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, button_press_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[BUTTON_RELEASE_EVENT] =
- g_signal_new ("button_release_event",
+ g_signal_new (I_("button_release_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, button_release_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SCROLL_EVENT] =
- g_signal_new ("scroll_event",
+ g_signal_new (I_("scroll_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, scroll_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[MOTION_NOTIFY_EVENT] =
- g_signal_new ("motion_notify_event",
+ g_signal_new (I_("motion_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, motion_notify_event),
* %FALSE to propagate the event further.
*/
widget_signals[DELETE_EVENT] =
- g_signal_new ("delete_event",
+ g_signal_new (I_("delete_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, delete_event),
* %FALSE to propagate the event further.
*/
widget_signals[DESTROY_EVENT] =
- g_signal_new ("destroy_event",
+ g_signal_new (I_("destroy_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, destroy_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[EXPOSE_EVENT] =
- g_signal_new ("expose_event",
+ g_signal_new (I_("expose_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, expose_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[KEY_PRESS_EVENT] =
- g_signal_new ("key_press_event",
+ g_signal_new (I_("key_press_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, key_press_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[KEY_RELEASE_EVENT] =
- g_signal_new ("key_release_event",
+ g_signal_new (I_("key_release_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, key_release_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[ENTER_NOTIFY_EVENT] =
- g_signal_new ("enter_notify_event",
+ g_signal_new (I_("enter_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, enter_notify_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[LEAVE_NOTIFY_EVENT] =
- g_signal_new ("leave_notify_event",
+ g_signal_new (I_("leave_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, leave_notify_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[CONFIGURE_EVENT] =
- g_signal_new ("configure_event",
+ g_signal_new (I_("configure_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, configure_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[FOCUS_IN_EVENT] =
- g_signal_new ("focus_in_event",
+ g_signal_new (I_("focus_in_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus_in_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[FOCUS_OUT_EVENT] =
- g_signal_new ("focus_out_event",
+ g_signal_new (I_("focus_out_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus_out_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[MAP_EVENT] =
- g_signal_new ("map_event",
+ g_signal_new (I_("map_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, map_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[UNMAP_EVENT] =
- g_signal_new ("unmap_event",
+ g_signal_new (I_("unmap_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, unmap_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[PROPERTY_NOTIFY_EVENT] =
- g_signal_new ("property_notify_event",
+ g_signal_new (I_("property_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, property_notify_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_CLEAR_EVENT] =
- g_signal_new ("selection_clear_event",
+ g_signal_new (I_("selection_clear_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_clear_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_REQUEST_EVENT] =
- g_signal_new ("selection_request_event",
+ g_signal_new (I_("selection_request_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_request_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_NOTIFY_EVENT] =
- g_signal_new ("selection_notify_event",
+ g_signal_new (I_("selection_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_notify_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[SELECTION_RECEIVED] =
- g_signal_new ("selection_received",
+ g_signal_new (I_("selection_received"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_received),
GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_UINT);
widget_signals[SELECTION_GET] =
- g_signal_new ("selection_get",
+ g_signal_new (I_("selection_get"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, selection_get),
G_TYPE_UINT,
G_TYPE_UINT);
widget_signals[PROXIMITY_IN_EVENT] =
- g_signal_new ("proximity_in_event",
+ g_signal_new (I_("proximity_in_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, proximity_in_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[PROXIMITY_OUT_EVENT] =
- g_signal_new ("proximity_out_event",
+ g_signal_new (I_("proximity_out_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, proximity_out_event),
* undo highlighting with gtk_drag_unhighlight()
*/
widget_signals[DRAG_LEAVE] =
- g_signal_new ("drag_leave",
+ g_signal_new (I_("drag_leave"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_leave),
* gtk_drag_source_set_icon().
*/
widget_signals[DRAG_BEGIN] =
- g_signal_new ("drag_begin",
+ g_signal_new (I_("drag_begin"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_begin),
* A typical reason to connect to this signal is to undo things done in ::drag-begin.
*/
widget_signals[DRAG_END] =
- g_signal_new ("drag_end",
+ g_signal_new (I_("drag_end"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_end),
* operation.
*/
widget_signals[DRAG_DATA_DELETE] =
- g_signal_new ("drag_data_delete",
+ g_signal_new (I_("drag_data_delete"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_delete),
* </programlisting></informalexample>
*/
widget_signals[DRAG_MOTION] =
- g_signal_new ("drag_motion",
+ g_signal_new (I_("drag_motion"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_motion),
* supported targets.
*/
widget_signals[DRAG_DROP] =
- g_signal_new ("drag_drop",
+ g_signal_new (I_("drag_drop"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_drop),
* gtk_selection_data_set_text().
*/
widget_signals[DRAG_DATA_GET] =
- g_signal_new ("drag_data_get",
+ g_signal_new (I_("drag_data_get"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_get),
* </programlisting></informalexample>
*/
widget_signals[DRAG_DATA_RECEIVED] =
- g_signal_new ("drag_data_received",
+ g_signal_new (I_("drag_data_received"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, drag_data_received),
G_TYPE_UINT,
G_TYPE_UINT);
widget_signals[VISIBILITY_NOTIFY_EVENT] =
- g_signal_new ("visibility_notify_event",
+ g_signal_new (I_("visibility_notify_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, visibility_notify_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[CLIENT_EVENT] =
- g_signal_new ("client_event",
+ g_signal_new (I_("client_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, client_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[NO_EXPOSE_EVENT] =
- g_signal_new ("no_expose_event",
+ g_signal_new (I_("no_expose_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, no_expose_event),
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
widget_signals[WINDOW_STATE_EVENT] =
- g_signal_new ("window_state_event",
+ g_signal_new (I_("window_state_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, window_state_event),
* Since: 2.8
*/
widget_signals[GRAB_BROKEN] =
- g_signal_new ("grab_broken_event",
+ g_signal_new (I_("grab_broken_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, grab_broken_event),
* example of how to use this signal.
*/
widget_signals[POPUP_MENU] =
- g_signal_new ("popup_menu",
+ g_signal_new (I_("popup_menu"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, popup_menu),
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
widget_signals[SHOW_HELP] =
- g_signal_new ("show_help",
+ g_signal_new (I_("show_help"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWidgetClass, show_help),
G_TYPE_BOOLEAN, 1,
GTK_TYPE_WIDGET_HELP_TYPE);
widget_signals[ACCEL_CLOSURES_CHANGED] =
- g_signal_new ("accel_closures_changed",
+ g_signal_new (I_("accel_closures_changed"),
G_TYPE_FROM_CLASS (gobject_class),
0,
0,
_gtk_marshal_NONE__NONE,
G_TYPE_NONE, 0);
widget_signals[SCREEN_CHANGED] =
- g_signal_new ("screen_changed",
+ g_signal_new (I_("screen_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, screen_changed),
* for determining whether an accelerator can be activated.
*/
widget_signals[CAN_ACTIVATE_ACCEL] =
- g_signal_new ("can_activate_accel",
+ g_signal_new (I_("can_activate_accel"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, can_activate_accel),
static GType our_type = 0;
if (our_type == 0)
- our_type = g_boxed_type_register_static (g_intern_static_string ("GtkRequisition"),
+ our_type = g_boxed_type_register_static (I_("GtkRequisition"),
(GBoxedCopyFunc) gtk_requisition_copy,
(GBoxedFreeFunc) gtk_requisition_free);
deco->maximizable = FALSE;
deco->real_inner_move = FALSE;
- g_object_set_data_full (G_OBJECT (window), g_intern_static_string ("gtk-window-decoration"), deco,
+ g_object_set_data_full (G_OBJECT (window), I_("gtk-window-decoration"), deco,
(GDestroyNotify) gtk_decoration_free);
gtk_window_set_has_frame (window, TRUE);
(GInstanceInitFunc) gtk_window_init,
};
- window_type = g_type_register_static (GTK_TYPE_BIN, g_intern_static_string ("GtkWindow"),
+ window_type = g_type_register_static (GTK_TYPE_BIN, I_("GtkWindow"),
&window_info, 0);
}
GTK_PARAM_READWRITE));
window_signals[SET_FOCUS] =
- g_signal_new ("set_focus",
+ g_signal_new (I_("set_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWindowClass, set_focus),
GTK_TYPE_WIDGET);
window_signals[FRAME_EVENT] =
- g_signal_new ("frame_event",
+ g_signal_new (I_("frame_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkWindowClass, frame_event),
GDK_TYPE_EVENT);
window_signals[ACTIVATE_FOCUS] =
- g_signal_new ("activate_focus",
+ g_signal_new (I_("activate_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, activate_focus),
0);
window_signals[ACTIVATE_DEFAULT] =
- g_signal_new ("activate_default",
+ g_signal_new (I_("activate_default"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, activate_default),
0);
window_signals[MOVE_FOCUS] =
- g_signal_new ("move_focus",
+ g_signal_new (I_("move_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, move_focus),
GTK_TYPE_DIRECTION_TYPE);
window_signals[KEYS_CHANGED] =
- g_signal_new ("keys_changed",
+ g_signal_new (I_("keys_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWindowClass, keys_changed),
embedded_windows = g_list_prepend (embedded_windows,
GUINT_TO_POINTER (xid));
- g_object_set_data_full (G_OBJECT (window), g_intern_static_string ("gtk-embedded"),
+ g_object_set_data_full (G_OBJECT (window), I_("gtk-embedded"),
embedded_windows,
embedded_windows ?
(GDestroyNotify) g_list_free : NULL);
g_list_free_1 (node);
}
- g_object_set_data_full (G_OBJECT (window), g_intern_static_string ("gtk-embedded"),
+ g_object_set_data_full (G_OBJECT (window), I_("gtk-embedded"),
embedded_windows,
embedded_windows ?
(GDestroyNotify) g_list_free : NULL);
{
info = g_new0 (GtkWindowIconInfo, 1);
g_object_set_data_full (G_OBJECT (window),
- g_intern_static_string ("gtk-window-icon-info"),
+ I_("gtk-window-icon-info"),
info,
(GDestroyNotify)free_icon_info);
}
if (!info)
{
info = g_new0 (ScreenIconInfo, 1);
- g_object_set_data (G_OBJECT (screen), g_intern_static_string ("gtk-window-default-icon-pixmap"), info);
+ g_object_set_data (G_OBJECT (screen), I_("gtk-window-default-icon-pixmap"), info);
}
if (info->serial != default_icon_serial)
(GInstanceInitFunc) NULL,
};
- window_group_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GtkWindowGroup"),
+ window_group_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkWindowGroup"),
&window_group_info, 0);
}
key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (screen)),
(GDestroyNotify)g_free);
_gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
- g_object_set_data (G_OBJECT (window), g_intern_static_string ("gtk-window-key-hash"), key_hash);
+ g_object_set_data (G_OBJECT (window), I_("gtk-window-key-hash"), key_hash);
return key_hash;
}
projects / ~andy / gtk / commitdiff