2005-03-21 Matthias Clasen <mclasen@redhat.com>
+ * gtk/gtkprivate.h: Define macros GTK_PARAM_READABLE,
+ GTK_PARAM_WRITABLE, GTK_PARAM_READWRITE which are like
+ their G_ counterparts, but also mark the name, nick
+ and blurb as static.
+
+ * gtk/*.c: Mark param spec strings as static, using
+ the new macros.
+
* gtk/gtkspinbutton.h: Fix a typo.
2005-03-21 Matthias Clasen <mclasen@redhat.com>
2005-03-21 Matthias Clasen <mclasen@redhat.com>
+ * gtk/gtkprivate.h: Define macros GTK_PARAM_READABLE,
+ GTK_PARAM_WRITABLE, GTK_PARAM_READWRITE which are like
+ their G_ counterparts, but also mark the name, nick
+ and blurb as static.
+
+ * gtk/*.c: Mark param spec strings as static, using
+ the new macros.
+
* gtk/gtkspinbutton.h: Fix a typo.
2005-03-21 Matthias Clasen <mclasen@redhat.com>
2005-03-21 Matthias Clasen <mclasen@redhat.com>
+ * gtk/gtkprivate.h: Define macros GTK_PARAM_READABLE,
+ GTK_PARAM_WRITABLE, GTK_PARAM_READWRITE which are like
+ their G_ counterparts, but also mark the name, nick
+ and blurb as static.
+
+ * gtk/*.c: Mark param spec strings as static, using
+ the new macros.
+
* gtk/gtkspinbutton.h: Fix a typo.
2005-03-21 Matthias Clasen <mclasen@redhat.com>
#include "gtkvbox.h"
#include "gtkviewport.h"
#include "gtkiconfactory.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
widget_class->style_set = gtk_about_dialog_style_set;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
/**
* GtkAboutDialog:name:
*
P_("Program name"),
P_("The name of the program. If this is not set, it defaults to g_get_application_name()"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:version:
P_("Program version"),
P_("The version of the program"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:copyright:
P_("Copyright string"),
P_("Copyright information for the program"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
P_("Comments string"),
P_("Comments about the program"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:license:
_("License"),
_("The license of the program"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:website:
P_("Website URL"),
P_("The URL for the link to the website of the program"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:website-label:
P_("Website label"),
P_("The label for the link to the website of the program. If this is not set, it defaults to the URL"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:authors:
P_("Authors"),
P_("List of authors of the program"),
G_TYPE_STRV,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:documenters:
P_("Documenters"),
P_("List of people documenting the program"),
G_TYPE_STRV,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:artists:
P_("Artists"),
P_("List of people who have contributed artwork to the program"),
G_TYPE_STRV,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
P_("Translator credits"),
P_("Credits to the translators. This string should be marked as translatable"),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:logo:
P_("Logo"),
P_("A logo for the about box. If this is not set, it defaults to gtk_window_get_default_icon_list()"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAboutDialog:logo-icon-name:
P_("Logo Icon Name"),
P_("A named icon to use as the logo for the about box."),
NULL,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/* Style properties */
gtk_widget_class_install_style_property (widget_class,
P_("Link Color"),
P_("Color of hyperlinks"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE|STATIC_STRINGS));
+ GTK_PARAM_READABLE));
g_type_class_add_private (object_class, sizeof (GtkAboutDialogPrivate));
}
#include "gtkaccellabel.h"
#include "gtkaccelmap.h"
#include "gtkmain.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
class->accel_seperator = g_strdup (" / ");
class->latin1_to_char = TRUE;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_ACCEL_CLOSURE,
g_param_spec_boxed ("accel-closure",
P_("Accelerator Closure"),
P_("The closure to be monitored for accelerator changes"),
G_TYPE_CLOSURE,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACCEL_WIDGET,
g_param_spec_object ("accel-widget",
P_("Accelerator Widget"),
P_("The widget to be monitored for accelerator changes"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE|STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtktearoffmenuitem.h"
#include "gtktoolbutton.h"
#include "gtktoolbar.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
klass->menu_item_type = GTK_TYPE_IMAGE_MENU_ITEM;
klass->toolbar_item_type = GTK_TYPE_TOOL_BUTTON;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_NAME,
g_param_spec_string ("name",
P_("Name"),
P_("A unique name for the action."),
NULL,
- G_PARAM_READWRITE |
- G_PARAM_CONSTRUCT_ONLY | STATIC_STRINGS));
+ GTK_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (gobject_class,
PROP_LABEL,
g_param_spec_string ("label",
P_("The label used for menu items and buttons "
"that activate this action."),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHORT_LABEL,
g_param_spec_string ("short-label",
P_("Short label"),
P_("A shorter label that may be used on toolbar buttons."),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TOOLTIP,
g_param_spec_string ("tooltip",
P_("Tooltip"),
P_("A tooltip for this action."),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_STOCK_ID,
g_param_spec_string ("stock-id",
P_("The stock icon displayed in widgets representing "
"this action."),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBLE_HORIZONTAL,
g_param_spec_boolean ("visible-horizontal",
P_("Whether the toolbar item is visible when the toolbar "
"is in a horizontal orientation."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAction:visible-overflown:
*
P_("When TRUE, toolitem proxies for this action "
"are represented in the toolbar overflow menu."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBLE_VERTICAL,
g_param_spec_boolean ("visible-vertical",
P_("Whether the toolbar item is visible when the toolbar "
"is in a vertical orientation."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_IS_IMPORTANT,
g_param_spec_boolean ("is-important",
"When TRUE, toolitem proxies for this action "
"show text in GTK_TOOLBAR_BOTH_HORIZ mode."),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HIDE_IF_EMPTY,
g_param_spec_boolean ("hide-if-empty",
P_("Hide if empty"),
P_("When TRUE, empty menu proxies for this action are hidden."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SENSITIVE,
g_param_spec_boolean ("sensitive",
P_("Sensitive"),
P_("Whether the action is enabled."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBLE,
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether the action is visible."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACTION_GROUP,
g_param_spec_object ("action-group",
P_("Action Group"),
P_("The GtkActionGroup this GtkAction is associated with, or NULL (for internal use)."),
GTK_TYPE_ACTION_GROUP,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAction::activate:
#include "gtkradioaction.h"
#include "gtkaccelmap.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
gobject_class->get_property = gtk_action_group_get_property;
klass->get_action = gtk_action_group_real_get_action;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_NAME,
g_param_spec_string ("name",
P_("Name"),
P_("A name for the action group."),
NULL,
- G_PARAM_READWRITE |
- G_PARAM_CONSTRUCT_ONLY | STATIC_STRINGS));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (gobject_class,
PROP_SENSITIVE,
g_param_spec_boolean ("sensitive",
P_("Sensitive"),
P_("Whether the action group is enabled."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBLE,
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether the action group is visible."),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkActionGroup::connect-proxy:
#include <config.h>
#include "gtkadjustment.h"
-#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
enum
class->changed = NULL;
class->value_changed = NULL;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
/**
* GtkAdjustment:value:
*
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAdjustment:lower:
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAdjustment:upper:
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAdjustment:step-increment:
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAdjustment:page-increment:
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAdjustment:page-size:
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
adjustment_signals[CHANGED] =
#include <config.h>
#include "gtkalignment.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
widget_class->size_request = gtk_alignment_size_request;
widget_class->size_allocate = gtk_alignment_size_allocate;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_XALIGN,
g_param_spec_float("xalign",
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YALIGN,
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_XSCALE,
g_param_spec_float("xscale",
0.0,
1.0,
1.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YSCALE,
g_param_spec_float("yscale",
0.0,
1.0,
1.0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
0,
G_MAXINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAlignment:bottom-padding:
0,
G_MAXINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAlignment:left-padding:
0,
G_MAXINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkAlignment:right-padding:
0,
G_MAXINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (gobject_class, sizeof (GtkAlignmentPrivate));
}
#include <config.h>
#include <math.h>
#include "gtkarrow.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
gobject_class->set_property = gtk_arrow_set_property;
gobject_class->get_property = gtk_arrow_get_property;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_ARROW_TYPE,
g_param_spec_enum ("arrow-type",
P_("The direction the arrow should point"),
GTK_TYPE_ARROW_TYPE,
GTK_ARROW_RIGHT,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
g_param_spec_enum ("shadow-type",
P_("Appearance of the shadow surrounding the arrow"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_OUT,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
widget_class->expose_event = gtk_arrow_expose;
}
#include <config.h>
#include "gtkaspectframe.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
frame_class->compute_child_allocation = gtk_aspect_frame_compute_child_allocation;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_XALIGN,
g_param_spec_float ("xalign",
P_("Horizontal Alignment"),
P_("X alignment of the child"),
0.0, 1.0, 0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YALIGN,
g_param_spec_float ("yalign",
P_("Vertical Alignment"),
P_("Y alignment of the child"),
0.0, 1.0, 0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RATIO,
g_param_spec_float ("ratio",
P_("Ratio"),
P_("Aspect ratio if obey_child is FALSE"),
MIN_RATIO, MAX_RATIO, 0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_OBEY_CHILD,
g_param_spec_boolean ("obey-child",
P_("Obey child"),
P_("Force aspect ratio to match that of the frame's child"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
}
static void
#include <config.h>
#include "gtkbbox.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
/* FIXME we need to override the "spacing" property on GtkBox once
* libgobject allows that.
*/
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-min-width",
P_("Minimum child width"),
0,
G_MAXINT,
DEFAULT_CHILD_MIN_WIDTH,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-min-height",
0,
G_MAXINT,
DEFAULT_CHILD_MIN_HEIGHT,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-internal-pad-x",
0,
G_MAXINT,
DEFAULT_CHILD_IPAD_X,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-internal-pad-y",
0,
G_MAXINT,
DEFAULT_CHILD_IPAD_Y,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_LAYOUT_STYLE,
g_param_spec_enum ("layout-style",
P_("How to layout the buttons in the box. Possible values are default, spread, edge, start and end"),
GTK_TYPE_BUTTON_BOX_STYLE,
GTK_BUTTONBOX_DEFAULT_STYLE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_SECONDARY,
P_("Secondary"),
P_("If TRUE, the child appears in a secondary group of children, suitable for, e.g., help buttons"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
}
static void
#include <config.h>
#include "gtkbox.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
container_class->set_child_property = gtk_box_set_child_property;
container_class->get_child_property = gtk_box_get_child_property;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_SPACING,
g_param_spec_int ("spacing",
0,
G_MAXINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HOMOGENEOUS,
P_("Homogeneous"),
P_("Whether the children should all be the same size"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_EXPAND,
P_("Expand"),
P_("Whether the child should receive extra space when the parent grows"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_FILL,
g_param_spec_boolean ("fill",
P_("Fill"),
P_("Whether extra space given to the child should be allocated to the child or used as padding"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_PADDING,
g_param_spec_uint ("padding",
P_("Padding"),
P_("Extra space to put between the child and its neighbors, in pixels"),
0, G_MAXINT, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_PACK_TYPE,
g_param_spec_enum ("pack-type",
P_("Pack type"),
P_("A GtkPackType indicating whether the child is packed with reference to the start or end of the parent"),
GTK_TYPE_PACK_TYPE, GTK_PACK_START,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_POSITION,
g_param_spec_int ("position",
P_("Position"),
P_("The index of the child in the parent"),
-1, G_MAXINT, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtkhbox.h"
#include "gtkstock.h"
#include "gtkiconfactory.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
klass->leave = gtk_button_update_state;
klass->activate = gtk_real_button_activate;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_LABEL,
g_param_spec_string ("label",
P_("Label"),
P_("Text of the label widget inside the button, if the button contains a label widget"),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_USE_UNDERLINE,
P_("Use underline"),
P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_USE_STOCK,
P_("Use stock"),
P_("If set, the label is used to pick a stock item instead of being displayed"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_FOCUS_ON_CLICK,
P_("Focus on click"),
P_("Whether the button grabs focus when it is clicked with the mouse"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RELIEF,
P_("The border relief style"),
GTK_TYPE_RELIEF_STYLE,
GTK_RELIEF_NORMAL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkButton:xalign:
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkButton:yalign:
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkButton::image:
P_("Image widget"),
P_("Child widget to appear next to the button text"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
button_signals[PRESSED] =
g_signal_new ("pressed",
P_("Default Spacing"),
P_("Extra space to add for CAN_DEFAULT buttons"),
GTK_TYPE_BORDER,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boxed ("default-outside-border",
P_("Default Outside Spacing"),
P_("Extra space to add for CAN_DEFAULT buttons that is always drawn outside the border"),
GTK_TYPE_BORDER,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-displacement-x",
P_("Child X Displacement"),
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("child-displacement-y",
P_("Child Y Displacement"),
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
/**
* GtkButton:displace-focus:
P_("Displace focus"),
P_("Whether the child_displacement_x/_y properties should also affect the focus rectangle"),
FALSE,
- G_PARAM_READABLE | STATIC_STRINGS));
+ GTK_PARAM_READABLE));
gtk_settings_install_property (g_param_spec_boolean ("gtk-button-images",
P_("Show button images"),
P_("Whether stock icons should be shown in buttons"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (gobject_class, sizeof (GtkButtonPrivate));
}
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gdk/gdkkeysyms.h"
#include "gtkalias.h"
class->prev_year = NULL;
class->next_year = NULL;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (gobject_class,
PROP_YEAR,
g_param_spec_int ("year",
P_("Year"),
P_("The selected year"),
0, G_MAXINT, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MONTH,
g_param_spec_int ("month",
P_("Month"),
P_("The selected month (as a number between 0 and 11)"),
0, 11, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DAY,
g_param_spec_int ("day",
P_("Day"),
P_("The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day)"),
0, 31, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCalendar:show-heading:
P_("Show Heading"),
P_("If TRUE, a heading is displayed"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCalendar:show-day-names:
P_("Show Day Names"),
P_("If TRUE, day names are displayed"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCalendar:no-month-change:
*
P_("No Month Change"),
P_("If TRUE, the selected month cannot be changed"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCalendar:show-week-numbers:
P_("Show Week Numbers"),
P_("If TRUE, week numbers are displayed"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
g_signal_new ("month_changed",
#include "gtkcellrenderer.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtktreeprivate.h"
#include "gtkalias.h"
GTK_TYPE_CELL_EDITABLE,
G_TYPE_STRING);
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (object_class,
PROP_MODE,
g_param_spec_enum ("mode",
P_("Editable mode of the CellRenderer"),
GTK_TYPE_CELL_RENDERER_MODE,
GTK_CELL_RENDERER_MODE_INERT,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_VISIBLE,
P_("visible"),
P_("Display the cell"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SENSITIVE,
g_param_spec_boolean ("sensitive",
P_("Sensitive"),
P_("Display the cell sensitive"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_XALIGN,
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_YALIGN,
0.0,
1.0,
0.5,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_XPAD,
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_YPAD,
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WIDTH,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_HEIGHT,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_IS_EXPANDER,
P_("Is Expander"),
P_("Row has children"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Is Expanded"),
P_("Row is an expander row, and is expanded"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_CELL_BACKGROUND,
P_("Cell background color name"),
P_("Cell background color as a string"),
NULL,
- G_PARAM_WRITABLE | STATIC_STRINGS));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_CELL_BACKGROUND_GDK,
P_("Cell background color"),
P_("Cell background color as a GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
-#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READWRITE | STATIC_STRINGS))
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
P_("Cell background set"),
#include "gtkcellrenderertext.h"
#include "gtkcombobox.h"
#include "gtkcomboboxentry.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
static void gtk_cell_renderer_combo_class_init (GtkCellRendererComboClass *klass);
cell_class->start_editing = gtk_cell_renderer_combo_start_editing;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
/**
* GtkCellRendererCombo:model:
*
P_("Model"),
P_("The model containing the possible values for the combo box"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererCombo:text-column:
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererCombo:has-entry:
P_("Has Entry"),
P_("If FALSE, don't allow to enter strings other than the chosen ones"),
TRUE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
}
#include "gtkcellrendererpixbuf.h"
#include "gtkiconfactory.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
static void gtk_cell_renderer_pixbuf_get_property (GObject *object,
cell_class->get_size = gtk_cell_renderer_pixbuf_get_size;
cell_class->render = gtk_cell_renderer_pixbuf_render;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
g_object_class_install_property (object_class,
PROP_PIXBUF,
g_param_spec_object ("pixbuf",
P_("Pixbuf Object"),
P_("The pixbuf to render"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_PIXBUF_EXPANDER_OPEN,
P_("Pixbuf Expander Open"),
P_("Pixbuf for open expander"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_PIXBUF_EXPANDER_CLOSED,
P_("Pixbuf Expander Closed"),
P_("Pixbuf for closed expander"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_ID,
P_("Stock ID"),
P_("The stock ID of the stock icon to render"),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_SIZE,
0,
G_MAXUINT,
GTK_ICON_SIZE_MENU,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_DETAIL,
P_("Detail"),
P_("Render detail to pass to the theme engine"),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererPixbuf:follow-state:
P_("Whether the rendered pixbuf should be "
"colorized according to the state"),
FALSE,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class, sizeof (GtkCellRendererPixbufPrivate));
#include <stdlib.h>
#include "gtkcellrendererprogress.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
cell_class->get_size = gtk_cell_renderer_progress_get_size;
cell_class->render = gtk_cell_renderer_progress_render;
-#define STATIC_STRINGS G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
-
/**
* GtkCellRendererProgress:value:
*
P_("Value"),
P_("Value of the progress bar"),
0, 100, 0,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererProgress:text:
P_("Text"),
P_("Text on the progress bar"),
NULL,
- G_PARAM_READWRITE | STATIC_STRINGS));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class,
sizeof (GtkCellRendererProgressPrivate));
#include "gtkentry.h"
#include "gtkmarshalers.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtktreeprivate.h"
#include "gtkalias.h"
cell_class->get_size = gtk_cell_renderer_text_get_size;
cell_class->render = gtk_cell_renderer_text_render;
cell_class->start_editing = gtk_cell_renderer_text_start_editing;
-
+
g_object_class_install_property (object_class,
PROP_TEXT,
g_param_spec_string ("text",
P_("Text"),
P_("Text to render"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MARKUP,
P_("Markup"),
P_("Marked up text to render"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_ATTRIBUTES,
P_("Attributes"),
P_("A list of style attributes to apply to the text of the renderer"),
PANGO_TYPE_ATTR_LIST,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SINGLE_PARAGRAPH_MODE,
P_("Single Paragraph Mode"),
P_("Whether or not to keep all text in a single paragraph"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Background color name"),
P_("Background color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_BACKGROUND_GDK,
P_("Background color"),
P_("Background color as a GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FOREGROUND,
P_("Foreground color name"),
P_("Foreground color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_FOREGROUND_GDK,
P_("Foreground color"),
P_("Foreground color as a GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Editable"),
P_("Whether the text can be modified by the user"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FONT,
P_("Font"),
P_("Font description as a string"),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FONT_DESC,
P_("Font"),
P_("Font description as a PangoFontDescription struct"),
PANGO_TYPE_FONT_DESCRIPTION,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Font family"),
P_("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STYLE,
P_("Font style"),
PANGO_TYPE_STYLE,
PANGO_STYLE_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_VARIANT,
P_("Font variant"),
PANGO_TYPE_VARIANT,
PANGO_VARIANT_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WEIGHT,
0,
G_MAXINT,
PANGO_WEIGHT_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STRETCH,
P_("Font stretch"),
PANGO_TYPE_STRETCH,
PANGO_STRETCH_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZE,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZE_POINTS,
0.0,
G_MAXDOUBLE,
0.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SCALE,
0.0,
G_MAXDOUBLE,
1.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_RISE,
-G_MAXINT,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Strikethrough"),
P_("Whether to strike through the text"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_UNDERLINE,
P_("Style of underline for this text"),
PANGO_TYPE_UNDERLINE,
PANGO_UNDERLINE_NONE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LANGUAGE,
"Pango can use this as a hint when rendering the text. "
"If you don't understand this parameter, you probably don't need it"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
"to display the entire string, if at all"),
PANGO_TYPE_ELLIPSIZE_MODE,
PANGO_ELLIPSIZE_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererText:width-chars:
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererText:wrap-mode:
*
- * Specifies how to break the string into multiple lines, if the cell renderer
- * does not have enough room to display the entire string. This property has no
- * effect unless the wrap-width property is set.
+ * Specifies how to break the string into multiple lines, if the cell
+ * renderer does not have enough room to display the entire string.
+ * This property has no effect unless the wrap-width property is set.
*
* Since: 2.8
*/
"to display the entire string"),
PANGO_TYPE_WRAP_MODE,
PANGO_WRAP_CHAR,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkCellRendererText:wrap-width:
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/* Style props are set or not */
-#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE))
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
P_("Background set"),
#include "gtkcellrenderertoggle.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtktreeprivate.h"
#include "gtkalias.h"
P_("Toggle state"),
P_("The toggle state of the button"),
FALSE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_INCONSISTENT,
P_("Inconsistent state"),
P_("The inconsistent state of the button"),
FALSE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_ACTIVATABLE,
P_("Activatable"),
P_("The toggle button can be activated"),
TRUE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_RADIO,
P_("Radio state"),
P_("Draw the toggle button as a radio button"),
FALSE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
/**
#include "gtksignal.h"
#include "gtkcellrenderertext.h"
#include "gtkcellrendererpixbuf.h"
+#include "gtkprivate.h"
#include <gobject/gmarshal.h>
#include "gtkalias.h"
P_("Background color name"),
P_("Background color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_BACKGROUND_GDK,
g_param_spec_boxed ("background-gdk",
P_("Background color"),
P_("Background color as a GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
-#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE))
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (gobject_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
P_("Background set"),
#include <config.h>
#include "gtkcheckbutton.h"
-#include "gtkintl.h"
#include "gtklabel.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
0,
G_MAXINT,
INDICATOR_SIZE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("indicator-spacing",
P_("Indicator Spacing"),
0,
G_MAXINT,
INDICATOR_SPACING,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
#include <config.h>
#include "gtkcheckmenuitem.h"
#include "gtkaccellabel.h"
-#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
enum {
P_("Active"),
P_("Whether the menu item is checked"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_INCONSISTENT,
P_("Inconsistent"),
P_("Whether to display an \"inconsistent\" state"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DRAW_AS_RADIO,
P_("Draw as radio menu item"),
P_("Whether the menu item looks like a radio menu item"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("indicator-size",
0,
G_MAXINT,
12,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
widget_class->expose_event = gtk_check_menu_item_expose;
gtk_object_add_arg_type ("GtkCList::n-columns",
GTK_TYPE_UINT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME,
ARG_N_COLUMNS);
gtk_object_add_arg_type ("GtkCList::shadow-type",
GTK_TYPE_SHADOW_TYPE,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SHADOW_TYPE);
gtk_object_add_arg_type ("GtkCList::selection-mode",
GTK_TYPE_SELECTION_MODE,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SELECTION_MODE);
gtk_object_add_arg_type ("GtkCList::row-height",
GTK_TYPE_UINT,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_ROW_HEIGHT);
gtk_object_add_arg_type ("GtkCList::reorderable",
GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_REORDERABLE);
gtk_object_add_arg_type ("GtkCList::titles-active",
GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_TITLES_ACTIVE);
gtk_object_add_arg_type ("GtkCList::use-drag-icons",
GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_USE_DRAG_ICONS);
gtk_object_add_arg_type ("GtkCList::sort-type",
GTK_TYPE_SORT_TYPE,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SORT_TYPE);
widget_class->set_scroll_adjustments_signal =
#include "gtkframe.h"
#include "gtksignal.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
g_param_spec_boolean ("use-alpha", P_("Use alpha"),
P_("Whether or not to give the color an alpha value"),
FALSE,
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkColorButton:title:
P_("Title"),
P_("The title of the color selection dialog"),
_("Pick a Color"),
- (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkColorButton:color:
P_("Current Color"),
P_("The selected color"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
/**
* GtkColorButton:alpha:
P_("Current Alpha"),
P_("The selected opacity value (0 fully transparent, 65535 fully opaque)"),
0, 65535, 65535,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
/**
* GtkColorButton::color-set:
#include "gtkmenuitem.h"
#include "gtkmain.h"
#include "gtksettings.h"
-#include "gtkintl.h"
#include "gtkimage.h"
#include "gtkstock.h"
#include "gtkaccessible.h"
+#include "gtkprivate.h"
+#include "gtkintl.h"
#include "gtkalias.h"
#include <string.h>
P_("Has Opacity Control"),
P_("Whether the color selector should allow setting opacity"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HAS_PALETTE,
g_param_spec_boolean ("has-palette",
P_("Has palette"),
P_("Whether a palette should be used"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CURRENT_COLOR,
g_param_spec_boxed ("current-color",
P_("Current Color"),
P_("The current color"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CURRENT_ALPHA,
g_param_spec_uint ("current-alpha",
P_("Current Alpha"),
P_("The current opacity value (0 fully transparent, 65535 fully opaque)"),
0, 65535, 65535,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
color_selection_signals[COLOR_CHANGED] =
g_signal_new ("color_changed",
P_("Custom palette"),
P_("Palette to use in the color selector"),
default_colors,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
/* widget functions */
#include "gdk/gdkkeysyms.h"
#include "gtkcombo.h"
#include "gtkframe.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Enable arrow keys"),
P_("Whether the arrow keys move through the list of items"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ENABLE_ARROWS_ALWAYS,
g_param_spec_boolean ("enable-arrows-always",
P_("Always enable arrows"),
P_("Obsolete property, ignored"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CASE_SENSITIVE,
g_param_spec_boolean ("case-sensitive",
P_("Case sensitive"),
P_("Whether list item matching is case sensitive"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ALLOW_EMPTY,
P_("Allow empty"),
P_("Whether an empty value may be entered in this field"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VALUE_IN_LIST,
P_("Value in list"),
P_("Whether entered values must already be present in the list"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
oclass->destroy = gtk_combo_destroy;
#include "gtktreeselection.h"
#include "gtkvseparator.h"
#include "gtkwindow.h"
+#include "gtkprivate.h"
#include <gdk/gdkkeysyms.h>
P_("ComboBox model"),
P_("The model for the combo box"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkComboBox:wrap-width:
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkComboBox:add-tearoffs:
P_("Add tearoffs to menus"),
P_("Whether dropdowns should have a tearoff menu item"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkComboBox:has-frame:
P_("Has Frame"),
P_("Whether the combo box draws a frame around the child"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FOCUS_ON_CLICK,
P_("Focus on click"),
P_("Whether the combo box grabs focus when it is clicked with the mouse"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("appears-as-list",
P_("Appears as list"),
P_("Whether dropdowns should look like lists rather than menus"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_type_class_add_private (object_class, sizeof (GtkComboBoxPrivate));
}
#include "gtkentry.h"
#include "gtkcellrenderertext.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private ((GObjectClass *) klass,
sizeof (GtkComboBoxEntryPrivate));
P_("Specify how resize events are handled"),
GTK_TYPE_RESIZE_MODE,
GTK_RESIZE_PARENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_BORDER_WIDTH,
g_param_spec_uint ("border-width",
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CHILD,
g_param_spec_object ("child",
P_("Child"),
P_("Can be used to add a new child to the container"),
GTK_TYPE_WIDGET,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
container_signals[ADD] =
g_signal_new ("add",
G_OBJECT_CLASS_TYPE (object_class),
gtk_object_add_arg_type ("GtkCTree::n-columns", /* overrides GtkCList::n_columns!! */
GTK_TYPE_UINT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME,
ARG_N_COLUMNS);
gtk_object_add_arg_type ("GtkCTree::tree-column",
GTK_TYPE_UINT,
- GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
+ GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME,
ARG_TREE_COLUMN);
gtk_object_add_arg_type ("GtkCTree::indent",
GTK_TYPE_UINT,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_INDENT);
gtk_object_add_arg_type ("GtkCTree::spacing",
GTK_TYPE_UINT,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SPACING);
gtk_object_add_arg_type ("GtkCTree::show-stub",
GTK_TYPE_BOOL,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SHOW_STUB);
gtk_object_add_arg_type ("GtkCTree::line-style",
GTK_TYPE_CTREE_LINE_STYLE,
- GTK_ARG_READWRITE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_LINE_STYLE);
gtk_object_add_arg_type ("GtkCTree::expander-style",
- GTK_TYPE_CTREE_EXPANDER_STYLE,
- GTK_ARG_READWRITE,
+ GTK_TYPE_CTREE_EXPANDER_STYLE | G_PARAM_STATIC_NAME,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_EXPANDER_STYLE);
ctree_signals[TREE_SELECT_ROW] =
#include "gtkmarshalers.h"
#include "gtkradiobutton.h"
#include "gtktable.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Is this curve linear, spline interpolated, or free-form"),
GTK_TYPE_CURVE_TYPE,
GTK_CURVE_TYPE_LINEAR,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MIN_X,
g_param_spec_float ("min-x",
-G_MAXFLOAT,
G_MAXFLOAT,
0.0,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MAX_X,
g_param_spec_float ("max-x",
-G_MAXFLOAT,
G_MAXFLOAT,
1.0,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MIN_Y,
g_param_spec_float ("min-y",
-G_MAXFLOAT,
G_MAXFLOAT,
0.0,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MAX_Y,
g_param_spec_float ("max-y",
-G_MAXFLOAT,
G_MAXFLOAT,
1.0,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
curve_type_changed_signal =
g_signal_new ("curve_type_changed",
#include "gtkmain.h"
#include "gtkintl.h"
#include "gtkbindings.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_DIALOG, GtkDialogPrivate))
P_("Has separator"),
P_("The dialog has a separator bar above its buttons"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
dialog_signals[RESPONSE] =
g_signal_new ("response",
0,
G_MAXINT,
2,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("button-spacing",
P_("Button spacing"),
0,
G_MAXINT,
10,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("action-area-border",
0,
G_MAXINT,
5,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
binding_set = gtk_binding_set_by_class (class);
#include "gtkwindow.h"
#include "gtktreeview.h"
#include "gtktreeselection.h"
+#include "gtkprivate.h"
#include "gtkentryprivate.h"
#include "gtkcelllayout.h"
#include "gtkalias.h"
0,
MAX_SIZE,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_SELECTION_BOUND,
0,
MAX_SIZE,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_EDITABLE,
P_("Editable"),
P_("Whether the entry contents can be edited"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MAX_LENGTH,
0,
MAX_SIZE,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBILITY,
g_param_spec_boolean ("visibility",
P_("Visibility"),
P_("FALSE displays the \"invisible char\" instead of the actual text (password mode)"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HAS_FRAME,
P_("Has Frame"),
P_("FALSE removes outside bevel from entry"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_INVISIBLE_CHAR,
P_("Invisible character"),
P_("The character to use when masking entry contents (in \"password mode\")"),
'*',
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACTIVATES_DEFAULT,
P_("Activates default"),
P_("Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WIDTH_CHARS,
g_param_spec_int ("width-chars",
-1,
G_MAXINT,
-1,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SCROLL_OFFSET,
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_TEXT,
P_("Text"),
P_("The contents of the entry"),
"",
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
/**
* GtkEntry:xalign:
0.0,
1.0,
0.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
signals[POPULATE_POPUP] =
g_signal_new ("populate_popup",
P_("Select on focus"),
P_("Whether to select the contents of an entry when it is focused"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (gobject_class, sizeof (GtkEntryPrivate));
}
#include "gtkentrycompletion.h"
#include "gtkentryprivate.h"
#include "gtkcelllayout.h"
-#include "gtkalias.h"
#include "gtkintl.h"
#include "gtkcellrenderertext.h"
#include "gtksignal.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
+#include "gtkalias.h"
+
#include <string.h>
P_("Completion Model"),
P_("The model to find matches in"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MINIMUM_KEY_LENGTH,
g_param_spec_int ("minimum-key-length",
0,
G_MAXINT,
1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkEntryCompletion:text-column:
*
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkEntryCompletion:inline-completion:
P_("Inline completion"),
P_("Whether the common prefix should be inserted automatically"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkEntryCompletion:popup-completion:
*
P_("Popup completion"),
P_("Whether the completions should be shown in a popup window"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class, sizeof (GtkEntryCompletionPrivate));
}
#include <config.h>
#include "gtkeventbox.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Visible Window"),
P_("Whether the event box is visible, as opposed to invisible and only used to trap events."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ABOVE_CHILD,
g_param_spec_boolean ("above-child",
P_("Above child"),
P_("Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it."),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (class, sizeof (GtkEventBoxPrivate));
}
P_("Expanded"),
P_("Whether the expander has been opened to reveal the child widget"),
FALSE,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_LABEL,
P_("Label"),
P_("Text of the expander's label"),
NULL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_USE_UNDERLINE,
P_("Use underline"),
P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
FALSE,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_USE_MARKUP,
P_("Use markup"),
P_("The text of the label includes XML markup. See pango_parse_markup()"),
FALSE,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_SPACING,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_LABEL_WIDGET,
P_("Label widget"),
P_("A widget to display in place of the usual expander label"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("expander-size",
0,
G_MAXINT,
DEFAULT_EXPANDER_SIZE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("expander-spacing",
0,
G_MAXINT,
DEFAULT_EXPANDER_SPACING,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
widget_class->activate_signal =
g_signal_new ("activate",
#include "gtkfilesystem.h"
#include "gtkintl.h"
#include "gtktypebuiltins.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
static void gtk_file_chooser_class_init (gpointer g_iface);
P_("The type of operation that the file selector is performing"),
GTK_TYPE_FILE_CHOOSER_ACTION,
GTK_FILE_CHOOSER_ACTION_OPEN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_string ("file-system-backend",
P_("File System Backend"),
P_("Name of file system backend to use"),
NULL,
- G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
g_object_interface_install_property (g_iface,
g_param_spec_object ("filter",
P_("Filter"),
P_("The current filter for selecting which files are displayed"),
GTK_TYPE_FILE_FILTER,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_boolean ("local-only",
P_("Local Only"),
P_("Whether the selected file(s) should be limited to local file: URLs"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_object ("preview-widget",
P_("Preview widget"),
P_("Application supplied widget for custom previews."),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_boolean ("preview-widget-active",
P_("Preview Widget Active"),
P_("Whether the application supplied widget for custom previews should be shown."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_boolean ("use-preview-label",
P_("Use Preview Label"),
P_("Whether to display a stock label with the name of the previewed file."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_object ("extra-widget",
P_("Extra widget"),
P_("Application supplied widget for extra options."),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_boolean ("select-multiple",
P_("Select Multiple"),
P_("Whether to allow multiple files to be selected"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_interface_install_property (g_iface,
g_param_spec_boolean ("show-hidden",
P_("Show Hidden"),
P_("Whether the hidden files and folders should be displayed"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
/**
#include "gtkfilesystemwin32.h"
#endif
+#include "gtkprivate.h"
#include "gtkalias.h"
/* **************** *
P_("Dialog"),
P_("The file chooser dialog to use."),
GTK_TYPE_FILE_CHOOSER_DIALOG,
- (G_PARAM_WRITABLE |
+ (GTK_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY)));
/**
P_("Title"),
P_("The title of the file chooser dialog."),
_(DEFAULT_TITLE),
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkFileChooserButton:width-chars:
P_("Width In Characters"),
P_("The desired width of the button widget, in characters."),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
_gtk_file_chooser_install_properties (gobject_class);
P_("Default file chooser backend"),
P_("Name of the GtkFileChooser backend to use by default"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
P_("Filename"),
P_("The currently selected filename"),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_FILEOPS,
g_param_spec_boolean ("show-fileops",
P_("Show file operations"),
P_("Whether buttons for creating/manipulating files should be displayed"),
FALSE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SELECT_MULTIPLE,
g_param_spec_boolean ("select-multiple",
P_("Select multiple"),
P_("Whether to allow multiple files to be selected"),
FALSE,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
object_class->destroy = gtk_file_selection_destroy;
widget_class->map = gtk_file_selection_map;
}
#include <config.h>
#include "gtkfixed.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
G_MININT,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_Y,
G_MININT,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static GType
#include "gtkfontsel.h"
#include "gtkimage.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Title"),
P_("The title of the font selection dialog"),
_("Pick a Font"),
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ (GTK_PARAM_READABLE |
+ GTK_PARAM_WRITABLE)));
/**
* GtkFontButton:font-name:
P_("Font name"),
P_("The name of the selected font"),
P_("Sans 12"),
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ (GTK_PARAM_READABLE |
+ GTK_PARAM_WRITABLE)));
/**
* GtkFontButton:use-font:
P_("Use font in label"),
P_("Whether the label is drawn in the selected font"),
FALSE,
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkFontButton:use-size:
P_("Use size in label"),
P_("Whether the label is drawn with the selected font size"),
FALSE,
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkFontButton:show-style:
P_("Show style"),
P_("Whether the selected font style is shown in the label"),
TRUE,
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkFontButton:show-size:
*
P_("Show size"),
P_("Whether selected font size is shown in the label"),
TRUE,
- (G_PARAM_READABLE |
- G_PARAM_WRITABLE)));
+ GTK_PARAM_READWRITE));
/**
* GtkFontButton::font-set:
#include "gtkscrolledwindow.h"
#include "gtkintl.h"
#include "gtkaccessible.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
/* We don't enable the font and style entries because they don't add
P_("Font name"),
P_("The X string that represents this font"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_FONT,
g_param_spec_boxed ("font",
P_("Font"),
P_("The GdkFont that is currently selected"),
GDK_TYPE_FONT,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_PREVIEW_TEXT,
g_param_spec_string ("preview-text",
P_("Preview text"),
P_("The text to display in order to demonstrate the selected font"),
PREVIEW_TEXT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gobject_class->finalize = gtk_font_selection_finalize;
}
#include <string.h>
#include "gtkframe.h"
#include "gtklabel.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Label"),
P_("Text of the frame's label"),
NULL,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READABLE |
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_LABEL_XALIGN,
g_param_spec_float ("label-xalign",
0.0,
1.0,
0.5,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_LABEL_YALIGN,
g_param_spec_float ("label-yalign",
0.0,
1.0,
0.5,
- G_PARAM_READABLE |
- G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHADOW,
g_param_spec_enum ("shadow", NULL,
P_("Deprecated property, use shadow_type instead"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_ETCHED_IN,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
g_param_spec_enum ("shadow-type",
P_("Appearance of the frame border"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_ETCHED_IN,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_LABEL_WIDGET,
P_("Label widget"),
P_("A widget to display in place of the usual frame label"),
GTK_TYPE_WIDGET,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
widget_class->expose_event = gtk_frame_expose;
widget_class->size_request = gtk_frame_size_request;
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtkwindow.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Deprecated property, use shadow_type instead"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_ETCHED_OUT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
g_param_spec_enum ("shadow-type",
P_("Appearance of the shadow that surrounds the container"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_ETCHED_OUT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HANDLE_POSITION,
P_("Position of the handle relative to the child widget"),
GTK_TYPE_POSITION_TYPE,
GTK_POS_LEFT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SNAP_EDGE,
P_("Side of the handlebox that's lined up with the docking point to dock the handlebox"),
GTK_TYPE_POSITION_TYPE,
GTK_POS_TOP,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SNAP_EDGE_SET,
P_("Snap edge set"),
P_("Whether to use the value from the snap_edge property or a value derived from handle_position"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
object_class->destroy = gtk_handle_box_destroy;
#include "gtkaccessible.h"
#include "gtkwindow.h"
#include "gtktextbuffer.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#undef DEBUG_ICON_VIEW
P_("The selection mode"),
GTK_TYPE_SELECTION_MODE,
GTK_SELECTION_SINGLE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:pixbuf-column:
P_("Pixbuf column"),
P_("Model column used to retrieve the icon pixbuf from"),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:text-column:
P_("Text column"),
P_("Model column used to retrieve the text from"),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
P_("Markup column"),
P_("Model column used to retrieve the text if using Pango markup"),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MODEL,
P_("Icon View Model"),
P_("The model for the icon view"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView:columns:
P_("Number of columns"),
P_("Number of columns to display"),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
P_("Width for each item"),
P_("The width used for each item"),
-1, G_MAXINT, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView::spacing:
P_("Spacing"),
P_("Space which is inserted between cells of an item"),
0, G_MAXINT, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView::row-spacing:
P_("Row Spacing"),
P_("Space which is inserted between grid rows"),
0, G_MAXINT, 6,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView::column-spacing:
P_("Column Spacing"),
P_("Space which is inserted between grid column"),
0, G_MAXINT, 6,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkIconView::margin:
P_("Margin"),
P_("Space which is inserted at the edges of the icon view"),
0, G_MAXINT, 6,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
P_("How the text and icon of each item are positioned relative to each other"),
GTK_TYPE_ORIENTATION,
GTK_ORIENTATION_VERTICAL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/* Style properties */
gtk_widget_class_install_style_property (widget_class,
P_("Selection Box Color"),
P_("Color of the selection box"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_uchar ("selection-box-alpha",
P_("Opacity of the selection box"),
0, 0xff,
0x40,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/* Signals */
widget_class->set_scroll_adjustments_signal =
#include <config.h>
#include <math.h>
+#include <string.h>
+
#include "gtkcontainer.h"
#include "gtkimage.h"
#include "gtkiconfactory.h"
#include "gtkstock.h"
#include "gtkicontheme.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
-#include <string.h>
typedef struct _GtkImagePrivate GtkImagePrivate;
P_("Pixbuf"),
P_("A GdkPixbuf to display"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PIXMAP,
P_("Pixmap"),
P_("A GdkPixmap to display"),
GDK_TYPE_PIXMAP,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_IMAGE,
P_("Image"),
P_("A GdkImage to display"),
GDK_TYPE_IMAGE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MASK,
P_("Mask"),
P_("Mask bitmap to use with GdkImage or GdkPixmap"),
GDK_TYPE_PIXMAP,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_FILE,
P_("Filename"),
P_("Filename to load and display"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
P_("Stock ID"),
P_("Stock ID for a stock image to display"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ICON_SET,
P_("Icon set"),
P_("Icon set to display"),
GTK_TYPE_ICON_SET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ICON_SIZE,
P_("Symbolic size to use for stock icon, icon set or named icon"),
0, G_MAXINT,
DEFAULT_ICON_SIZE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkImage:pixel-size:
*
P_("Pixel size to use for named icon"),
-1, G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PIXBUF_ANIMATION,
P_("Animation"),
P_("GdkPixbufAnimation to display"),
GDK_TYPE_PIXBUF_ANIMATION,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkImage:icon-name:
P_("Icon Name"),
P_("The name of the icon from the icon theme"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_STORAGE_TYPE,
P_("The representation being used for image data"),
GTK_TYPE_IMAGE_TYPE,
GTK_IMAGE_EMPTY,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_type_class_add_private (object_class, sizeof (GtkImagePrivate));
}
#include "gtkimage.h"
#include "gtkcontainer.h"
#include "gtkwindow.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
static void gtk_image_menu_item_class_init (GtkImageMenuItemClass *klass);
P_("Image widget"),
P_("Child widget to appear next to the menu text"),
GTK_TYPE_WIDGET,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
gtk_settings_install_property (g_param_spec_boolean ("gtk-menu-images",
P_("Show menu images"),
P_("Whether images should be shown in menus"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
#include <config.h>
#include <gdk/gdk.h>
#include "gtkinvisible.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Screen"),
P_("The screen where this window will be displayed"),
GDK_TYPE_SCREEN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtknotebook.h"
#include "gtkstock.h"
#include "gtkbindings.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define GTK_LABEL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_LABEL, GtkLabelPrivate))
P_("Label"),
P_("The text of the label"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ATTRIBUTES,
g_param_spec_boxed ("attributes",
P_("Attributes"),
P_("A list of style attributes to apply to the text of the label"),
PANGO_TYPE_ATTR_LIST,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_USE_MARKUP,
g_param_spec_boolean ("use-markup",
P_("Use markup"),
P_("The text of the label includes XML markup. See pango_parse_markup()"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_USE_UNDERLINE,
g_param_spec_boolean ("use-underline",
P_("Use underline"),
P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_JUSTIFY,
P_("The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that"),
GTK_TYPE_JUSTIFICATION,
GTK_JUSTIFY_LEFT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PATTERN,
P_("Pattern"),
P_("A string with _ characters in positions correspond to characters in the text to underline"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_WRAP,
P_("Line wrap"),
P_("If set, wrap lines if the text becomes too wide"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SELECTABLE,
g_param_spec_boolean ("selectable",
P_("Selectable"),
P_("Whether the label text can be selected with the mouse"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MNEMONIC_KEYVAL,
g_param_spec_uint ("mnemonic-keyval",
0,
G_MAXUINT,
GDK_VoidSymbol,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_MNEMONIC_WIDGET,
g_param_spec_object ("mnemonic-widget",
P_("The widget to be activated when the label's mnemonic "
"key is pressed"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CURSOR_POSITION,
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_SELECTION_BOUND,
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkLabel:ellipsize:
P_("The preferred place to ellipsize the string, if the label does not have enough room to display the entire string, if at all"),
PANGO_TYPE_ELLIPSIZE_MODE,
PANGO_ELLIPSIZE_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkLabel:width-chars:
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkLabel:single-line-mode:
P_("Single Line Mode"),
P_("Whether the label is in single line mode"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkLabel:angle:
0.0,
360.0,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkLabel:max-width-chars:
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/*
* Key bindings
*/
G_MININT,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_Y,
G_MININT,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HADJUSTMENT,
P_("Horizontal adjustment"),
P_("The GtkAdjustment for the horizontal position"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VADJUSTMENT,
P_("Vertical adjustment"),
P_("The GtkAdjustment for the vertical position"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WIDTH,
0,
G_MAXINT,
100,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HEIGHT,
g_param_spec_uint ("height",
0,
G_MAXINT,
100,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
widget_class->realize = gtk_layout_realize;
widget_class->unrealize = gtk_layout_unrealize;
widget_class->map = gtk_layout_map;
GTK_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
- gtk_object_add_arg_type ("GtkList::selection_mode",
- GTK_TYPE_SELECTION_MODE, GTK_ARG_READWRITE,
+ gtk_object_add_arg_type ("GtkList::selection-mode",
+ GTK_TYPE_SELECTION_MODE,
+ GTK_ARG_READWRITE | G_PARAM_STATIC_NAME,
ARG_SELECTION_MODE);
}
#include "gtkhbox.h"
#include "gtkvscrollbar.h"
#include "gtksettings.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Tearoff Title"),
P_("A title that may be displayed by the window manager when this menu is torn-off"),
"",
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkMenu:tearoff-state:
P_("Tearoff State"),
P_("A boolean that indicates whether the menu is torn-off"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("vertical-padding",
0,
G_MAXINT,
1,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("vertical-offset",
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("horizontal-offset",
G_MININT,
G_MAXINT,
-2,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_container_class_install_child_property (container_class,
P_("Left Attach"),
P_("The column number to attach the left side of the child to"),
-1, INT_MAX, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_RIGHT_ATTACH,
P_("Right Attach"),
P_("The column number to attach the right side of the child to"),
-1, INT_MAX, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TOP_ATTACH,
P_("Top Attach"),
P_("The row number to attach the top of the child to"),
-1, INT_MAX, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_BOTTOM_ATTACH,
P_("Bottom Attach"),
P_("The row number to attach the bottom of the child to"),
-1, INT_MAX, -1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
binding_set = gtk_binding_set_by_class (class);
gtk_binding_entry_add_signal (binding_set,
P_("Can change accelerators"),
P_("Whether menu accelerators can be changed by pressing a key over the menu item"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_settings_install_property (g_param_spec_int ("gtk-menu-popup-delay",
P_("Delay before submenus appear"),
0,
G_MAXINT,
DEFAULT_POPUP_DELAY,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_settings_install_property (g_param_spec_int ("gtk-menu-popdown-delay",
P_("Delay before hiding a submenu"),
0,
G_MAXINT,
DEFAULT_POPDOWN_DELAY,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
#include "gtksettings.h"
#include "gtkintl.h"
#include "gtkwindow.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
P_("The pack direction of the menubar"),
GTK_TYPE_PACK_DIRECTION,
GTK_PACK_DIRECTION_LTR,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkMenuBar:child-pack-direction:
P_("The child pack direction of the menubar"),
GTK_TYPE_PACK_DIRECTION,
GTK_PACK_DIRECTION_LTR,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
P_("Style of bevel around the menubar"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_OUT,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("internal-padding",
0,
G_MAXINT,
DEFAULT_IPADDING,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_settings_install_property (g_param_spec_int ("gtk-menu-bar-popup-delay",
P_("Delay before drop down menus appear"),
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (gobject_class, sizeof (GtkMenuBarPrivate));
}
#include "gtkmenubar.h"
#include "gtkmenuitem.h"
#include "gtkseparatormenuitem.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
"Shadow type when item is selected",
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_NONE,
- G_PARAM_READABLE),
+ GTK_PARAM_READABLE),
gtk_rc_property_parse_enum);
gtk_widget_class_install_style_property (widget_class,
0,
G_MAXINT,
3,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("toggle-spacing",
0,
G_MAXINT,
5,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("arrow-spacing",
0,
G_MAXINT,
10,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
#include "gtkvbox.h"
#include "gtkmenu.h"
#include "gtkmain.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
P_("Menu"),
P_("The dropdown menu"),
GTK_TYPE_MENU,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class, sizeof (GtkMenuToolButtonPrivate));
}
*/
#include <config.h>
+#include <string.h>
+
#include "gtkmessagedialog.h"
#include "gtklabel.h"
#include "gtkhbox.h"
#include "gtkstock.h"
#include "gtkiconfactory.h"
#include "gtkintl.h"
-#include <string.h>
+#include "gtkprivate.h"
#include "gtkalias.h"
#define GTK_MESSAGE_DIALOG_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogPrivate))
0,
G_MAXINT,
12,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkMessageDialog::use_separator
*
P_("Use separator"),
P_("Whether to put a separator between the message dialog's text and the buttons"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_MESSAGE_TYPE,
g_param_spec_enum ("message-type",
P_("The type of message"),
GTK_TYPE_MESSAGE_TYPE,
GTK_MESSAGE_INFO,
- G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_BUTTONS,
g_param_spec_enum ("buttons",
P_("The buttons shown in the message dialog"),
GTK_TYPE_BUTTONS_TYPE,
GTK_BUTTONS_NONE,
- G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (gobject_class,
sizeof (GtkMessageDialogPrivate));
}
#include "gtkcontainer.h"
#include "gtkmisc.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
0.0,
1.0,
0.5,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YALIGN,
0.0,
1.0,
0.5,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_XPAD,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_YPAD,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtkbindings.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TAB_POS,
g_param_spec_enum ("tab-pos",
P_("Which side of the notebook holds the tabs"),
GTK_TYPE_POSITION_TYPE,
GTK_POS_TOP,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TAB_BORDER,
g_param_spec_uint ("tab-border",
0,
G_MAXUINT,
2,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_TAB_HBORDER,
g_param_spec_uint ("tab-hborder",
0,
G_MAXUINT,
2,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TAB_VBORDER,
g_param_spec_uint ("tab-vborder",
0,
G_MAXUINT,
2,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_TABS,
g_param_spec_boolean ("show-tabs",
P_("Show Tabs"),
P_("Whether tabs should be shown or not"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_BORDER,
g_param_spec_boolean ("show-border",
P_("Show Border"),
P_("Whether the border should be shown or not"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SCROLLABLE,
g_param_spec_boolean ("scrollable",
P_("Scrollable"),
P_("If TRUE, scroll arrows are added if there are too many tabs to fit"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ENABLE_POPUP,
g_param_spec_boolean ("enable-popup",
P_("Enable Popup"),
P_("If TRUE, pressing the right mouse button on the notebook pops up a menu that you can use to go to a page"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HOMOGENEOUS,
g_param_spec_boolean ("homogeneous",
P_("Homogeneous"),
P_("Whether tabs should have homogeneous sizes"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_LABEL,
P_("Tab label"),
P_("The string displayed on the child's tab label"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_MENU_LABEL,
g_param_spec_string ("menu-label",
P_("Menu label"),
P_("The string displayed in the child's menu entry"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_POSITION,
g_param_spec_int ("position",
P_("Position"),
P_("The index of the child in the parent"),
-1, G_MAXINT, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_EXPAND,
g_param_spec_boolean ("tab-expand",
P_("Tab expand"),
P_("Whether to expand the child's tab or not"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_FILL,
g_param_spec_boolean ("tab-fill",
P_("Tab fill"),
P_("Whether the child's tab should fill the allocated area or not"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TAB_PACK,
g_param_spec_enum ("tab-pack",
P_("Tab pack type"),
P_("A GtkPackType indicating whether the child is packed with reference to the start or end of the parent"),
GTK_TYPE_PACK_TYPE, GTK_PACK_START,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkNotebook:has-secondary-backward-stepper:
P_("Display a second backward arrow button on the opposite end of the tab area"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkNotebook:has-secondary-forward-stepper:
P_("Display a second forward arrow button on the opposite end of the tab area"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkNotebook:has-backward-stepper:
P_("Display the standard backward arrow button"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkNotebook:has-forward-stepper:
P_("Display the standard forward arrow button"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
notebook_signals[SWITCH_PAGE] =
g_signal_new ("switch_page",
#include "gtkobject.h"
#include "gtkmarshalers.h"
#include "gtksignal.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
g_return_if_fail ((arg_flags & G_PARAM_CONSTRUCT_ONLY) == 0);
if (arg_flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))
g_return_if_fail (arg_flags & G_PARAM_WRITABLE);
- g_return_if_fail ((arg_flags & ~(G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) == 0);
+ g_return_if_fail ((arg_flags & ~(G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME)) == 0);
pname = strchr (arg_name, ':');
g_return_if_fail (pname && pname[1] == ':');
PROP_USER_DATA,
g_param_spec_pointer ("user-data", "User Data",
"Anonymous User Data Pointer",
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
object_signals[DESTROY] =
g_signal_new ("destroy",
G_TYPE_FROM_CLASS (gobject_class),
_gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
- gtk_object_add_arg_type ("GtkOldEditable::text-position", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TEXT_POSITION);
- gtk_object_add_arg_type ("GtkOldEditable::editable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EDITABLE);
+ gtk_object_add_arg_type ("GtkOldEditable::text-position", GTK_TYPE_INT, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_TEXT_POSITION);
+ gtk_object_add_arg_type ("GtkOldEditable::editable", GTK_TYPE_BOOL, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_EDITABLE);
}
static void
#include "gtkoptionmenu.h"
#define GTK_DISABLE_DEPRECATED
+#include "gtkprivate.h"
#include "gtkalias.h"
#define CHILD_LEFT_SPACING 4
P_("Menu"),
P_("The menu of options"),
GTK_TYPE_MENU,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boxed ("indicator-size",
P_("Indicator Size"),
P_("Size of dropdown indicator"),
GTK_TYPE_REQUISITION,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boxed ("indicator-spacing",
P_("Indicator Spacing"),
P_("Spacing around indicator"),
GTK_TYPE_BORDER,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static GType
#include "gtkwindow.h"
#include "gtkmain.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
enum {
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_POSITION_SET,
g_param_spec_boolean ("position-set",
P_("Position Set"),
P_("TRUE if the Position property should be used"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("handle-size",
0,
G_MAXINT,
5,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkPaned:min-position:
*
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkPaned:max-position:
0,
G_MAXINT,
G_MAXINT,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
* GtkPaned:resize:
P_("Resize"),
P_("If TRUE, the child expands and shrinks along with the paned widget"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkPaned:shrink:
P_("Shrink"),
P_("If TRUE, the child can be made smaller than its requisition"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
signals [CYCLE_CHILD_FOCUS] =
g_signal_new ("cycle_child_focus",
#include "gdk/gdkrgb.h"
#include "gtkpreview.h"
#include "gtksignal.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Expand"),
P_("Whether the preview widget should take up the entire space it is allocated"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#include <gtk/gtkwidget.h>
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
+G_BEGIN_DECLS
/* The private flags that are used in the private_flags member of GtkWidget.
*/
const char *string,
gboolean no_leading_period);
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+#define GTK_PARAM_READABLE G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_WRITABLE G_PARAM_WRITABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+#define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
+
+G_END_DECLS
#endif /* __GTK_PRIVATE_H__ */
#include <math.h>
#include <string.h>
#include "gtkprogress.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Activity mode"),
P_("If TRUE the GtkProgress is in activity mode, meaning that it signals something is happening, but not how much of the activity is finished. This is used when you're doing something that you don't know how long it will take"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_TEXT,
P_("Show text"),
P_("Whether the progress is shown as text"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TEXT_XALIGN,
0.0,
1.0,
0.5,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TEXT_YALIGN,
g_param_spec_float ("text-yalign",
0.0,
1.0,
0.5,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#endif
#include "gtkprogressbar.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Adjustment"),
P_("The GtkAdjustment connected to the progress bar (Deprecated)"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ORIENTATION,
P_("Orientation and growth direction of the progress bar"),
GTK_TYPE_PROGRESS_BAR_ORIENTATION,
GTK_PROGRESS_LEFT_TO_RIGHT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_BAR_STYLE,
P_("Specifies the visual style of the bar in percentage mode (Deprecated)"),
GTK_TYPE_PROGRESS_BAR_STYLE,
GTK_PROGRESS_CONTINUOUS,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACTIVITY_STEP,
-G_MAXUINT,
G_MAXUINT,
3,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACTIVITY_BLOCKS,
2,
G_MAXUINT,
5,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DISCRETE_BLOCKS,
2,
G_MAXUINT,
10,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_FRACTION,
0.0,
1.0,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PULSE_STEP,
0.0,
1.0,
0.1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TEXT,
P_("Text"),
P_("Text to be displayed in the progress bar"),
"%P %%",
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkProgressBar:ellipsize:
P_("The preferred place to ellipsize the string, if the progressbar does not have enough room to display the entire string, if at all"),
PANGO_TYPE_ELLIPSIZE_MODE,
PANGO_ELLIPSIZE_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
#include "gtktoggleactionprivate.h"
#include "gtktoggletoolbutton.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define GTK_RADIO_ACTION_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RADIO_ACTION, GtkRadioActionPrivate))
G_MININT,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkRadioAction:group:
P_("Group"),
P_("The radio action whose group this action belongs to."),
GTK_TYPE_RADIO_ACTION,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
/**
* GtkRadioAction::changed:
#include "gtklabel.h"
#include "gtkmarshalers.h"
#include "gtkradiobutton.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Group"),
P_("The radio button whose group this widget belongs to."),
GTK_TYPE_RADIO_BUTTON,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
object_class->destroy = gtk_radio_button_destroy;
widget_class->focus = gtk_radio_button_focus;
#include "gtkradiotoolbutton.h"
#include "gtkradiobutton.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
enum {
_("Group"),
_("The radio tool button whose group this button belongs to."),
GTK_TYPE_RADIO_TOOL_BUTTON,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
}
#include "gtkrange.h"
#include "gtkintl.h"
#include "gtkscrollbar.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define SCROLL_INITIAL_DELAY 250 /* must hold button this long before ... */
P_("How the range should be updated on the screen"),
GTK_TYPE_UPDATE_TYPE,
GTK_UPDATE_CONTINUOUS,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ADJUSTMENT,
P_("Adjustment"),
P_("The GtkAdjustment that contains the current value of this range object"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_INVERTED,
P_("Inverted"),
P_("Invert direction slider moves to increase range value"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("slider-width",
0,
G_MAXINT,
14,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("trough-border",
P_("Trough Border"),
0,
G_MAXINT,
1,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("stepper-size",
P_("Stepper Size"),
0,
G_MAXINT,
14,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("stepper-spacing",
P_("Stepper Spacing"),
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("arrow-displacement-x",
P_("Arrow X Displacement"),
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("arrow-displacement-y",
P_("Arrow Y Displacement"),
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
#include <config.h>
#include "gtkruler.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_UPPER,
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_POSITION,
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MAX_SIZE,
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtkmarshalers.h"
#include "gdk/gdkkeysyms.h"
#include "gtkbindings.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
-1,
MAX_DIGITS,
1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DRAW_VALUE,
P_("Draw Value"),
P_("Whether the current value is displayed as a string next to the slider"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VALUE_POS,
P_("The position in which the current value is displayed"),
GTK_TYPE_POSITION_TYPE,
GTK_POS_LEFT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("slider-length",
0,
G_MAXINT,
31,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("value-spacing",
0,
G_MAXINT,
2,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/* All bindings (even arrow keys) are on both h/v scale, because
* blind users etc. don't care about scale orientation.
#include <config.h>
#include "gtkscrollbar.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
static void gtk_scrollbar_class_init (GtkScrollbarClass *klass);
0,
G_MAXINT,
21,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("fixed-slider-length",
P_("Don't change slider size, just lock it to the minimum length"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("has-backward-stepper",
P_("Display the standard backward arrow button"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("has-forward-stepper",
P_("Display the standard forward arrow button"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("has-secondary-backward-stepper",
P_("Display a second backward arrow button on the opposite end of the scrollbar"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("has-secondary-forward-stepper",
P_("Display a secondary forward arrow button on the opposite end of the scrollbar"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
#include "gtkbindings.h"
#include "gtkmarshalers.h"
#include "gtkscrolledwindow.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Horizontal Adjustment"),
P_("The GtkAdjustment for the horizontal position"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_VADJUSTMENT,
g_param_spec_object ("vadjustment",
P_("Vertical Adjustment"),
P_("The GtkAdjustment for the vertical position"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_HSCROLLBAR_POLICY,
g_param_spec_enum ("hscrollbar-policy",
P_("When the horizontal scrollbar is displayed"),
GTK_TYPE_POLICY_TYPE,
GTK_POLICY_ALWAYS,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_VSCROLLBAR_POLICY,
g_param_spec_enum ("vscrollbar-policy",
P_("When the vertical scrollbar is displayed"),
GTK_TYPE_POLICY_TYPE,
GTK_POLICY_ALWAYS,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_WINDOW_PLACEMENT,
P_("Where the contents are located with respect to the scrollbars"),
GTK_TYPE_CORNER_TYPE,
GTK_CORNER_TOP_LEFT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
g_param_spec_enum ("shadow-type",
P_("Style of bevel around the contents"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_NONE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("scrollbar-spacing",
0,
G_MAXINT,
DEFAULT_SCROLLBAR_SPACING,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
signals[SCROLL_CHILD] =
g_signal_new ("scroll_child",
#include "gtkseparatortoolitem.h"
#include "gtkintl.h"
#include "gtktoolbar.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define MENU_ID "gtk-separator-tool-item-menu-id"
P_("Draw"),
P_("Whether the separator is drawn, or just blank"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_type_class_add_private (object_class, sizeof (GtkSeparatorToolItemPrivate));
}
#include "gtkrc.h"
#include "gtkintl.h"
#include "gtkwidget.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
typedef struct _GtkSettingsValuePrivate GtkSettingsValuePrivate;
P_("Double Click Time"),
P_("Maximum time allowed between two clicks for them to be considered a double click (in milliseconds)"),
0, G_MAXINT, 250,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_DOUBLE_CLICK_TIME);
result = settings_install_property_parser (class,
P_("Double Click Distance"),
P_("Maximum distance allowed between two clicks for them to be considered a double click (in pixels)"),
0, G_MAXINT, 5,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_DOUBLE_CLICK_DISTANCE);
result = settings_install_property_parser (class,
P_("Cursor Blink"),
P_("Whether the cursor should blink"),
TRUE,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_CURSOR_BLINK);
result = settings_install_property_parser (class,
P_("Cursor Blink Time"),
P_("Length of the cursor blink cycle, in milleseconds"),
100, G_MAXINT, 1200,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_CURSOR_BLINK_TIME);
result = settings_install_property_parser (class,
P_("Split Cursor"),
P_("Whether two cursors should be displayed for mixed left-to-right and right-to-left text"),
TRUE,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_SPLIT_CURSOR);
result = settings_install_property_parser (class,
P_("Theme Name"),
P_("Name of theme RC file to load"),
"Default",
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_THEME_NAME);
result = settings_install_property_parser (class,
P_("Icon Theme Name"),
P_("Name of icon theme to use"),
"hicolor",
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_ICON_THEME_NAME);
P_("Key Theme Name"),
P_("Name of key theme RC file to load"),
NULL,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_KEY_THEME_NAME);
P_("Menu bar accelerator"),
P_("Keybinding to activate the menu bar"),
"F10",
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_MENU_BAR_ACCEL);
P_("Drag threshold"),
P_("Number of pixels the cursor can move before dragging"),
1, G_MAXINT, 8,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_DND_DRAG_THRESHOLD);
P_("Font Name"),
P_("Name of default font to use"),
"Sans 10",
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_FONT_NAME);
P_("Icon Sizes"),
P_("List of icon sizes (gtk-menu=16,16;gtk-button=20,20..."),
NULL,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_ICON_SIZES);
P_("GTK Modules"),
P_("List of currently active GTK modules"),
NULL,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_MODULES);
P_("Xft Antialias"),
P_("Whether to antialias Xft fonts; 0=no, 1=yes, -1=default"),
-1, 1, -1,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_XFT_ANTIALIAS);
P_("Xft Hinting"),
P_("Whether to hint Xft fonts; 0=no, 1=yes, -1=default"),
-1, 1, -1,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_XFT_HINTING);
P_("Xft Hint Style"),
P_("What degree of hinting to use; none, slight, medium, or full"),
NULL,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_XFT_HINTSTYLE);
P_("Xft RGBA"),
P_("Type of subpixel antialiasing; none, rgb, bgr, vrgb, vbgr"),
NULL,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_XFT_RGBA);
P_("Xft DPI"),
P_("Resolution for Xft, in 1024 * dots/inch. -1 to use default value"),
-1, 1024*1024, -1,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_XFT_DPI);
P_("Alternative button order"),
P_("Whether buttons in dialogs should use the alternative button order"),
FALSE,
- G_PARAM_READWRITE),
+ GTK_PARAM_READWRITE),
NULL);
g_assert (result == PROP_ALTERNATIVE_BUTTON_ORDER);
}
" of its component widgets"),
GTK_TYPE_SIZE_GROUP_MODE,
GTK_SIZE_GROUP_HORIZONTAL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static void
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtksettings.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Adjustment"),
P_("The adjustment that holds the value of the spinbutton"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CLIMB_RATE,
0.0,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DIGITS,
0,
MAX_DIGITS,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SNAP_TO_TICKS,
P_("Snap to Ticks"),
P_("Whether erroneous values are automatically changed to a spin button's nearest step increment"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_NUMERIC,
P_("Numeric"),
P_("Whether non-numeric characters should be ignored"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WRAP,
P_("Wrap"),
P_("Whether a spin button should wrap upon reaching its limits"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_UPDATE_POLICY,
P_("Whether the spin button should update always, or only when the value is legal"),
GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY,
GTK_UPDATE_ALWAYS,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VALUE,
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property_parser (widget_class,
g_param_spec_enum ("shadow-type",
P_("Style of bevel around the spin button"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_IN,
- G_PARAM_READABLE),
+ GTK_PARAM_READABLE),
gtk_rc_property_parse_enum);
spinbutton_signals[INPUT] =
g_signal_new ("input",
#include "gtkmarshalers.h"
#include "gtkstatusbar.h"
#include "gtkwindow.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Has Resize Grip"),
P_("Whether the statusbar has a grip for resizing the toplevel"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
statusbar_signals[SIGNAL_TEXT_PUSHED] =
g_signal_new ("text_pushed",
G_OBJECT_CLASS_TYPE (class),
P_("Style of bevel around the statusbar text"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_IN,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
#include <config.h>
#include "gtktable.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_N_COLUMNS,
g_param_spec_uint ("n-columns",
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ROW_SPACING,
g_param_spec_uint ("row-spacing",
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_COLUMN_SPACING,
g_param_spec_uint ("column-spacing",
0,
G_MAXUINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HOMOGENEOUS,
g_param_spec_boolean ("homogeneous",
P_("Homogenous"),
P_("If TRUE this means the table cells are all the same width/height"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_LEFT_ATTACH,
P_("Left attachment"),
P_("The column number to attach the left side of the child to"),
0, 65535, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_RIGHT_ATTACH,
g_param_spec_uint ("right-attach",
P_("Right attachment"),
P_("The column number to attach the right side of a child widget to"),
1, 65535, 1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_TOP_ATTACH,
g_param_spec_uint ("top-attach",
P_("Top attachment"),
P_("The row number to attach the top of a child widget to"),
0, 65535, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_BOTTOM_ATTACH,
g_param_spec_uint ("bottom-attach",
P_("Bottom attachment"),
P_("The row number to attach the bottom of the child to"),
1, 65535, 1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_X_OPTIONS,
g_param_spec_flags ("x-options",
P_("Horizontal options"),
P_("Options specifying the horizontal behaviour of the child"),
GTK_TYPE_ATTACH_OPTIONS, GTK_EXPAND | GTK_FILL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_Y_OPTIONS,
g_param_spec_flags ("y-options",
P_("Vertical options"),
P_("Options specifying the vertical behaviour of the child"),
GTK_TYPE_ATTACH_OPTIONS, GTK_EXPAND | GTK_FILL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_X_PADDING,
g_param_spec_uint ("x-padding",
P_("Horizontal padding"),
P_("Extra space to put between the child and its left and right neighbors, in pixels"),
0, 65535, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_Y_PADDING,
g_param_spec_uint ("y-padding",
P_("Vertical padding"),
P_("Extra space to put between the child and its upper and lower neighbors, in pixels"),
0, 65535, 0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
}
static GType
#include "gtktext.h"
#include "line-wrap.xbm"
#include "line-arrow.xbm"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Horizontal Adjustment"),
P_("Horizontal adjustment for the text widget"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VADJUSTMENT,
P_("Vertical Adjustment"),
P_("Vertical adjustment for the text widget"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_LINE_WRAP,
P_("Line Wrap"),
P_("Whether lines are wrapped at widget edges"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WORD_WRAP,
P_("Word Wrap"),
P_("Whether words are wrapped at widget edges"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
widget_class->set_scroll_adjustments_signal =
gtk_signal_new ("set_scroll_adjustments",
#include "gtktextbuffer.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Tag Table"),
P_("Text Tag Table"),
GTK_TYPE_TEXT_TAG_TABLE,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
signals[INSERT_TEXT] =
g_signal_new ("insert_text",
#include "gtkmain.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#include <stdlib.h>
P_("Tag name"),
P_("Name used to refer to the text tag. NULL for anonymous tags"),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/* Style args */
P_("Background color name"),
P_("Background color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_BACKGROUND_GDK,
P_("Background color"),
P_("Background color as a (possibly unallocated) GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_BACKGROUND_FULL_HEIGHT,
P_("Background full height"),
P_("Whether the background color fills the entire line height or only the height of the tagged characters"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Background stipple mask"),
P_("Bitmap to use as a mask when drawing the text background"),
GDK_TYPE_PIXMAP,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Foreground color name"),
P_("Foreground color as a string"),
NULL,
- G_PARAM_WRITABLE));
+ GTK_PARAM_WRITABLE));
g_object_class_install_property (object_class,
PROP_FOREGROUND_GDK,
P_("Foreground color"),
P_("Foreground color as a (possibly unallocated) GdkColor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Foreground stipple mask"),
P_("Bitmap to use as a mask when drawing the text foreground"),
GDK_TYPE_PIXMAP,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_DIRECTION,
P_("Text direction, e.g. right-to-left or left-to-right"),
GTK_TYPE_TEXT_DIRECTION,
GTK_TEXT_DIR_LTR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_EDITABLE,
P_("Editable"),
P_("Whether the text can be modified by the user"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FONT,
P_("Font"),
P_("Font description as a string, e.g. \"Sans Italic 12\""),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FONT_DESC,
P_("Font"),
P_("Font description as a PangoFontDescription struct"),
PANGO_TYPE_FONT_DESCRIPTION,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Font family"),
P_("Name of the font family, e.g. Sans, Helvetica, Times, Monospace"),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STYLE,
P_("Font style as a PangoStyle, e.g. PANGO_STYLE_ITALIC"),
PANGO_TYPE_STYLE,
PANGO_STYLE_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_VARIANT,
P_("Font variant as a PangoVariant, e.g. PANGO_VARIANT_SMALL_CAPS"),
PANGO_TYPE_VARIANT,
PANGO_VARIANT_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WEIGHT,
0,
G_MAXINT,
PANGO_WEIGHT_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Font stretch as a PangoStretch, e.g. PANGO_STRETCH_CONDENSED"),
PANGO_TYPE_STRETCH,
PANGO_STRETCH_NORMAL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZE,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SCALE,
0.0,
G_MAXDOUBLE,
1.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZE_POINTS,
0.0,
G_MAXDOUBLE,
0.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_JUSTIFICATION,
P_("Left, right, or center justification"),
GTK_TYPE_JUSTIFICATION,
GTK_JUSTIFY_LEFT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LANGUAGE,
P_("Language"),
P_("The language this text is in, as an ISO code. Pango can use this as a hint when rendering the text. If not set, an appropriate default will be used."),
NULL,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LEFT_MARGIN,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_RIGHT_MARGIN,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
G_MININT,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_PIXELS_ABOVE_LINES,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_PIXELS_BELOW_LINES,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_PIXELS_INSIDE_WRAP,
0,
G_MAXINT,
0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STRIKETHROUGH,
P_("Strikethrough"),
P_("Whether to strike through the text"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_UNDERLINE,
P_("Style of underline for this text"),
PANGO_TYPE_UNDERLINE,
PANGO_UNDERLINE_NONE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WRAP_MODE,
P_("Whether to wrap lines never, at word boundaries, or at character boundaries"),
GTK_TYPE_WRAP_MODE,
GTK_WRAP_NONE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Tabs"),
P_("Custom tabs for this text"),
PANGO_TYPE_TAB_ARRAY,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_INVISIBLE,
P_("Invisible"),
P_("Whether this text is hidden. Not implemented in GTK 2.0"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
/* Style props are set or not */
-#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, G_PARAM_READABLE | G_PARAM_WRITABLE))
+#define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
ADD_SET_PROP ("background-set", PROP_BACKGROUND_SET,
P_("Background set"),
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PIXELS_BELOW_LINES,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PIXELS_INSIDE_WRAP,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_EDITABLE,
P_("Editable"),
P_("Whether the text can be modified by the user"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WRAP_MODE,
P_("Whether to wrap lines never, at word boundaries, or at character boundaries"),
GTK_TYPE_WRAP_MODE,
GTK_WRAP_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_JUSTIFICATION,
P_("Left, right, or center justification"),
GTK_TYPE_JUSTIFICATION,
GTK_JUSTIFY_LEFT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_LEFT_MARGIN,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RIGHT_MARGIN,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_INDENT,
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TABS,
P_("Tabs"),
P_("Custom tabs for this text"),
PANGO_TYPE_TAB_ARRAY,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CURSOR_VISIBLE,
P_("Cursor Visible"),
P_("If the insertion cursor is shown"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_BUFFER,
P_("Buffer"),
P_("The buffer which is displayed"),
GTK_TYPE_TEXT_BUFFER,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_OVERWRITE,
P_("Overwrite mode"),
P_("Whether entered text overwrites existing contents"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ACCEPTS_TAB,
P_("Accepts tab"),
P_("Whether Tab will result in a tab character being entered"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/*
* Style properties
P_("Error underline color"),
P_("Color with which to draw error-indication underlines"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/*
* Signals
class->widget_entered = gtk_tips_query_widget_entered;
class->widget_selected = NULL;
- gtk_object_add_arg_type ("GtkTipsQuery::emit-always", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EMIT_ALWAYS);
- gtk_object_add_arg_type ("GtkTipsQuery::caller", GTK_TYPE_WIDGET, GTK_ARG_READWRITE, ARG_CALLER);
- gtk_object_add_arg_type ("GtkTipsQuery::label-inactive", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_INACTIVE);
- gtk_object_add_arg_type ("GtkTipsQuery::label-no-tip", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_NO_TIP);
+ gtk_object_add_arg_type ("GtkTipsQuery::emit-always", GTK_TYPE_BOOL, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_EMIT_ALWAYS);
+ gtk_object_add_arg_type ("GtkTipsQuery::caller", GTK_TYPE_WIDGET, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_CALLER);
+ gtk_object_add_arg_type ("GtkTipsQuery::label-inactive", GTK_TYPE_STRING, GTK_ARG_READWRITE | G_PARAM_STATIC_NAME, ARG_LABEL_INACTIVE);
+ 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",
#include "gtktoggletoolbutton.h"
#include "gtktogglebutton.h"
#include "gtkcheckmenuitem.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
enum
P_("Create the same proxies as a radio action"),
P_("Whether the proxies for this action look like radio action proxies"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
action_signals[TOGGLED] =
g_signal_new ("toggled",
#include "gtkmain.h"
#include "gtkmarshalers.h"
#include "gtktogglebutton.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Active"),
P_("If the toggle button should be pressed in or not"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_INCONSISTENT,
P_("Inconsistent"),
P_("If the toggle button is in an \"in between\" state"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DRAW_INDICATOR,
P_("Draw Indicator"),
P_("If the toggle part of the button is displayed"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
toggle_button_signals[TOGGLED] =
g_signal_new ("toggled",
#include "gtkstock.h"
#include "gtkintl.h"
#include "gtkradiotoolbutton.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define MENU_ID "gtk-toggle-tool-button-menu-id"
P_("The orientation of the toolbar"),
GTK_TYPE_ORIENTATION,
GTK_ORIENTATION_HORIZONTAL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TOOLBAR_STYLE,
P_("How to draw the toolbar"),
GTK_TYPE_TOOLBAR_STYLE,
GTK_TOOLBAR_ICONS,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_ARROW,
g_param_spec_boolean ("show-arrow",
P_("Show Arrow"),
P_("If an arrow should be shown if the toolbar doesn't fit"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/* child properties */
gtk_container_class_install_child_property (container_class,
P_("Expand"),
P_("Whether the item should receive extra space when the toolbar grows"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_container_class_install_child_property (container_class,
CHILD_PROP_HOMOGENEOUS,
P_("Homogeneous"),
P_("Whether the item should be the same size as other homogeneous items"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/* style properties */
gtk_widget_class_install_style_property (widget_class,
0,
G_MAXINT,
DEFAULT_SPACE_SIZE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("internal-padding",
0,
G_MAXINT,
DEFAULT_IPADDING,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_enum ("space-style",
P_("Whether spacers are vertical lines or just blank"),
GTK_TYPE_TOOLBAR_SPACE_STYLE,
DEFAULT_SPACE_STYLE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_enum ("button-relief",
P_("Type of bevel around toolbar buttons"),
GTK_TYPE_RELIEF_STYLE,
GTK_RELIEF_NONE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_enum ("shadow-type",
P_("Shadow type"),
P_("Style of bevel around the toolbar"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_OUT,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_settings_install_property (g_param_spec_enum ("gtk-toolbar-style",
P_("Toolbar style"),
P_("Whether default toolbars have text only, text and icons, icons only, etc."),
GTK_TYPE_TOOLBAR_STYLE,
DEFAULT_TOOLBAR_STYLE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
gtk_settings_install_property (g_param_spec_enum ("gtk-toolbar-icon-size",
P_("Toolbar icon size"),
P_("Size of icons in default toolbars"),
GTK_TYPE_ICON_SIZE,
DEFAULT_ICON_SIZE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
binding_set = gtk_binding_set_by_class (klass);
#include "gtkintl.h"
#include "gtktoolbar.h"
#include "gtkiconfactory.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#include <string.h>
P_("Label"),
P_("Text to show in the item."),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_USE_UNDERLINE,
g_param_spec_boolean ("use-underline",
P_("Use underline"),
P_("If set, an underline in the label property indicates that the next character should be used for the mnemonic accelerator key in the overflow menu"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LABEL_WIDGET,
g_param_spec_object ("label-widget",
P_("Label widget"),
P_("Widget to use as the item label"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_ID,
g_param_spec_string ("stock-id",
P_("Stock Id"),
P_("The stock icon displayed on the item"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_ICON_WIDGET,
g_param_spec_object ("icon-widget",
P_("Icon widget"),
P_("Icon widget to display in the item"),
GTK_TYPE_WIDGET,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkToolButton::clicked:
#include "gtkintl.h"
#include "gtkmain.h"
#include "gtkalias.h"
+#include "gtkprivate.h"
#include <string.h>
P_("Visible when horizontal"),
P_("Whether the toolbar item is visible when the toolbar is in a horizontal orientation."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_VISIBLE_VERTICAL,
g_param_spec_boolean ("visible-vertical",
P_("Visible when vertical"),
P_("Whether the toolbar item is visible when the toolbar is in a vertical orientation."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_IS_IMPORTANT,
g_param_spec_boolean ("is-important",
P_("Is important"),
P_("Whether the toolbar item is considered important. When TRUE, toolbar buttons show text in GTK_TOOLBAR_BOTH_HORIZ mode"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkToolItem::create-menu-proxy:
#include "gtkintl.h"
#include "gtktreednd.h"
#include "gtkalias.h"
+#include "gtkprivate.h"
#include <string.h>
/* ITER FORMAT:
("The child model"),
("The model for the filtermodel to filter"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class,
PROP_VIRTUAL_ROOT,
("The virtual root"),
("The virtual root (relative to the child model) for this filtermodel"),
GTK_TYPE_TREE_PATH,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (object_class, sizeof (GtkTreeModelFilterPrivate));
}
#include "gtktreestore.h"
#include "gtktreedatalist.h"
#include "gtkintl.h"
+#include "gtkprivate.h"
#include "gtktreednd.h"
#include "gtkalias.h"
P_("TreeModelSort Model"),
P_("The model for the TreeModelSort to sort"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}
static void
#include "gtkentry.h"
#include "gtkframe.h"
#include "gtktreemodelsort.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
P_("TreeView Model"),
P_("The model for the tree view"),
GTK_TYPE_TREE_MODEL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_HADJUSTMENT,
P_("Horizontal Adjustment"),
P_("Horizontal Adjustment for the widget"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_VADJUSTMENT,
P_("Vertical Adjustment"),
P_("Vertical Adjustment for the widget"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_HEADERS_VISIBLE,
P_("Headers Visible"),
P_("Show the column header buttons"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_HEADERS_CLICKABLE,
P_("Headers Clickable"),
P_("Column headers respond to click events"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_EXPANDER_COLUMN,
P_("Expander Column"),
P_("Set the column for the expander column"),
GTK_TYPE_TREE_VIEW_COLUMN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_REORDERABLE,
P_("Reorderable"),
P_("View is reorderable"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_RULES_HINT,
P_("Rules Hint"),
P_("Set a hint to the theme engine to draw rows in alternating colors"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_ENABLE_SEARCH,
P_("Enable Search"),
P_("View allows user to search through columns interactively"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (o_class,
PROP_SEARCH_COLUMN,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkTreeView:fixed-height-mode:
P_("Fixed Height Mode"),
P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkTreeView:hover-selection:
P_("Hover Selection"),
P_("Whether the selection should follow the pointer"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkTreeView:hover-expand:
P_("Hover Expand"),
P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/* Style properties */
#define _TREE_VIEW_EXPANDER_SIZE 12
0,
G_MAXINT,
_TREE_VIEW_EXPANDER_SIZE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("vertical-separator",
0,
G_MAXINT,
_TREE_VIEW_VERTICAL_SEPARATOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("horizontal-separator",
0,
G_MAXINT,
_TREE_VIEW_HORIZONTAL_SEPARATOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("allow-rules",
P_("Allow Rules"),
P_("Allow drawing of alternating color rows"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boolean ("indent-expanders",
P_("Indent Expanders"),
P_("Make the expanders indented"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boxed ("even-row-color",
P_("Even Row Color"),
P_("Color to use for even rows"),
GDK_TYPE_COLOR,
-G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_boxed ("odd-row-color",
P_("Odd Row Color"),
P_("Color to use for odd rows"),
GDK_TYPE_COLOR,
-G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/* Signals */
widget_class->set_scroll_adjustments_signal =
#include "gtkhbox.h"
#include "gtkmarshalers.h"
#include "gtkarrow.h"
+#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
P_("Visible"),
P_("Whether to display the column"),
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_RESIZABLE,
P_("Resizable"),
P_("Column is user-resizable"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_WIDTH,
0,
G_MAXINT,
0,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_SPACING,
g_param_spec_int ("spacing",
0,
G_MAXINT,
0,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SIZING,
g_param_spec_enum ("sizing",
P_("Resize mode of the column"),
GTK_TYPE_TREE_VIEW_COLUMN_SIZING,
GTK_TREE_VIEW_COLUMN_GROW_ONLY,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_FIXED_WIDTH,
1,
G_MAXINT,
1, /* not useful */
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MIN_WIDTH,
-1,
G_MAXINT,
-1,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MAX_WIDTH,
-1,
G_MAXINT,
-1,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_TITLE,
P_("Title"),
P_("Title to appear in column header"),
"",
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_EXPAND,
P_("Expand"),
P_("Column gets share of extra width allocated to the widget"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_CLICKABLE,
P_("Clickable"),
P_("Whether the header can be clicked"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
P_("Widget"),
P_("Widget to put in column header button instead of column title"),
GTK_TYPE_WIDGET,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_ALIGNMENT,
0.0,
1.0,
0.0,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_REORDERABLE,
P_("Reorderable"),
P_("Whether the column can be reordered around the headers"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SORT_INDICATOR,
P_("Sort indicator"),
P_("Whether to show a sort indicator"),
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_SORT_ORDER,
P_("Sort direction the sort indicator should indicate"),
GTK_TYPE_SORT_TYPE,
GTK_SORT_ASCENDING,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ GTK_PARAM_READWRITE));
}
#include "gtktearoffmenuitem.h"
#include "gtktoolbar.h"
#include "gtkuimanager.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
#undef DEBUG_UI_MANAGER
P_("Add tearoffs to menus"),
P_("Whether tearoff menu items should be added to menus"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_UI,
P_("Merged UI definition"),
P_("An XML string describing the merged UI"),
NULL,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
/**
#include "gtkviewport.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtkprivate.h"
#include "gtkalias.h"
enum {
P_("Horizontal adjustment"),
P_("The GtkAdjustment that determines the values of the horizontal position for this viewport"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_VADJUSTMENT,
P_("Vertical adjustment"),
P_("The GtkAdjustment that determines the values of the vertical position for this viewport"),
GTK_TYPE_ADJUSTMENT,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
P_("Determines how the shadowed box around the viewport is drawn"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_IN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
widget_class->set_scroll_adjustments_signal =
g_signal_new ("set_scroll_adjustments",
P_("Widget name"),
P_("The name of the widget"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PARENT,
g_param_spec_object ("parent",
P_("Parent widget"),
P_("The parent widget of this widget. Must be a Container widget"),
GTK_TYPE_CONTAINER,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WIDTH_REQUEST,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HEIGHT_REQUEST,
g_param_spec_int ("height-request",
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VISIBLE,
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether the widget is visible"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SENSITIVE,
g_param_spec_boolean ("sensitive",
P_("Sensitive"),
P_("Whether the widget responds to input"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_APP_PAINTABLE,
g_param_spec_boolean ("app-paintable",
P_("Application paintable"),
P_("Whether the application will paint directly on the widget"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CAN_FOCUS,
g_param_spec_boolean ("can-focus",
P_("Can focus"),
P_("Whether the widget can accept the input focus"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HAS_FOCUS,
g_param_spec_boolean ("has-focus",
P_("Has focus"),
P_("Whether the widget has the input focus"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_IS_FOCUS,
g_param_spec_boolean ("is-focus",
P_("Is focus"),
P_("Whether the widget is the focus widget within the toplevel"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_CAN_DEFAULT,
g_param_spec_boolean ("can-default",
P_("Can default"),
P_("Whether the widget can be the default widget"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HAS_DEFAULT,
g_param_spec_boolean ("has-default",
P_("Has default"),
P_("Whether the widget is the default widget"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RECEIVES_DEFAULT,
g_param_spec_boolean ("receives-default",
P_("Receives default"),
P_("If TRUE, the widget will receive the default action when it is focused"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_COMPOSITE_CHILD,
g_param_spec_boolean ("composite-child",
P_("Composite child"),
P_("Whether the widget is part of a composite widget"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_STYLE,
g_param_spec_object ("style",
P_("Style"),
P_("The style of the widget, which contains information about how it will look (colors etc)"),
GTK_TYPE_STYLE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_EVENTS,
g_param_spec_flags ("events",
P_("The event mask that decides what kind of GdkEvents this widget gets"),
GDK_TYPE_EVENT_MASK,
GDK_STRUCTURE_MASK,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_EXTENSION_EVENTS,
g_param_spec_enum ("extension-events",
P_("The mask that decides what kind of extension events this widget gets"),
GDK_TYPE_EXTENSION_MODE,
GDK_EXTENSION_EVENTS_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_NO_SHOW_ALL,
g_param_spec_boolean ("no-show-all",
P_("No show all"),
P_("Whether gtk_widget_show_all() should not affect this widget"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
widget_signals[SHOW] =
g_signal_new ("show",
G_TYPE_FROM_CLASS (gobject_class),
P_("Interior Focus"),
P_("Whether to draw the focus indicator inside widgets"),
TRUE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_int ("focus-line-width",
P_("Focus linewidth"),
P_("Width, in pixels, of the focus indicator line"),
0, G_MAXINT, 1,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_string ("focus-line-pattern",
P_("Focus line dash pattern"),
P_("Dash pattern used to draw the focus indicator"),
"\1\1",
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_int ("focus-padding",
P_("Focus padding"),
P_("Width, in pixels, between focus indicator and the widget 'box'"),
0, G_MAXINT, 1,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_boxed ("cursor-color",
P_("Cursor color"),
P_("Color with which to draw insertion cursor"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_boxed ("secondary-cursor-color",
P_("Secondary cursor color"),
P_("Color with which to draw the secondary insertion cursor when editing mixed right-to-left and left-to-right text"),
GDK_TYPE_COLOR,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
gtk_widget_class_install_style_property (klass,
g_param_spec_float ("cursor-aspect-ratio",
P_("Cursor line aspect ratio"),
P_("Aspect ratio with which to draw insertion cursor"),
0.0, 1.0, 0.04,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
}
static void
P_("The type of the window"),
GTK_TYPE_WINDOW_TYPE,
GTK_WINDOW_TOPLEVEL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/* Regular Props */
g_object_class_install_property (gobject_class,
PROP_TITLE,
P_("Window Title"),
P_("The title of the window"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ROLE,
P_("Window Role"),
P_("Unique identifier for the window to be used when restoring a session"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ALLOW_SHRINK,
/* xgettext:no-c-format */
P_("If TRUE, the window has no mimimum size. Setting this to TRUE is 99% of the time a bad idea"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ALLOW_GROW,
P_("Allow Grow"),
P_("If TRUE, users can expand the window beyond its minimum size"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RESIZABLE,
P_("Resizable"),
P_("If TRUE, users can resize the window"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MODAL,
P_("Modal"),
P_("If TRUE, the window is modal (other windows are not usable while this one is up)"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WIN_POS,
P_("The initial position of the window"),
GTK_TYPE_WINDOW_POSITION,
GTK_WIN_POS_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DEFAULT_WIDTH,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DEFAULT_HEIGHT,
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DESTROY_WITH_PARENT,
P_("Destroy with Parent"),
P_("If this window should be destroyed when the parent is destroyed"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ICON,
P_("Icon"),
P_("Icon for this window"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:icon-name:
P_("Icon Name"),
P_("Name of the themed icon for this window"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SCREEN,
P_("Screen"),
P_("The screen where this window will be displayed"),
GDK_TYPE_SCREEN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_IS_ACTIVE,
P_("Is Active"),
P_("Whether the toplevel is the current active window"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_HAS_TOPLEVEL_FOCUS,
P_("Focus in Toplevel"),
P_("Whether the input focus is within this GtkWindow"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_TYPE_HINT,
P_("Hint to help the desktop environment understand what kind of window this is and how to treat it."),
GDK_TYPE_WINDOW_TYPE_HINT,
GDK_WINDOW_TYPE_HINT_NORMAL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SKIP_TASKBAR_HINT,
P_("Skip taskbar"),
P_("TRUE if the window should not be in the task bar."),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SKIP_PAGER_HINT,
P_("Skip pager"),
P_("TRUE if the window should not be in the pager."),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:accept-focus-hint:
P_("Accept focus"),
P_("TRUE if the window should receive the input focus."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:focus-on-map-hint:
P_("Focus on map"),
P_("TRUE if the window should receive the input focus when mapped."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:decorated:
P_("Decorated"),
P_("Whether the window should be decorated by the window manager"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:gravity:
P_("The window gravity of the window"),
GDK_TYPE_GRAVITY,
GDK_GRAVITY_NORTH_WEST,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
window_signals[SET_FOCUS] =
g_signal_new ("set_focus",
projects / ~andy / gtk / commitdiff