+2001-06-03 Matthias Clasen <matthiasc@poet.de>
+
+ * glib/tmpl/caches.sgml, glib/tmpl/main.sgml,
+ gobject/gobject-docs.sgml, gobject/tmpl/generic_values.sgml,
+ gobject/tmpl/gtypemodule.sgml, gobject/tmpl/signals.sgml,
+ gobject/tmpl/types.sgml: fix some typos.
+
Thu Jun 28 17:43:29 2001 Owen Taylor <otaylor@redhat.com>
* glib/tmpl/memory.sgml glib/tmpl/macros_misc.sgml: Add
</para>
<para>
GTK uses a #GCache for both GtkStyles and GdkGCs. These consume a lot of
-resouces, so a #GCache is used to see if a GtkStyle or GdkGC with the
+resources, so a #GCache is used to see if a GtkStyle or GdkGC with the
required properties already exists. If it does, then the existing
GtkStyle or GdkGC is used instead of creating a new one.
</para>
type is used for handling GDK events. A new source type is
created by <firstterm>deriving</firstterm> from the #GSource
structure. The derived type of source is represented by a
- structure that has the #GSource structure as a first elemeent,
+ structure that has the #GSource structure as a first element,
and other elements specific to the new source type. To create
an instance of the new source type, call g_source_new() passing
in the size of the derived structure and a table of functions.
doubles, enums and structured types, to name a few.
</para></listitem></varlistentry>
<varlistentry><term></term><listitem><para>
- * A sample fundamental type implementation to base object hirachies
+ * A sample fundamental type implementation to base object hierarchies
upon - the GObject fundamental type.
</para></listitem></varlistentry>
<varlistentry><term></term><listitem><para>
- * A signal system that allowes very flexible user customization of
- virtual/overridable object methods and can serve as a powerfull
+ * A signal system that allows very flexible user customization of
+ virtual/overridable object methods and can serve as a powerful
notification mechanism.
</para></listitem></varlistentry>
<varlistentry><term></term><listitem><para>
The type identifier within a #GValue structure always determines the
type of the associated value.
To create a undefined #GValue structure, simply create a zero-filled
-#GValue structure. To intialize the #GValue, use the g_value_init()
+#GValue structure. To initialize the #GValue, use the g_value_init()
function. A #GValue cannot be used until it is initialized.
The basic type operations (such as freeing and copying) are determined
by the #GTypeValueTable associated with the type ID stored in the #GValue.
does not allow NULL pointers, it needs to either spew an error,
or do an implicit conversion by storing an empty string.
The @value passed in to this function has a zero-filled data
- array, so just like for @value_init it is guarranteed to not
+ array, so just like for @value_init it is guaranteed to not
contain any old contents that might need freeing.
@n_collect_values is exactly the string length of @collect_format,
and @collect_values is an array of unions #GTypeCValue with
regardless of @collect_flags. For invalid objects, the example
returns a newly allocated string without altering @value.
Upon success, collect_value() needs to return NULL, if however
- a malicious condition occoured, collect_value() may spew an
+ a malicious condition occurred, collect_value() may spew an
error by returning a newly allocated non-NULL string, giving
a suitable description of the error condition.
The calling code makes no assumptions about the @value
any non-NULL return is considered a fatal condition so further
program behaviour is undefined.
@lcopy_format: Format description of the arguments to collect for @lcopy_value,
- analogous to @collect_format. Usually, @lcopy_format string consist
+ analogous to @collect_format. Usually, @lcopy_format string consists
only of 'p's to provide lcopy_value() with pointers to storage locations.
@lcopy_value: This function is responsible for storing the @value contents into
arguments passed through a variable argument list which got
#GTypeModule provides a simple implementation of the #GTypePlugin
interface. The model of #GTypeModule is a dynamically loaded module
which implements some number of types and interface
-implementations. When the module is loaded, it registerse its types
+implementations. When the module is loaded, it registers its types
and interfaces using g_type_module_register_type() and
g_type_module_add_interface(). As long as any instances of these
types and interface implementations are in use, the module is kept
Keeping track of whether the module should be loaded or not is done by
using a use count - it starts at zero, and whenever it is greater than
zero, the module is loaded. The use count is maintained internally by
-the type system, but also can be explicitely controlled by
+the type system, but also can be explicitly controlled by
g_type_module_use() and g_type_module_unuse(). Typically, when loading
a module for the first type, g_type_module_use() will be used to load
it so that it can initialize its types. At some later point, when the
The basic concept of the signal system is that of the <emphasis>emission</emphasis>
of a signal.
Signals are introduced per-type and are identified through strings.
-Signals introduced for a parent type are availale in derived types as well,
+Signals introduced for a parent type are available in derived types as well,
so basically they are a per-type facility that is inherited.
A signal emission mainly involves invocation of a certain set of callbacks in
precisely defined manner. There are two main categories of such callbacks,
per-object
- <footnote><para> Although signals can deal with any kind of instantiatable type,
+ <footnote><para>Although signals can deal with any kind of instantiatable type,
i'm referring to those types as "object types" in the following, simply
because that is the context most users will encounter signals in.
</para></footnote>
to collect return values of the various callbacks that are called
during a signal emission. The signal accumulator is specified at signal
creation time, if it is left NULL, no accumulation of callback return
-values is perfomed. The return value of signal emissions is then the
+values is performed. The return value of signal emissions is then the
value returned by the last callback.
</para>
-@ihint: Signal invokation hint, see #GSignalInvocationHint.
+@ihint: Signal invocation hint, see #GSignalInvocationHint.
@return_accu: Accumulator to collect callback return values in, this
is the return value of the current signal emission.
@handler_return:
This is the signature of marshaller functions, required to marshall
arrays of parameter values to signal emissions into C language callback
invocations. It is merely an alias to #GClosureMarshal since the #GClosure
-mechanism takes over responsibility of actuall function invocation for the
+mechanism takes over responsibility of actual function invocation for the
signal system.
</para>
<!-- ##### ENUM GSignalFlags ##### -->
<para>
-The signal flags are used to specify a signal's behaviour, the overrall
-signal description outlines how especially the RUN flags controll the
+The signal flags are used to specify a signal's behaviour, the overall
+signal description outlines how especially the RUN flags control the
stages of a signal emission.
</para>
emission for this very object will not be emitted recursively,
but instead cause the first emission to be restarted.
@G_SIGNAL_DETAILED: This signal supports "::detail" appendixes to the signal name
- upon hanlder connections and emissions.
+ upon handler connections and emissions.
@G_SIGNAL_ACTION: Action signals are signals that may freely be emitted on alive
objects from user code via g_signal_emit() and friends, without
the need of being embedded into extra code that performs pre or
post emission adjustments on the object. They can also be thought
- of as by third-party code generically callable obejct methods.
+ of as by third-party code generically callable object methods.
@G_SIGNAL_NO_HOOKS: No emissions hooks are supported for this signal.
<!-- ##### ENUM GSignalMatchType ##### -->
filled in by the g_signal_query() function.
</para>
-@signal_id: The signal id of the signal being querried, or 0 if the
- signal to be querried was unknown.
+@signal_id: The signal id of the signal being queried, or 0 if the
+ signal to be queried was unknown.
@signal_name: The signal name.
@itype: The interface/instance type that this signal can be emitted for.
@signal_flags: The signal flags as passed in to g_signal_new().
Query the signal system for in-depth information about a
specific signal. This function will fill in a user-provided
structure to hold signal-specific information. If an invalid
-dignal id is passed in, the @signal_id member of the #GSignalQuery
+signal id is passed in, the @signal_id member of the #GSignalQuery
is 0. All members filled into the #GSignalQuery structure should
be considered constant and have to be left untouched.
</para>
<!-- ##### FUNCTION g_signal_list_ids ##### -->
<para>
List the signals by id, that a certain instance or interface type
-created. Further information about the signals can be aquired through
+created. Further information about the signals can be acquired through
g_signal_query().
</para>
Find the first signal handler that matches certain selection criteria.
The criteria mask is passed as an OR-ed combination of #GSignalMatchType
flags, and the criteria values are passed as arguments.
-The match @mask has to be non-0 for successfull matches.
+The match @mask has to be non-0 for successful matches.
If no handler was found, 0 is returned.
</para>
@closure: The closure the handler will invoke.
@func: The C closure callback of the handler (useless for non-C closures).
@data: The closure data of the handler's closure.
-@Returns: A valid non-0 signal handler id for a successfull match.
+@Returns: A valid non-0 signal handler id for a successful match.
<!-- ##### FUNCTION g_signal_handlers_block_matched ##### -->
selection criteria. The criteria mask is passed as an OR-ed combination of
#GSignalMatchType flags, and the criteria values are passed as arguments.
Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
-or %G_SIGNAL_MATCH_DATA match flags is required for successfull matches.
+or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
If no handlers were found, 0 is returned, the number of blocked handlers
otherwise.
</para>
selection criteria. The criteria mask is passed as an OR-ed combination of
#GSignalMatchType flags, and the criteria values are passed as arguments.
Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
-or %G_SIGNAL_MATCH_DATA match flags is required for successfull matches.
+or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
If no handlers were found, 0 is returned, the number of unblocked handlers
otherwise. The match criteria should not apply to any handlers that are
not currently blocked.
selection criteria. The criteria mask is passed as an OR-ed combination of
#GSignalMatchType flags, and the criteria values are passed as arguments.
Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
-or %G_SIGNAL_MATCH_DATA match flags is required for successfull matches.
+or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
If no handlers were found, 0 is returned, the number of disconnected handlers
otherwise.
</para>
<para>
Returns #TRUE if @type is a fundamental data type such as #G_TYPE_INT or
#G_TYPE_POINTER. Fundamental types are types that serve as fundaments for
-the derived types, thus they are the roots of distinct inheritance heirachies.
+the derived types, thus they are the roots of distinct inheritance hierarchies.
</para>
@type: A #GType value.
<!-- ##### MACRO G_TYPE_IS_DERIVED ##### -->
<para>
-Returns #TRUE if @type is derived (or in object-oriented terminolgy:
+Returns #TRUE if @type is derived (or in object-oriented terminology:
inherited) from another type (this holds true for all non-fundamental
types).
</para>
@n_preallocs: Number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching).
@instance_init: Location of the instance initialization function (optional, for instantiatable types only).
@value_table: A #GTypeValueTable function table for generic handling of GValues of this type (usualy only
- usefull for fundamental types).
+ useful for fundamental types).
<!-- ##### STRUCT GTypeFundamentalInfo ##### -->
<para>
</para>
-@g_class: The #GTypeClass structure to retrive the parent class for.
+@g_class: The #GTypeClass structure to retrieve the parent class for.
@Returns: The parent class of @g_class.
or reference counted resources) are better handled by a GBaseInitFunc()
for this type, so proper initialization of the dynamic class members
are performed for class intialization of derived types as well.
-An example may help to corrsepond the intend of the different class
+An example may help to correspond the intend of the different class
initializers:
<msgtext><programlisting>
Initialization of TypeBClass will first cause initialization of
TypeAClass (derived classes reference their parent classes, see
g_type_class_ref() on this).
-Initialization of TypeAClass roughly involves zero-intializing its fields,
+Initialization of TypeAClass roughly involves zero-initializing its fields,
then calling its GBaseInitFunc() type_a_base_class_init() that allocates
its dynamic members (dynamic_string) and finally calling its GClassInitFunc()
type_a_class_init() to initialize its static members (static_integer).
The first step in the initialization process of TypeBClass is then
a plain memory copy of the contents of TypeAClass into TypeBClass and
-zero intialization of the remaining fields in TypeBClass.
+zero-initialization of the remaining fields in TypeBClass.
The dynamic members of TypeAClass within TypeBClass now need
reinitialization which is performed by calling type_a_base_class_init()
with an argument of TypeBClass.
<para>
A callback function used by the type system to initialize a new
instance of a type. This function initializes all instance members and
-allocates any resources require by it.
+allocates any resources required by it.
Initialization of a derived instance involves calling all its parent
types instance initializers, therefore the class member of the instance
is altered during its initialization to always point to the class that
contained in the #GTypeInfo structure pointed to by @info and the
#GTypeFundamentalInfo structure pointed to by @finfo to manage the
type and its instances. The value of @flags determines additional
-characteristics of the funamental type.
+characteristics of the fundamental type.
</para>
@type_id: A predefined #GTypeFundamentals value.
<para>
Creates and initializes an instance of @type if @type is valid and can
be instantiated. The type system only performs basic allocation and
-structure setups for instances, actuall instance creation should happen
+structure setups for instances, actual instance creation should happen
through functions supplied by the types fundamental type implementation.
So use of g_type_create_instance() is reserved for implementators of
-fundamental types only. E.g. instances of the #GObject heirachy
+fundamental types only. E.g. instances of the #GObject hierarchy
should be created via g_object_new() and <emphasis>never</emphasis>
directly through g_type_create_instance() which doesn't handle
things like singleton objects or object construction.
<!-- ##### FUNCTION g_type_instance_is_a ##### -->
<para>
-Determines if @instance adhears to the interface exported
-by @iface_type. @iface_type is eitehr a type that @instance
-is derived from, or an interface type that is suppoted by
+Determines if @instance adheres to the interface exported
+by @iface_type. @iface_type is either a type that @instance
+is derived from, or an interface type that is supported by
the anchestry of @instance.
</para>
projects / platform / upstream / glib.git / commitdiff