* @appinfo1: the first #GAppInfo.
* @appinfo2: the second #GAppInfo.
*
- * Checks if two #GAppInfo<!-- -->s are equal.
+ * Checks if two #GAppInfos are equal.
*
* Returns: %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
**/
* Tries to delete a #GAppInfo.
*
* On some platforms, there may be a difference between user-defined
- * #GAppInfo<!-- -->s which can be deleted, and system-wide ones which
- * cannot. See g_app_info_can_delete().
+ * #GAppInfos which can be deleted, and system-wide ones which cannot.
+ * See g_app_info_can_delete().
*
* Virtual: do_delete
* Returns: %TRUE if @appinfo has been deleted
* else
* g_printf ("Uh oh!\n");
*
- * /<!-- -->* ... *<!-- -->/
+ * ...
*
* }
*
* int main (int argc, void *argv[])
* {
- * /<!-- -->* ... *<!-- -->/
+ * ...
*
* _theoretical_frobnitz_async (theoretical_data,
* NULL,
* frobnitz_result_func,
* NULL);
*
- * /<!-- -->* ... *<!-- -->/
+ * ...
* }
* ]|
*
*
* An example of how to us this:
* |[
- * /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/
+ * /* Make sure we don't do unnecessary work if already cancelled */
* if (g_cancellable_set_error_if_cancelled (cancellable, error))
* return;
*
- * /<!-- -->* Set up all the data needed to be able to
- * * handle cancellation of the operation *<!-- -->/
+ * /* Set up all the data needed to be able to
+ * * handle cancellation of the operation
+ * */
* my_data = my_data_new (...);
*
* id = 0;
* G_CALLBACK (cancelled_handler)
* data, NULL);
*
- * /<!-- -->* cancellable operation here... *<!-- -->/
+ * /* cancellable operation here... */
*
* g_cancellable_disconnect (cancellable, id);
*
- * /<!-- -->* cancelled_handler is never called after this, it
- * * is now safe to free the data *<!-- -->/
+ * /* cancelled_handler is never called after this,
+ * * it is now safe to free the data
+ * */
* my_data_free (my_data);
* ]|
*
* G_DBUS_CALL_FLAGS_NONE,
* -1,
* NULL,
- * &error);
+ * &error);
* ]|
*
* The calling thread is blocked until a reply is received. See
* @dbus_error_name: A D-Bus error name.
*
* Creates an association to map between @dbus_error_name and
- * #GError<!-- -->s specified by @error_domain and @error_code.
+ * #GErrors specified by @error_domain and @error_code.
*
* This is typically done in the routine that returns the #GQuark for
* an error domain.
/**
* g_dbus_error_get_remote_error:
- * @error: A #GError.
+ * @error: a #GError
*
* Gets the D-Bus error name used for @error, if any.
*
* This function is guaranteed to return a D-Bus error name for all
- * #GError<!-- -->s returned from functions handling remote method
- * calls (e.g. g_dbus_connection_call_finish()) unless
+ * #GErrors returned from functions handling remote method calls
+ * (e.g. g_dbus_connection_call_finish()) unless
* g_dbus_error_strip_remote_error() has been used on @error.
*
- * Returns: An allocated string or %NULL if the D-Bus error name could not be found. Free with g_free().
+ * Returns: an allocated string or %NULL if the D-Bus error name
+ * could not be found. Free with g_free().
*
* Since: 2.26
*/
* and formatting is subject to change at any time. Typical output
* looks something like this:
* |[
- * Type: method-call
- * Flags: none
- * Version: 0
- * Serial: 4
- * Headers:
+ * Type: method-call
+ * Flags: none
+ * Version: 0
+ * Serial: 4
+ * Headers:
* path -> objectpath '/org/gtk/GDBus/TestObject'
* interface -> 'org.gtk.GDBus.TestInterface'
* member -> 'GimmeStdout'
* destination -> ':1.146'
- * Body: ()
+ * Body: ()
* UNIX File Descriptors:
* (none)
* ]|
* or
* |[
- * Type: method-return
- * Flags: no-reply-expected
- * Version: 0
- * Serial: 477
- * Headers:
+ * Type: method-return
+ * Flags: no-reply-expected
+ * Version: 0
+ * Serial: 477
+ * Headers:
* reply-serial -> uint32 4
* destination -> ':1.159'
* sender -> ':1.146'
* num-unix-fds -> uint32 1
- * Body: ()
- * UNIX File Descriptors:
+ * Body: ()
+ * UNIX File Descriptors:
* fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
* ]|
*
* @object: An object.
*
* Like g_dbus_object_manager_server_export() but appends a string of
- * the form <literal>_N</literal> (with N being a natural number) to
- * @object<!-- -->'s object path if an object with the given path
- * already exists. As such, the #GDBusObjectProxy:g-object-path property
- * of @object may be modified.
+ * the form _N (with N being a natural number) to @object's object path
+ * if an object with the given path already exists. As such, the
+ * #GDBusObjectProxy:g-object-path property of @object may be modified.
*
* Since: 2.30
*/
* Emitted when a method is invoked by a remote caller and used to
* determine if the method call is authorized.
*
- * This signal is like #GDBusInterfaceSkeleton<!-- -->'s
- * #GDBusInterfaceSkeleton::g-authorize-method signal, except that it is
- * for the enclosing object.
+ * This signal is like #GDBusInterfaceSkeleton's
+ * #GDBusInterfaceSkeleton::g-authorize-method signal,
+ * except that it is for the enclosing object.
*
* The default class handler just returns %TRUE.
*
* -1,
* NULL,
* (GAsyncReadyCallback) two_strings_done,
- * &data);
+ * &data);
* ]|
*
* If @proxy has an expected interface (see
* G_DBUS_CALL_FLAGS_NONE,
* -1,
* NULL,
- * &error);
+ * &error);
* ]|
*
* The calling thread is blocked until a reply is received. See
* Gets the list of emblems for the @icon.
*
* Returns: (element-type Gio.Emblem) (transfer none): a #GList of
- * #GEmblem <!-- -->s that is owned by @emblemed
+ * #GEmblems that is owned by @emblemed
*
* Since: 2.18
**/
* @emblemed: a #GEmblemedIcon
* @emblem: a #GEmblem
*
- * Adds @emblem to the #GList of #GEmblem <!-- -->s.
+ * Adds @emblem to the #GList of #GEmblems.
*
* Since: 2.18
**/
* @short_description: Enumerated Files Routines
* @include: gio/gio.h
*
- * #GFileEnumerator allows you to operate on a set of #GFile<!-- -->s,
+ * #GFileEnumerator allows you to operate on a set of #GFiles,
* returning a #GFileInfo structure for each file enumerated (e.g.
* g_file_enumerate_children() will return a #GFileEnumerator for each
* of the children within a directory).
* To get the next file's information from a #GFileEnumerator, use
* g_file_enumerator_next_file() or its asynchronous version,
* g_file_enumerator_next_files_async(). Note that the asynchronous
- * version will return a list of #GFileInfo<!---->s, whereas the
+ * version will return a list of #GFileInfos, whereas the
* synchronous will only return the next file in the enumerator.
*
* The ordering of returned files is unspecified for non-Unix
* @attributes: an attribute string to match.
*
* Creates a new file attribute matcher, which matches attributes
- * against a given string. #GFileAttributeMatcher<!-- -->s are reference
+ * against a given string. #GFileAttributeMatchers are reference
* counted structures, and are created with a reference count of 1. If
* the number of references falls to 0, the #GFileAttributeMatcher is
* automatically destroyed.
* The list is sorted by priority, beginning with the highest priority.
*
* Returns: (element-type GIOExtension) (transfer none): a #GList of
- * #GIOExtension<!-- -->s. The list is owned by GIO and should not be
- * modified.
+ * #GIOExtensions. The list is owned by GIO and should not be
+ * modified.
*/
GList *
g_io_extension_point_get_extensions (GIOExtensionPoint *extension_point)
* GSettings::change-event:
* @settings: the object on which the signal was emitted
* @keys: (array length=n_keys) (element-type GQuark) (allow-none):
- * an array of #GQuark<!-- -->s for the changed keys, or %NULL
+ * an array of #GQuarks for the changed keys, or %NULL
* @n_keys: the length of the @keys array, or 0
*
* The "change-event" signal is emitted once per change event that
*
* #GSimpleAsyncResult implements #GAsyncResult.
*
- * GSimpleAsyncResult handles #GAsyncReadyCallback<!-- -->s, error
+ * GSimpleAsyncResult handles #GAsyncReadyCallbacks, error
* reporting, operation cancellation and the final state of an operation,
* completely transparent to the application. Results can be returned
* as a pointer e.g. for functions that return data that is collected
* cause a leak if cancelled before being run).
*
* GSimpleAsyncResult can integrate into GLib's event loop, #GMainLoop,
- * or it can use #GThread<!-- -->s.
+ * or it can use #GThreads.
* g_simple_async_result_complete() will finish an I/O task directly
* from the point where it is called. g_simple_async_result_complete_in_idle()
* will finish it from an idle handler in the <link
* reasons. For instance, on Windows a socket is always seen as writable
* until a write returns %G_IO_ERROR_WOULD_BLOCK.
*
- * #GSocket<!-- -->s can be either connection oriented or datagram based.
+ * #GSockets can be either connection oriented or datagram based.
* For connection oriented types you must first establish a connection by
* either connecting to an address or accepting a connection from another
* address. For connectionless socket types the target/source address is
* then @vectors is assumed to be terminated by a #GOutputVector with a
* %NULL buffer pointer.) The #GOutputVector structs describe the buffers
* that the sent data will be gathered from. Using multiple
- * #GOutputVector<!-- -->s is more memory-efficient than manually copying
+ * #GOutputVectors is more memory-efficient than manually copying
* data from multiple sources into a single buffer, and more
* network-efficient than making multiple calls to g_socket_send().
*
* enumerator = g_socket_connectable_enumerate (addr);
* g_object_unref (addr);
*
- * /<!-- -->* Try each sockaddr until we succeed. Record the first
- * * connection error, but not any further ones (since they'll probably
- * * be basically the same as the first).
- * *<!-- -->/
+ * /* Try each sockaddr until we succeed. Record the first
+ * * connection error, but not any further ones (since they'll probably
+ * * be basically the same as the first).
+ * */
* while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error))
* {
* conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error);
* {
* if (conn_error)
* {
- * /<!-- -->* We couldn't connect to the first address, but we succeeded
- * * in connecting to a later address.
- * *<!-- -->/
+ * /* We couldn't connect to the first address, but we succeeded
+ * * in connecting to a later address.
+ * */
* g_error_free (conn_error);
* }
* return conn;
* }
* else if (error)
* {
- * /<!-- -->* Either the initial lookup failed, or else the caller
- * * cancelled us.
- * *<!-- -->/
+ * /* Either the initial lookup failed, or else the caller
+ * * cancelled us.
+ * */
* if (conn_error)
* g_error_free (conn_error);
* return NULL;
* @connectable: a #GSocketConnectable
*
* Creates a #GSocketAddressEnumerator for @connectable that will
- * return #GProxyAddress<!-- -->es for addresses that you must connect
+ * return #GProxyAddresses for addresses that you must connect
* to via a proxy.
*
* If @connectable does not implement
* then connect to whatever host was pointed to by that record.
*
* You can use g_resolver_lookup_service() or
- * g_resolver_lookup_service_async() to find the #GSrvTarget<!-- -->s
+ * g_resolver_lookup_service_async() to find the #GSrvTargets
* for a given service. However, if you are simply planning to connect
* to the remote service, you can use #GNetworkService's
* #GSocketConnectable interface and not need to worry about
*
* Creates a new #GSrvTarget with the given parameters.
*
- * You should not need to use this; normally #GSrvTarget<!-- -->s are
+ * You should not need to use this; normally #GSrvTargets are
* created by #GResolver.
*
* Return value: a new #GSrvTarget.
* @file: file containing PEM-encoded certificates to import
* @error: #GError for error reporting, or %NULL to ignore.
*
- * Creates one or more #GTlsCertificate<!-- -->s from the PEM-encoded
+ * Creates one or more #GTlsCertificates from the PEM-encoded
* data in @file. If @file cannot be read or parsed, the function will
* return %NULL and set @error. If @file does not contain any
* PEM-encoded certificates, this will return an empty list and not
* |[
* gint16 in;
* gint32 out;
- * sscanf ("42", "%" G_GINT16_FORMAT, &in)
+ * sscanf ("42", "%" G_GINT16_FORMAT, &in)
* out = in * 1000;
* g_print ("%" G_GINT32_FORMAT, out);
* ]|
* * We don't want it zero-terminated or cleared to 0's.
* */
* garray = g_array_new (FALSE, FALSE, sizeof (gint));
- * for (i = 0; i < 10000; i++)
+ * for (i = 0; i < 10000; i++)
* g_array_append_val (garray, i);
- * for (i = 0; i < 10000; i++)
+ * for (i = 0; i < 10000; i++)
* if (g_array_index (garray, gint, i) != i)
- * g_print ("ERROR: got %d instead of %d\n",
+ * g_print ("ERROR: got %d instead of %d\n",
* g_array_index (garray, gint, i), i);
* g_array_free (garray, TRUE);
* ]|
* /* This gets a pointer to the 4th element
* * in the array of EDayViewEvent structs.
* */
- * event = &g_array_index (events, EDayViewEvent, 3);
+ * event = &g_array_index (events, EDayViewEvent, 3);
* ]|
*
* Returns: the element of the #GArray at the index given by @i
* the g_log() functions.
*
* |[
- * #include <glib.h>
+ * #include <glib.h>
*
* static void
* log_handler (const gchar *log_domain,
* G_LOG_LEVEL_CRITICAL,
* log_handler,
* NULL);
- * /* ... */
+ * ...
* ]|
*
* If [E]xit is selected, the application terminates with a call
* the bookmark as "private" to the applications and groups that has it
* registered; the URI and MIME type of an icon, to be used when displaying
* the bookmark inside a GUI.
- * |[<xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../glib/tests/bookmarks.xbel"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>]|
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../glib/tests/bookmarks.xbel"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include>
+ * </programlisting>
*
* A bookmark file might contain more than one bookmark; each bookmark
* is accessed through its URI.
* time_t ttime;
* GTime gtime;
*
- * time (&ttime);
+ * time (&ttime);
* gtime = (GTime)ttime;
* ]|
*/
* |[
* gchar *contents;
* GError *err = NULL;
- * g_file_get_contents ("foo.txt", &contents, NULL, &err);
- * g_assert ((contents == NULL && err != NULL) || (contents != NULL && err == NULL));
+ *
+ * g_file_get_contents ("foo.txt", &contents, NULL, &err);
+ * g_assert ((contents == NULL && err != NULL) || (contents != NULL && err == NULL));
* if (err != NULL)
* {
* /* Report error to user, and free error */
* g_assert (contents == NULL);
- * fprintf (stderr, "Unable to read file: %s\n", err->message);
+ * fprintf (stderr, "Unable to read file: %s\n", err->message);
* g_error_free (err);
* }
* else
* are only interested in whether it failed and don't need to display
* an error message, you can pass %NULL for the @error argument:
* |[
- * if (g_file_get_contents ("foo.txt", &contents, NULL, NULL)) /* ignore errors */
+ * if (g_file_get_contents ("foo.txt", &contents, NULL, NULL)) /* ignore errors */
* /* no error occurred */ ;
* else
* /* error */ ;
*
* fd = open ("file.txt", O_RDONLY);
*
- * if (fd < 0)
+ * if (fd < 0)
* {
* g_set_error (error,
* FOO_ERROR, /* error domain */
* FOO_ERROR_BLAH, /* error code */
- * "Failed to open file: %s", /* error message format string */
+ * "Failed to open file: %s", /* error message format string */
* g_strerror (errno));
* return -1;
* }
* g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
*
* tmp_error = NULL;
- * sub_function_that_can_fail (&tmp_error);
+ * sub_function_that_can_fail (&tmp_error);
*
* if (tmp_error != NULL)
* {
* g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
*
* tmp_error = NULL;
- * sub_function_that_can_fail (&tmp_error);
- * other_function_that_can_fail (&tmp_error);
+ * sub_function_that_can_fail (&tmp_error);
+ * other_function_that_can_fail (&tmp_error);
*
* if (tmp_error != NULL)
* {
* sub_function_that_can_fail (NULL); /* ignore errors */
*
* tmp_error = NULL;
- * other_function_that_can_fail (&tmp_error);
+ * other_function_that_can_fail (&tmp_error);
*
* if (tmp_error != NULL)
* {
* <filename>glib/gi18n-lib.h</filename> after defining the %GETTEXT_PACKAGE
* macro suitably for your library:
* |[
- * #define GETTEXT_PACKAGE "gtk20"
- * #include <glib/gi18n-lib.h>
+ * #define GETTEXT_PACKAGE "gtk20"
+ * #include <glib/gi18n-lib.h>
* ]|
* For an application, note that you also have to call bindtextdomain(),
* bind_textdomain_codeset(), textdomain() and setlocale() early on in your
* const char *string;
* ...
* string
- * = index > 1 ? g_dpgettext2 (NULL, "some context", "a default message")
- * : g_dpgettext2 (NULL, "some context", messages[index]);
+ * = index > 1 ? g_dpgettext2 (NULL, "some context", "a default message")
+ * : g_dpgettext2 (NULL, "some context", messages[index]);
*
* fputs (string);
* ...
* operations that want to be able to be run in contexts other than
* the default one should call this method or
* g_main_context_ref_thread_default() to get a #GMainContext to add
- * their #GSource<!-- -->s to. (Note that even in single-threaded
+ * their #GSources to. (Note that even in single-threaded
* programs applications may sometimes want to temporarily push a
* non-default context, so it is not safe to assume that this will
* always return %NULL if you are running in the default thread.)
* {
* SomeWidget *self = data;
*
- * GDK_THREADS_ENTER (<!-- -->);
- * /<!-- -->* do stuff with self *<!-- -->/
+ * GDK_THREADS_ENTER ();
+ * /* do stuff with self */
* self->idle_id = 0;
- * GDK_THREADS_LEAVE (<!-- -->);
+ * GDK_THREADS_LEAVE ();
*
* return G_SOURCE_REMOVE;
* }
* GDK_THREADS_ENTER ();
* if (!g_source_is_destroyed (g_main_current_source ()))
* {
- * /<!-- -->* do stuff with self *<!-- -->/
+ * /* do stuff with self */
* }
* GDK_THREADS_LEAVE ();
*
* might themselves contain markup.
*
* |[
- * const char *store = "Fortnum & Mason";
+ * const char *store = "Fortnum & Mason";
* const char *item = "Tea";
* char *output;
- *
- * output = g_markup_printf_escaped ("<purchase>"
- * "<store>%s</store>"
- * "<item>%s</item>"
- * "</purchase>",
+ *
+ * output = g_markup_printf_escaped ("<purchase>"
+ * "<store>%s</store>"
+ * "<item>%s</item>"
+ * "</purchase>",
* store, item);
* ]|
*
* --rand Randomize the data
* </screen></informalexample>
*
- * GOption groups options in #GOptionGroup<!-- -->s, which makes it easy to
+ * GOption groups options in #GOptionGroups, which makes it easy to
* incorporate options from multiple sources. The intended use for this is
* to let applications collect option groups from the libraries it uses,
* add them to their #GOptionContext, and parse all options by a single call
/**
* g_option_context_add_main_entries:
* @context: a #GOptionContext
- * @entries: a %NULL-terminated array of #GOptionEntry<!-- -->s
+ * @entries: a %NULL-terminated array of #GOptionEntrys
* @translation_domain: (allow-none): a translation domain to use for translating
* the <option>--help</option> output for the options in @entries
* with gettext(), or %NULL
/**
* g_option_group_add_entries:
* @group: a #GOptionGroup
- * @entries: a %NULL-terminated array of #GOptionEntry<!-- -->s
+ * @entries: a %NULL-terminated array of #GOptionEntrys
*
* Adds the options specified in @entries to @group.
*
*
* Sets the function which is used to translate user-visible
* strings, for <option>--help</option> output. Different
- * groups can use different #GTranslateFunc<!-- -->s. If @func
+ * groups can use different #GTranslateFuncs. If @func
* is %NULL, strings are not translated.
*
* If you are using gettext(), you only need to set the translation
* file descriptor, but the situation is much more complicated on
* Windows. If you need to use g_poll() in code that has to run on
* Windows, the easiest solution is to construct all of your
- * #GPollFD<!-- -->s with g_io_channel_win32_make_pollfd().
+ * #GPollFDs with g_io_channel_win32_make_pollfd().
*
* Return value: the number of entries in @fds whose %revents fields
* were filled in, or 0 if the operation timed out, or -1 on error or
*
* A convenience macro which defines a function returning the
* #GQuark for the name @QN. The function will be named
- * @q_n<!-- -->_quark().
+ * @q_n_quark().
*
* Note that the quark name will be stringified automatically
* in the macro, so you shouldn't use double quotes.
* @match_info: #GMatchInfo structure
* @match_num: number of the sub expression
*
- * Retrieves the text matching the @match_num<!-- -->'th capturing
+ * Retrieves the text matching the @match_num'th capturing
* parentheses. 0 is the full text of the match, 1 is the first paren
* set, 2 the second, and so on.
*
* @end_pos: (out) (allow-none): pointer to location where to store
* the end position, or %NULL
*
- * Retrieves the position in bytes of the @match_num<!-- -->'th capturing
+ * Retrieves the position in bytes of the @match_num'th capturing
* parentheses. 0 is the full text of the match, 1 is the first
* paren set, 2 the second, and so on.
*
* /* Print all uppercase-only words. */
* GRegex *regex;
* GMatchInfo *match_info;
- *
+ *
* regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
- * g_regex_match (regex, string, 0, &match_info);
+ * g_regex_match (regex, string, 0, &match_info);
* while (g_match_info_matches (match_info))
* {
* gchar *word = g_match_info_fetch (match_info, 0);
* GRegex *regex;
* GMatchInfo *match_info;
* GError *error = NULL;
- *
+ *
* regex = g_regex_new ("[A-Z]+", 0, 0, NULL);
- * g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
+ * g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
* while (g_match_info_matches (match_info))
* {
* gchar *word = g_match_info_fetch (match_info, 0);
* g_print ("Found: %s\n", word);
* g_free (word);
- * g_match_info_next (match_info, &error);
+ * g_match_info_next (match_info, &error);
* }
* g_match_info_free (match_info);
* g_regex_unref (regex);
* |[
* char buf[G_ASCII_DTOSTR_BUF_SIZE];
*
- * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
+ * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
* ]|
*/
* static int current_number = 0;
* int ret_val;
*
- * g_mutex_lock (&mutex);
+ * g_mutex_lock (&mutex);
* ret_val = current_number = calc_next_number (current_number);
- * g_mutex_unlock (&mutex);
+ * g_mutex_unlock (&mutex);
*
* return ret_val;
* }
* if (!array)
* return NULL;
*
- * g_rw_lock_reader_lock (&lock);
+ * g_rw_lock_reader_lock (&lock);
* if (index < array->len)
* retval = g_ptr_array_index (array, index);
- * g_rw_lock_reader_unlock (&lock);
+ * g_rw_lock_reader_unlock (&lock);
*
* return retval;
* }
* |[
* static gsize initialization_value = 0;
*
- * if (g_once_init_enter (&initialization_value))
+ * if (g_once_init_enter (&initialization_value))
* {
- * gsize setup_value = 42; /** initialization code here **/
+ * gsize setup_value = 42; /* initialization code here */
*
- * g_once_init_leave (&initialization_value, setup_value);
+ * g_once_init_leave (&initialization_value, setup_value);
* }
*
- * /** use initialization_value here **/
+ * /* use initialization_value here */
* ]|
*
* Returns: %TRUE if the initialization section should be entered,
* A #GClosure represents a callback supplied by the programmer. It
* will generally comprise a function of some kind and a marshaller
* used to call it. It is the reponsibility of the marshaller to
- * convert the arguments for the invocation from #GValue<!-- -->s into
+ * convert the arguments for the invocation from #GValues into
* a suitable form, perform the callback on the converted arguments,
* and transform the return value back into a #GValue.
*
* In the case of C programs, a closure usually just holds a pointer
* to a function and maybe a data argument, and the marshaller
- * converts between #GValue<!-- --> and native C types. The GObject
+ * converts between #GValue and native C types. The GObject
* library provides the #GCClosure type for this purpose. Bindings for
* other languages need marshallers which convert between #GValue<!--
* -->s and suitable representations in the runtime of the language in
* struct _MyClosure
* {
* GClosure closure;
- * // extra data goes here
+ * /* extra data goes here */
* };
*
* static void
* {
* MyClosure *my_closure = (MyClosure *)closure;
*
- * // free extra data here
+ * /* free extra data here */
* }
*
* MyClosure *my_closure_new (gpointer data)
* closure = g_closure_new_simple (sizeof (MyClosure), data);
* my_closure = (MyClosure *) closure;
*
- * // initialize extra data here
+ * /* initialize extra data here */
*
* g_closure_add_finalize_notifier (closure, notify_data,
* my_closure_finalize);
* |[
* closure = g_cclosure_new (cb_func, cb_data);
* g_source_set_closure (source, closure);
- * g_closure_unref (closure); // XXX GObject doesn't really need this
+ * g_closure_unref (closure); /* GObject doesn't really need this */
* ]|
* Because g_source_set_closure() (and similar functions) take ownership of the
* initial reference count, if it is unowned, we instead can write:
* doesn't return a value.
* @n_param_values: the length of the @param_values array
* @param_values: (array length=n_param_values): an array of
- * #GValue<!-- -->s holding the arguments on which to
+ * #GValues holding the arguments on which to
* invoke the callback of @closure
* @invocation_hint: (allow-none): a context-dependent invocation hint
*
* @return_gvalue: A #GValue to store the return value. May be %NULL
* if the callback of closure doesn't return a value.
* @n_param_values: The length of the @param_values array.
- * @param_values: An array of #GValue<!-- -->s holding the arguments
+ * @param_values: An array of #GValues holding the arguments
* on which to invoke the callback of closure.
* @invocation_hint: The invocation hint given as the last argument to
* g_closure_invoke().
/**
* g_object_class_install_properties:
* @oclass: a #GObjectClass
- * @n_pspecs: the length of the #GParamSpec<!-- -->s array
- * @pspecs: (array length=n_pspecs): the #GParamSpec<!-- -->s array
+ * @n_pspecs: the length of the #GParamSpecs array
+ * @pspecs: (array length=n_pspecs): the #GParamSpecs array
* defining the new properties
*
- * Installs new properties from an array of #GParamSpec<!-- -->s. This is
+ * Installs new properties from an array of #GParamSpecs. This is
* usually done in the class initializer.
*
* The property id of each property is the index of each #GParamSpec in
* be used to store a #GParamSpec.
*
* This function should be used if you plan to use a static array of
- * #GParamSpec<!-- -->s and g_object_notify_by_pspec(). For instance, this
+ * #GParamSpecs and g_object_notify_by_pspec(). For instance, this
* class initialization:
*
* |[
* NULL),
* "signal::event", gtk_menu_window_event, menu,
* "signal::size_request", gtk_menu_window_size_request, menu,
- * "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
+ * "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
* NULL);
* ]|
*
* This function is intended for #GObject implementations to re-enforce a
* <link linkend="floating-ref">floating</link> object reference.
* Doing this is seldom required: all
- * #GInitiallyUnowned<!-- -->s are created with a floating reference which
+ * #GInitiallyUnowneds are created with a floating reference which
* usually just needs to be sunken by calling g_object_ref_sink().
*
* Since: 2.10
* objects.
*
* If the object's #GObjectClass.dispose method results in additional
- * references to the object being held, any #GWeakRef<!-- -->s taken
+ * references to the object being held, any #GWeakRefs taken
* before it was disposed will continue to point to %NULL. If
- * #GWeakRef<!-- -->s are taken after the object is disposed and
+ * #GWeakRefs are taken after the object is disposed and
* re-referenced, they will continue to point to it until its refcount
* goes back to zero, at which point they too will be invalidated.
*/
* efficient and in fact required when using property names as detail
* strings for signals.
*
- * Beyond the name, #GParamSpec<!-- -->s have two more descriptive
+ * Beyond the name, #GParamSpecs have two more descriptive
* strings associated with them, the @nick, which should be suitable
* for use as a label for the property in a property editor, and the
* @blurb, which should be a somewhat longer description, suitable for
/**
* GParamSpecPool:
*
- * A #GParamSpecPool maintains a collection of #GParamSpec<!-- -->s which can be
+ * A #GParamSpecPool maintains a collection of #GParamSpecs which can be
* quickly accessed by owner and name. The implementation of the #GObject property
* system uses such a pool to store the #GParamSpecs of the properties all object
* types.
* @pool: a #GParamSpecPool
* @owner_type: the owner to look for
*
- * Gets an #GList of all #GParamSpec<!-- -->s owned by @owner_type in
+ * Gets an #GList of all #GParamSpecs owned by @owner_type in
* the pool.
*
* Returns: (transfer container) (element-type GObject.ParamSpec): a
- * #GList of all #GParamSpec<!-- -->s owned by @owner_type in
- * the pool#GParamSpec<!-- -->s.
+ * #GList of all #GParamSpecs owned by @owner_type in
+ * the pool#GParamSpecs.
*/
GList*
g_param_spec_pool_list_owned (GParamSpecPool *pool,
* @owner_type: the owner to look for
* @n_pspecs_p: (out): return location for the length of the returned array
*
- * Gets an array of all #GParamSpec<!-- -->s owned by @owner_type in
+ * Gets an array of all #GParamSpecs owned by @owner_type in
* the pool.
*
* Returns: (array length=n_pspecs_p) (transfer container): a newly
* features.
*
* |[
- * #include <glib-object.h>
+ * #include <glib-object.h>
*
* static void
* int2string (const GValue *src_value,
* const gchar *message;
*
* /* The GValue starts empty */
- * g_assert (!G_VALUE_HOLDS_STRING (&a));
+ * g_assert (!G_VALUE_HOLDS_STRING (&a));
*
* /* Put a string in it */
- * g_value_init (&a, G_TYPE_STRING);
- * g_assert (G_VALUE_HOLDS_STRING (&a));
- * g_value_set_static_string (&a, "Hello, world!");
- * g_printf ("%s\n", g_value_get_string (&a));
+ * g_value_init (&a, G_TYPE_STRING);
+ * g_assert (G_VALUE_HOLDS_STRING (&a));
+ * g_value_set_static_string (&a, "Hello, world!");
+ * g_printf ("%s\n", g_value_get_string (&a));
*
* /* Reset it to its pristine state */
- * g_value_unset (&a);
+ * g_value_unset (&a);
*
* /* It can then be reused for another type */
- * g_value_init (&a, G_TYPE_INT);
- * g_value_set_int (&a, 42);
+ * g_value_init (&a, G_TYPE_INT);
+ * g_value_set_int (&a, 42);
*
* /* Attempt to transform it into a GValue of type STRING */
- * g_value_init (&b, G_TYPE_STRING);
+ * g_value_init (&b, G_TYPE_STRING);
*
* /* An INT is transformable to a STRING */
* g_assert (g_value_type_transformable (G_TYPE_INT, G_TYPE_STRING));
*
- * g_value_transform (&a, &b);
- * g_printf ("%s\n", g_value_get_string (&b));
+ * g_value_transform (&a, &b);
+ * g_printf ("%s\n", g_value_get_string (&b));
*
* /* Attempt to transform it again using a custom transform function */
* g_value_register_transform_func (G_TYPE_INT, G_TYPE_STRING, int2string);
- * g_value_transform (&a, &b);
- * g_printf ("%s\n", g_value_get_string (&b));
+ * g_value_transform (&a, &b);
+ * g_printf ("%s\n", g_value_get_string (&b));
* return 0;
* }
* ]|