Mostly correcting it's to its and changing some , to .
* composited and therefore is no longer automatically drawn to the screen.
*
* When the contents of the event box change, an expose event is generated on
- * it's parent window (which, in this case, belongs to the toplevel #GtkWindow).
+ * its parent window (which, in this case, belongs to the toplevel #GtkWindow).
* The expose handler for this widget is responsible for merging the changes
* back on the screen in the way that it wishes.
*
}
else if (timeout > 0)
{
- /* We need to get the run loop to break out of it's wait when our timeout
+ /* We need to get the run loop to break out of its wait when our timeout
* expires. We do this by adding a dummy timer that we'll remove immediately
* after the wait wakes up.
*/
{
guint keysym = gdk_unicode_to_keyval (wcs[0]);
- /* It is a dead key, and it's has been stored in
+ /* It is a dead key, and it has been stored in
* the keyboard layout's state by
* ToAsciiEx()/ToUnicodeEx(). Yes, this is an
* incredibly silly API! Make the keyboard
*
* The GtkBuildable interface is implemented by all widgets and
* many of the non-widget objects that are provided by GTK+. The
- * main user of this interface is #GtkBuilder, there should be
+ * main user of this interface is #GtkBuilder. There should be
* very little need for applications to call any
* <function>gtk_buildable_...</function> functions.
*
* GtkButton:xalign:
*
* If the child of the button is a #GtkMisc or #GtkAlignment, this property
- * can be used to control it's horizontal alignment. 0.0 is left aligned,
+ * can be used to control its horizontal alignment. 0.0 is left aligned,
* 1.0 is right aligned.
*
* Since: 2.4
* GtkButton:yalign:
*
* If the child of the button is a #GtkMisc or #GtkAlignment, this property
- * can be used to control it's vertical alignment. 0.0 is top aligned,
+ * can be used to control its vertical alignment. 0.0 is top aligned,
* 1.0 is bottom aligned.
*
* Since: 2.4
* size requests and allocations for a given row of data.
*
* Usually users dont have to interact with the #GtkCellArea directly
- * unless they are implementing a cell layouting widget themselves.
+ * unless they are implementing a cell-layouting widget themselves.
*
* <refsect2 id="cell-area-geometry-management">
* <title>Requesting area sizes</title>
* size of an area for an arbitrary number of #GtkTreeModel rows.
*
* When requesting the size of a cell area one needs to calculate
- * the size for a handful of rows, this will be done differently by
+ * the size for a handful of rows, and this will be done differently by
* different layouting widgets. For instance a #GtkTreeViewColumn
* always lines up the areas from top to bottom while a #GtkIconView
* on the other hand might enforce that all areas received the same
*
* The #GtkCellAreaContext is an opaque object specific to the
* #GtkCellArea which created it (see gtk_cell_area_create_context()).
- * The owning cell layouting widget can create as many contexts as
+ * The owning cell-layouting widget can create as many contexts as
* it wishes to calculate sizes of rows which should receive the
* same size in at least one orientation (horizontally or vertically),
- * however it's important that the same #GtkCellAreaContext which
+ * However, it's important that the same #GtkCellAreaContext which
* was used to request the sizes for a given #GtkTreeModel row be
* used when rendering or processing events for that row.
*
* </example>
* Note that in this example it's not important to observe the
* returned minimum and natural width of the area for each row
- * unless the cell layouting object is actually interested in the
+ * unless the cell-layouting object is actually interested in the
* widths of individual rows. The overall width is however stored
* in the accompanying #GtkCellAreaContext object and can be consulted
* at any time.
* Requesting the height for width (or width for height) of an area is
* a similar task except in this case the #GtkCellAreaContext does not
* store the data (actually, it does not know how much space the layouting
- * widget plans to allocate it for every row, it's up to the layouting
+ * widget plans to allocate it for every row. It's up to the layouting
* widget to render each row of data with the appropriate height and
* width which was requested by the #GtkCellArea).
*
* </example>
* Note that the cached height in this example really depends on how
* the layouting widget works. The layouting widget might decide to
- * give every row it's minimum or natural height or, if the model content
+ * give every row its minimum or natural height or, if the model content
* is expected to fit inside the layouting widget without scrolling, it
* would make sense to calculate the allocation for each row at
* #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
* for #GtkWidgets. This provides some general interfaces for defining
* the relationship cell areas have with their cells. For instance in a
* #GtkCellAreaBox a cell might "expand" and receive extra space when
- * the area is allocated more than it's full natural request, or a cell
+ * the area is allocated more than its full natural request, or a cell
* might be configured to "align" with adjacent rows which were requested
* and rendered with the same #GtkCellAreaContext.
*
* @path: the #GtkTreePath string this edit was initiated for
*
* Indicates that editing has started on @renderer and that @editable
- * should be added to the owning cell layouting widget at @cell_area.
+ * should be added to the owning cell-layouting widget at @cell_area.
*
* Since: 3.0
*/
* @editable: the #GtkCellEditable widget to remove
*
* Indicates that editing finished on @renderer and that @editable
- * should be removed from the owning cell layouting widget.
+ * should be removed from the owning cell-layouting widget.
*
* Since: 3.0
*/
* the specified @width.
*
* @area stores some geometrical information in @context along the way
- * while calling gtk_cell_area_get_preferred_width(), it's important to
+ * while calling gtk_cell_area_get_preferred_width(). It's important to
* perform a series of gtk_cell_area_get_preferred_width() requests with
* @context first and then call gtk_cell_area_get_preferred_height_for_width()
* on each cell area individually to get the height for width of each
* the specified @height.
*
* @area stores some geometrical information in @context along the way
- * while calling gtk_cell_area_get_preferred_height(), it's important to
+ * while calling gtk_cell_area_get_preferred_height(). It's important to
* perform a series of gtk_cell_area_get_preferred_height() requests with
* @context first and then call gtk_cell_area_get_preferred_width_for_height()
* on each cell area individually to get the height for width of each
* for a given @direction and row data.
*
* Implementing #GtkCellArea classes should implement this
- * method to receive and navigate focus in it's own way particular
+ * method to receive and navigate focus in its own way particular
* to how it lays out cells.
*
* Return value: %TRUE if focus remains inside @area as a result of this call.
* @sibling: the #GtkCellRenderer to add to @renderer's focus area
*
* Adds @sibling to @renderer's focusable area, focus will be drawn
- * around @renderer and all of it's siblings if @renderer can
+ * around @renderer and all of its siblings if @renderer can
* focus for a given row.
*
* Events handled by focus siblings can also activate the given
*
* This is used by #GtkCellArea subclasses when handling events
* to activate cells, the base #GtkCellArea class activates cells
- * for keyboard events for free in it's own GtkCellArea->activate()
+ * for keyboard events for free in its own GtkCellArea->activate()
* implementation.
*
* Return value: whether cell activation was successful
info = g_hash_table_lookup (priv->cell_info, cell);
/* Note we do not take a reference to the proxy, the proxy is a GtkCellLayout
- * that is forwarding it's implementation to a delegate GtkCellArea therefore
- * it's life-cycle is longer than the area's life cycle.
+ * that is forwarding its implementation to a delegate GtkCellArea therefore
+ * its life-cycle is longer than the area's life cycle.
*/
if (info)
{
}
/* Now we have the allocation for the group,
- * request it's height-for-width
+ * request its height-for-width
*/
compute_group_size_for_opposing_orientation (box, group, widget,
orientation_sizes[i].minimum_size,
* @Title: GtkCellAreaContext
*
* The #GtkCellAreaContext object is created by a given #GtkCellArea
- * implementation via it's #GtkCellAreaClass.create_context() virtual
+ * implementation via its #GtkCellAreaClass.create_context() virtual
* method and is used to store cell sizes and alignments for a series of
* #GtkTreeModel rows that are requested and rendered in the same context.
*
* fetch information about the area it is being used for.
*
* For instance at #GtkCellAreaContextClass.allocate() time
- * it's important to know details about any cell spacing
+ * its important to know details about any cell spacing
* that the #GtkCellArea is configured with in order to
* compute a proper allocation.
*
* Resets any previously cached request and allocation
* data.
*
- * When underlying #GtkTreeModel data changes it's
+ * When underlying #GtkTreeModel data changes its
* important to reset the context if the content
* size is allowed to shrink. If the content size
* is only allowed to grow (this is usually an option
* is rendered in the correct location using gtk_cell_renderer_render().
*
* There are a number of rules that must be followed when writing a new
- * #GtkCellRenderer. First and formost, it's important that a certain set
+ * #GtkCellRenderer. First and formost, its important that a certain set
* of properties will always yield a cell renderer of the same size,
* barring a #GtkStyle change. The #GtkCellRenderer also has a number of
* generic properties that are expected to be honored by all children.
/* Default implementation assumes that a cell renderer will never use more
- * space than it's natural size (this is fine for toggles and pixbufs etc
+ * space than its natural size (this is fine for toggles and pixbufs etc
* but needs to be overridden from wrapping/ellipsizing text renderers) */
static void
gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
* the same context.
*
* #GtkComboBox menus uses this to assign the same context to all cell views
- * in the menu items for a single menu (each submenu creates it's own
+ * in the menu items for a single menu (each submenu creates its own
* context since the size of each submenu does not depend on parent
* or sibling menus).
*
* gtk_cell_view_get_draw_sensitive:
* @cell_view: a #GtkCellView
*
- * Gets whether @cell_view is configured to draw all of it's
+ * Gets whether @cell_view is configured to draw all of its
* cells in a sensitive state.
*
- * Return value: whether @cell_view draws all of it's
+ * Return value: whether @cell_view draws all of its
* cells in a sensitive state
*
* Since: 3.0
* @cell_view: a #GtkCellView
* @draw_sensitive: whether to draw all cells in a sensitive state.
*
- * Sets whether @cell_view should draw all of it's
+ * Sets whether @cell_view should draw all of its
* cells in a sensitive state, this is used by #GtkComboBox menus
* to ensure that rows with insensitive cells that contain
* children appear sensitive in the parent menu item.
g_return_if_fail (GTK_IS_WIDGET (tmp_list->data));
/* In principle each widget in the chain should be a descendant
- * of the container, but we don't want to check that here, it's
+ * of the container, but we don't want to check that here. It's
* expensive and also it's allowed to set the focus chain before
* you pack the widgets, or have a widget in the chain that isn't
* always packed. So we check for ancestor during actual traversal.
* This is a helper function for GtkComboBox. A GtkEntry in a GtkComboBox
* is supposed to behave like a GtkCellEditable when placed in a combo box.
*
- * I.e take up it's allocation and get GtkEntry->is_cell_renderer = TRUE.
+ * I.e take up its allocation and get GtkEntry->is_cell_renderer = TRUE.
*
*/
void
if (!priv->heights || priv->heights_length < gtk_menu_get_n_rows (menu))
return FALSE;
- /* when we have a row with only invisible children, it's height will
+ /* when we have a row with only invisible children, its height will
* be zero, so there's no need to check WIDGET_VISIBLE here
*/
for (i = 0; i < item_top_attach; i++)
* @size_fixed: %TRUE to make the slider size constant
*
* Sets whether the range's slider has a fixed size, or a size that
- * depends on it's adjustment's page size.
+ * depends on its adjustment's page size.
*
* This function is useful mainly for #GtkRange subclasses.
*
* @base_widget will be returned.
* The general purpose of this function is to find the most likely "action"
* widget, relative to another labeling widget. Such as finding a
- * button or text entry widget, given it's corresponding label widget.
+ * button or text entry widget, given its corresponding label widget.
*
* Returns: (transfer none): a widget of type @widget_type if any is found.
*
area.y -= text_view->priv->yoffset;
/* Width returned by Pango indicates direction of cursor,
- * by it's sign more than the size of cursor.
+ * by its sign more than the size of cursor.
*/
area.width = 0;
G_CALLBACK (gtk_tool_palette_adjustment_value_changed),
palette);
priv->hadjustment = g_object_ref_sink (adjustment);
- /* FIXME: Adjustment should probably have it's values updated now */
+ /* FIXME: Adjustment should probably have its values updated now */
g_object_notify (G_OBJECT (palette), "hadjustment");
}
G_CALLBACK (gtk_tool_palette_adjustment_value_changed),
palette);
priv->vadjustment = g_object_ref_sink (adjustment);
- /* FIXME: Adjustment should probably have it's values updated now */
+ /* FIXME: Adjustment should probably have its values updated now */
g_object_notify (G_OBJECT (palette), "vadjustment");
}
*
* If you dont provide a root for the #GtkTreeMenu then the whole
* model will be added to the menu. Specifying a root allows you
- * to build a menu for a given #GtkTreePath and it's children.
+ * to build a menu for a given #GtkTreePath and its children.
*
* Since: 3.0
*/
path = gtk_tree_row_reference_get_path (row);
if (!path)
- /* Return any first child where it's row-reference became invalid,
+ /* Return any first child where its row-reference became invalid,
* this is because row-references get null paths before we recieve
* the "row-deleted" signal.
*/
path = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (view));
if (!path)
- /* Return any first child where it's row-reference became invalid,
+ /* Return any first child where its row-reference became invalid,
* this is because row-references get null paths before we recieve
* the "row-deleted" signal.
*/
depth = gtk_tree_path_get_depth (path);
index = indices[depth -1];
- /* Menus with a header include a menuitem for it's root node
+ /* Menus with a header include a menuitem for its root node
* and a separator menu item */
if (priv->menu_with_header)
index += 2;
* _gtk_tree_menu_new_with_area:
* @area: the #GtkCellArea to use to render cells in the menu
*
- * Creates a new #GtkTreeMenu using @area to render it's cells.
+ * Creates a new #GtkTreeMenu using @area to render its cells.
*
* Return value: A newly created #GtkTreeMenu with no model or root.
*
* @model: (allow-none): the #GtkTreeModel to build the menu heirarchy from, or %NULL.
* @root: (allow-none): the #GtkTreePath indicating the root row for this menu, or %NULL.
*
- * Creates a new #GtkTreeMenu hierarchy from the provided @model and @root using @area to render it's cells.
+ * Creates a new #GtkTreeMenu hierarchy from the provided @model and @root using @area to render its cells.
*
* Return value: A newly created #GtkTreeMenu.
*
* gtk_tree_view_column_new_with_area:
* @area: the #GtkCellArea that the newly created column should use to layout cells.
*
- * Creates a new #GtkTreeViewColumn using @area to render it's cells.
+ * Creates a new #GtkTreeViewColumn using @area to render its cells.
*
* Return value: A newly created #GtkTreeViewColumn.
*
* queues a resize to ensure there's enough space for the new text.
*
* <note><para>You cannot call gtk_widget_queue_resize() on a widget
- * from inside it's implementation of the GtkWidgetClass::size_allocate
+ * from inside its implementation of the GtkWidgetClass::size_allocate
* virtual method. Calls to gtk_widget_queue_resize() from inside
* GtkWidgetClass::size_allocate will be silently ignored.</para></note>
**/
_gtk_widget_set_is_toplevel (widget, TRUE);
/* When a window becomes toplevel after being embedded and anchored
- * into another window we need to unset it's anchored flag so that
+ * into another window we need to unset its anchored flag so that
* the hierarchy changed signal kicks in properly.
*/
_gtk_widget_set_anchored (widget, FALSE);
gail_return_val_if_fail (renderers, FALSE);
/*
- * If the cell is in a container, it's index is used to find the renderer
+ * If the cell is in a container, its index is used to find the renderer
* in the list
*/
gail_return_if_fail (renderers);
/*
- * if the cell is in a container, it's index is used to find the
+ * if the cell is in a container, its index is used to find the
* renderer in the list
*/
else
{
/* XXX A real implementation should check if the
- * previous row can focus with it's attributes setup */
+ * previous row can focus with its attributes setup */
focus_row--;
valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
}
else
{
/* XXX A real implementation should check if the
- * previous row can focus with it's attributes setup */
+ * previous row can focus with its attributes setup */
focus_row++;
valid = gtk_tree_model_iter_next (priv->model, &iter);
}
projects / ~andy / gtk / commitdiff