+2.35.8 (unstable);
+
+2013-02-21 Murray Cumming <murrayc@murrayc.com>
+
+ Fix the build with --enable-warnings=fatal.
+
+ * glib/src/threads.hg: The GThread definition is now deprecated,
+ meaning it should only be used via a pointer.
+ However, we depend on it, so this temporarily undefs the
+ deprecation, so we can still use those checks elsewhere in the build.
+ It looks like we will have to do a third version of Glib::Threads,
+ after already replacing Glib::Thread.
+ This fixes make distcheck.
+
+2013-02-21 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Signal*::connect(): Make them less thread-unsafe.
+
+ * glib/glibmm/main.cc: Make SignalTimeout::connect(), connect_seconds(),
+ SignalIdle::connect() and SignalChildWatch::connect() less thread-unsafe
+ by moving conn_node->install() to before g_source_attach().
+ * glib/glibmm/main.h: Describe that the Signal*::connect*() methods that
+ return a sigc::connection are not thread-safe. Bug #396958.
+
+2013-02-20 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Signal[Timeout|Idle]::connect_once() docs: Warn about thread-unsafety.
+
+ * glib/glibmm/main.cc: Fix an incomplete comment.
+ * glib/glibmm/main.h: SignalTimeout::connect_once(), connect_seconds_once(),
+ SignalIdle::connect_once(): Describe the caution necessary because
+ sigc::trackable-derived objects are not thread-safe. Bug #396963.
+
+2013-02-20 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ ThreadPool::push() docs: Note that sigc::trackable is not thread-safe.
+
+ * glib/glibmm/threadpool.h: push(): Describe how sigc::trackable-derived
+ classes can be used in a thread-safe way.
+ * glib/src/threads.hg: create(): Correct the description added in the
+ previous commit. Bug #512348.
+
+2013-02-20 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Threads::Thread::create(): Update the documentation.
+
+ * examples/thread/thread.cc: Don't derive from sigc::trackable.
+ * glib/src/threads.hg: create(): Describe how sigc::trackable-derived classes
+ can be used in a thread-safe way. Bug #512348.
+
+2013-01-30 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Predefine G_OS_UNIX or G_OS_WIN32 in Doxygen's configuration file.
+
+ * docs/reference/Doxyfile.in: Predefine either G_OS_UNIX or G_OS_WIN32,
+ depending on HOST_WINDOWS_NATIVE. Update to Doxygen 1.8.3 status.
+ * glib/src/iochannel.hg: Remove the DOXYGEN_SHOULD_SKIP_THIS that was added
+ just to get Windows-specific methods included in the documentation.
+
+2013-01-30 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ DBus::[Connection|Proxy]: Change ifdef G_OS_LINUX to ifdef G_OS_UNIX.
+
+ * gio/src/dbusconnection.[ccg|hg]:
+ * gio/src/dbusproxy.[ccg|hg]: Change G_OS_LINUX to G_OS_UNIX. Glib does not
+ define G_OS_LINUX. Correct function declarations for DBus::Proxy::call().
+
+2013-01-29 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ gmmproc: Improve the conversion of documentation to Doxygen format.
+
+ * tools/defs_gen/docextract.py: Handle 'Since ' without a colon.
+ * tools/m4/signal.m4:
+ * tools/pm/Output.pm: When a function declaration is surrounded by
+ ifdef/endif, put its documentation inside the ifdef/endif.
+ * tools/pm/DocsParser.pm: Handle 'Since ' without a colon. Escape most
+ backslashes, not just \r and \n. Convert more <tags> to something that
+ Doxygen understands.
+
+2013-01-27 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Documentation: Fix many warnings from Doxygen.
+
+ * gio/src/gio_docs_override.xml:
+ * glib/src/glib_docs_override.xml: Move "Since: n.m" from the <return> to the
+ <description> entries. gmmproc adds a period at the end of the @return
+ Doxygen command, and Doxygen warns for "@newin{n,m}.".
+ * glib/glibmm/interface.h:
+ * glib/glibmm/stringutils.h:
+ * glib/glibmm/vectorutils.h:
+ * gio/src/*.hg:
+ * glib/src/*.hg: (Here "*" means "many", not "all") Examples of changes:
+ Add missing @param. Change names of parameters, to make them equal in
+ function declaration and @param command. Change "@name" to "@a name".
+ Change "<ulink url=" to "<a href=".
+
+2013-01-17 José Alburquerque <jaalburquerque@gmail.com>
+
+ TlsConnection: Wrap the virtual functions.
+
+ * gio/src/tlsconnection.hg: Wrap the three virtual functions that were
+ left as TODO's now that it's possible to wrap virtual functions with
+ slots.
+ * tools/m4/vfunc.m4: Use 'retval' instead of 'result' for variables
+ that store the result of the C base virtual function invocation and
+ the C++ virtual function invocation because 'result' conflicts with
+ the AsyncResult 'result' parameter of the handshake_finish_vfunc().
+
+2013-01-16 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: _WRAP_VFUNC: Support the wrapping of slots.
+
+ * tools/pm/WrapParser.pm (on_wrap_vfunc): Add support for parsing the
+ additional 'slot_name', 'slot_callback', and 'no_slot_copy' options
+ that do the same thing as the corresponding _WRAP_METHOD options (ie.
+ specify the name of the C++ slot parameter, the name of the callback
+ function and whether to use the original slot or a copy of it,
+ respectively. Also pass the options along to:
+ (output_wrap_vfunc): Store the options in the C++ virtual function
+ object so they can be tested for when converting the parameters and
+ composing the _VFUNC* m4 macro calls.
+ * tools/pm/Output.pm (output_wrap_vfunc_cc):
+ - Append the additional 'slot_type', 'slot_name' and 'no_slot_copy'
+ parameters to the _VFUNC_CC m4 macro invocation so that it can include
+ code for the vfunc to copy the slot parameter and pass it on to the C
+ function.
+ - Also append the additional 'slot_type' and 'c_data_param_name' to
+ the _VFUNC_PCC m4 macro so that it knows the slot type and the C
+ gpointer parameter name that contains the slot so that the macro can
+ generate code to extract the slot from the data parameter and pass the
+ slot on to the C++ virtual function.
+ (convert_args_c_to_cpp):
+ - Rewritten so that it loops through the C++ parameters so that it is
+ possible to re-order the parameters using the existing mapping
+ functionality that allows parameters to be re-ordered for the
+ _WRAP_[CREATE|CTOR|METHOD] macros. Also re-written so that it knows
+ how to deal with slot parameters.
+ * tools/m4/vfunc.m4 (_VFUNC_PCC): Modified to accept the additional
+ 'slot_type' and 'c_data_param_name' arguments and to insert code to
+ extract the slot from the C gpointer data parameter to be passed on
+ to the C++ virtual function.
+ (_VFUNC_CC): Modified to accept the additional 'slot_type',
+ 'slot_name' and 'no_slot_copy' arguments and to insert code to either
+ copy the slot in a 'slot_copy' variable or set the variable to the
+ actual slot (if it's so been specified) which is then passed on to the
+ C function.
+
+2013-01-16 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: _WRAP_[CREATE|CTOR|METHOD]: Allow any order of {} options.
+
+ * tools/pm/Function.pm: Make it possible to use any order desired of
+ the options to specify whether parameters should be optional or should
+ be re-ordered in the _WRAP_* directives.
+
+2013-01-14 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Gio::File: Remove refreturn to avoid memory leaks.
+
+ * gio/src/file.hg: Remove the refreturn argument from _WRAP_METHOD for read()
+ and 13 other methods. The glib functions add a ref.
+ Change @newin2p24 to @newin{2,24}. Bug #691606.
+
+2013-01-09 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm.h: Add the tls[client|server]connection.h headers.
+
+ * gio/giomm.h: Add the two new headers.
+
+2013-01-08 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the Tls[Client|Server]Connection classes.
+
+ * gio/src/tlsclientconnection.{ccg,hg}: Add the new client sources
+ wrapping the methods and properties.
+ * gio/src/tlsserverconnection.{ccg,hg}: Add the new server sources
+ wrapping its single property.
+ * gio/src/filelist.am: Include the new sources in the list of files to
+ be built.
+ * gio/src/enums.hg: Add the TlsAuthenticationMode enum needed for the
+ server class here because it is documented in the Tls Overview section
+ of the C API's documentation and not as part of any other class.
+ * tools/m4/convert_gio.m4: Add a necessary conversion.
+
+ * gio/src/tlsdatabase.{ccg,hg}: Fix the includes so that the
+ tlscertificate.h header file does not have to be included in the .h
+ file but instead in the .c file.
+
+2013-01-07 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm.h: Add the new tls*.h headers.
+
+ * gio/giomm.h: Add the
+ tls[connection|database|filedatabase|interaction].h headers.
+
+2013-01-07 José Alburquerque <jaalburquerque@gmail.com>
+
+ Tls[Database|Interaction|Passowrd]: Const corrections.
+
+ * gio/src/tlsdatabase.hg (verify_chain):
+ (verify_chain_async): Accept the SocketConnectable as a const because
+ it is used to check for certificates that have been pinned (marked as
+ good) for a specific domain in a browser session and not modified.
+ (lookup_certificate_issuer)
+ (lookup_certificate_issuer_async): Accept the TlsCertificate for which
+ to look for the issuer as const because it is not modified according
+ to the docs.
+ * gio/src/tlsinteraction.hg (ask_password):
+ (ask_password_async)
+ (invoke_ask_password): Accept the TlsPassword as non-const because the
+ docs say that it is filled in by the methods, not used to compare a
+ user entry with an existing password.
+ * gio/src/tlspassword.hg (get_value_vfunc):
+ (get_default_warning_vfunc): Make these const because they are getter
+ functions.
+ * tools/m4/convert_gio.m4: Adjust the conversions according to above
+ changes.
+
+2013-01-07 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ gmmproc: _WRAP_ENUM: Skip enum constants whose names are deleted.
+
+ * tools/pm/Enum.pm, build_element_list(): If a custom substitution argument
+ in _WRAP_ENUM() removes all of an enum constant's name, exclude that constant
+ from the element list. Useful for GdkEventType. Bug #544694.
+
+2013-01-07 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ gmmproc: Improve the search for documentation of enums.
+
+ * tools/pm/Enum.pm, build_element_list(): Search for value documentation
+ before custom substitutions are applied to the element name. Bug #544694.
+
+2013-01-03 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsConnection class.
+
+ * gio/src/filelist.am:
+ * gio/src/tlsconnection.{ccg,hg}: Add the new sources wrapping the
+ methods, properties and signals of the new class. Also add the
+ sources to the list of files to be built and add the virtual
+ functions as a TODO.
+ * gio/src/gio_vfuncs.defs: Add the definitions of the virtual
+ functions of the class for when the virtual functions are wrapped.
+ * tools/m4/convert_gio.m4: Add conversions relevant to wrapping the
+ class.
+
+2013-01-03 José Alburquerque <jaalburquerque@gmail.com>
+
+ TlsDatabase: Add a TODO to wrap virtual functions.
+
+ * gio/src/tlsdatabase.hg: Add the virtual functions but as a TODO so
+ that the parameters can be properly ordered according to the order in
+ the methods.
+ * gio/src/gio_vfuncs.defs: Add the virtual function definitions for
+ when the vfuncs are wrapped.
+
+ * gio/src/tlscertificate.hg: Do not wrap a write-only construct-only
+ property.
+
+2013-01-03 José Alburquerque <jaalburquerque@gmail.com>
+
+ TlsDatabase: Reorder parameters so that flags can have defaults.
+
+ * gio/src/tlsdatabase.hg (lookup_certificate_issuer):
+ (lookup_certificate_issuer_async): Reorder the parameters in these
+ methods as is done in the other methods so that the flag parameter can
+ be last and have a default value.
+
+2013-01-03 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsDatabase class which implements TlsFileDatabase.
+
+ * gio/src/filelist.am:
+ * gio/src/tlsdatabase.{ccg,hg}: Add the sources wrapping the C
+ functions and include the sources in the list of files to be built.
+ * tools/m4/convert_gio.m4: Add the necessary conversions for the
+ wrapped methods in the sources.
+
+ * gio/src/tlsfiledatabase.hg: Add a TODO.
+
+2013-01-02 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsFileDatabase interface.
+
+ * gio/src/filelist.am:
+ * gio/src/tlsfiledatabase.{ccg,hg}: Add the new sources wrapping a
+ single property and include them in the list of files to be built.
+ * gio/src/tlsinteraction.hg: Correct a typo.
+
+2013-01-01 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsInteraction class.
+
+ * gio/src/tlsinteraction.{ccg,hg}:
+ * gio/src/filelist.am: Add the sources wrapping the C functions and
+ include the sources in the build.
+ * gio/src/gio_vfuncs.defs: Add the virtual functions of the class.
+ The vfuncs are not wrapped yet so that gmmproc can be modified so that
+ virtual functions with slot parameters can be wrapped as is already
+ possible with methods.
+ * tools/m4/convert_gio.m4: Add necessary conversions.
+
+2012-12-28 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: _WRAP_METHOD: Ensure that slot parameters can be optional.
+
+ * tools/pm/Output.pm (output_wrap_meth): Only pass the slot parameters
+ to the m4 _*METHOD() macros if convert_args_cpp_to_c() signals that a
+ possible slot parameter should be included.
+ (convert_args_cpp_to_c): Add a boolean called 'include_slot' to the
+ objCppfunc object that is by default false that is set when a slot
+ parameter is encountered and should converted.
+
+2012-12-28 José Alburquerque <jaalburquerque@gmail.com>
+
+ Variant: Allow containing complex types in arrays and in variants.
+
+ * glib/src/variant.hg (Variant< Variant<T> >): Add a new class capable
+ of containing any Variant<>. The class is just like
+ Variant<VariantBase> except that with it, it is now possible to store
+ and handle complex variant types in a variant easily in a C++ way.
+ The modified test below exemplifies.
+ (Variant< std::vector<T> >::create): Create a Variant<> for each of
+ the members in the vector and then use g_variant_builder_add_value()
+ to add the underlying GVariant of the wrapped elements in the builder
+ instead of using the variadic g_variant_builder_add() function which
+ causes problems when dealing with types that are more complex than
+ basic ones.
+ (Variant< std::vector<T> >::get_child): Rewritten to get the child as
+ a GVariant, wrap the GVariant in a Variant<> and then get its value
+ instead of assuming that the array in the variant is a fixed array of
+ basic types so that complex types are supported in arrays.
+ (Variant< std::vector<T> >::get): Rewritten as get_child() above so
+ that the elements in the array are gotten as a GVariant, wrapped in a
+ Variant<> and then retrieved and placed in the resulting vector,
+ again, to ensure that a vector of complex types can be stored in a
+ variant.
+ * tests/glibmm_variant/main.cc: Modify the test to ensure that any
+ type other than basic ones are supported.
+
+2012-12-28 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ Gio::Action: Add more documentation of get_state_hint() and get_state().
+
+ * gio/src/action.hg: get_state_hint() and get_state() returns void, which
+ makes them useless. That can't be fixed until the next ABI break. Explain in
+ the documentation what to do instead of calling these methods. Bug #690134.
+
+2012-12-27 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ SignalProxy: Fix the documentation, especially of connect_notify().
+
+ * glib/src/signalproxy.h.m4: Many small fixes of the documentation, and a
+ more thorough rewrite of the doc of SignalProxy[0-6]::connect_notify().
+ Bug #126213, comment 5.
+
+2012-12-18 Andrew Potter <agpotter@gmail.com>
+
+ VariantBase: Add operator for BoolExpr (const void*).
+
+ * glib/src/variant.{ccg,hg}: Adds operator BoolExpr.
+ Also deletes relational operators to prevent unexpected conversion.
+ Bug #690121.
+
+2012-12-13 Andrew Potter <agpotter@gmail.com>
+
+ SimpleAction: Fix stateful action constructor typo, allowing use.
+
+ * gio/src/simpleaction.hg: Fix 'sate' typo to 'state', allowing
+ the constructor to be used. Bug #690122.
+
+2012-12-12 Andrew Potter <agpotter@gmail.com>
+
+ Threads: Add create(slot, name).
+
+ * glib/src/threads.{ccg,hg}: Add a method to create named threads.
+
+ Bug #689863.
+
+2012-11-20 Andrew Potter <agpotter@gmail.com>
+
+ VariantType: Add create_tuple().
+
+ * glib/src/varianttype.{ccg,hg}: Add the method following the style of
+ VariantContainerBase::create_tuple(), completing a TODO.
+
+ Bug #688682.
+
+2012-11-20 José Alburquerque <jaalburquerque@gmail.com>
+
+ VariantType: Correct the referencing in the create*() methods.
+
+ * tools/m4/convert_glib.m4: Correct the 'GVarianType*' to VariantType
+ conversion to not take an extra reference when wrapping the
+ GVariantType in the VariantType.
+ * glib/src/variant.hg:
+ * glib/src/varianttype.hg: Also move the 'const GVariantType'
+ conversion from the global glib convert file (above) to these local
+ files because it takes an extra reference of the GVariantType.
+
+ Bug #688440 (Andrew Potter).
+
+2012-11-18 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: Documentation: Adjust if the method has a slot param.
+
+ * tools/pm/WrapParser.pm (on_wrap_method): Pass the objCppfunc object
+ to the DocParser::lookup_documentation() subroutine so that it can
+ decide if the final parameter of the C function should be excluded
+ from the docs. The final parameter (which would be a gpointer
+ user_data parameter) would be omitted if the C++ method has a slot
+ parameter.
+ * tools/pm/DocsParser.pm (lookup_documentation): Pass the objCppfunc
+ on to the append_parameter_docs() subroutine which does what's
+ described above.
+ (append_parameter_documentation): Decide whether to skip the final C
+ parameter as described above. Also rename 'callback' parameters to
+ 'slot' and use '@a slot' instead of '@a callback' in the main
+ description.
+ (substitute_identifiers): Replace C *Callback types to C++ Slot*
+ types.
+
+ Bug #688587.
+
+2012-11-18 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: _WRAP_METHOD: Support wrapping methods with slots.
+
+ * tools/pm/WrapParser.pm (on_wrap_method): Add code to parse the
+ additional 'slot_name', 'slot_callback' and 'no_slot_copy' options.
+ - The 'slot_name' options specifies the name of the slot parameter in
+ the C++ method declaration.
+ - The 'slot_callback' option specifies the name of the callback to
+ pass to the C function.
+ - The 'no_slot_copy' option specifies that the actual slot should be
+ passed to the C function in the data parameter and not a copy. By
+ default, a copy is used.
+ * tools/pm/Output.pm (output_wrap_meth): Pass the new slot options
+ along to the *METHOD() m4 macros.
+ (convert_args_cpp_to_c):
+ - If there is a slot parameter, ignore the final user_data parameter
+ in the C function when comparing the argument count in the C++
+ method and the C function.
+ - Convert a possible slot parameter to the address of the specified
+ slot callback (with the 'slot_callback' option). Report an error if
+ no callback has been specified.
+ - Pass a 'slot_copy' variable as the final user data parameter to the
+ C function. The variable is declared by the _*METHOD() m4 macros.
+ * tools/m4/method.m4 (_METHOD):
+ (_STATIC_METHOD):
+ - Accept the new 'slot_type', 'slot_name' and 'no_slot_copy' options
+ which specify the C++ slot type (without the const and the &), the
+ C++ slot parameter name and whether to create a copy of the slot or
+ not respectively.
+ - Insert code to declare a 'slot_copy' variable that is either a copy
+ of the slot or a pointer to the actual C++ slot based on the
+ 'no_slot_copy' option.
+
+ Bug #688587.
+
+2012-11-15 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm.h: Include the tlspassword.h header file.
+
+ * gio/giomm.h:
+
+2012-11-14 Debarshi Ray <debarshir@src.gnome.org>
+
+ ustring docs: The global locale should be set when using C++ streams.
+
+ * glib/glibmm/ustring.h: Replace output.imbue(std::locale("")) by
+ std::locale::global(std::locale("")) in the description of how to use
+ std::ostringstream. Bug #661588.
+
+2012-11-13 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsPassword class.
+
+ * gio/src/tlspassword.{ccg,hg}:
+ * gio/src/filelist.am: Add the new sources containing the constructor,
+ methods, properties and virtual functions and include the sources in
+ the build.
+ * gio/src/gio_vfuncs.defs: Add the GTlsPassword virtual functions so
+ that they are recognized by gmmproc.
+ * tools/m4/convert_gio.m4: Add an enum conversion.
+
+2012-11-13 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the GTls* GTypes to the extra defs generation utility.
+
+ * tools/extra_defs_gen/generate_defs_gio.cc: Add the GTypes.
+ * gio/src/gio_signals.defs: And regenerate the signal and property
+ defs file.
+
+2012-11-13 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm.h: Re-add an accidentally removed include.
+
+ * gio/giomm.h: Re-add 'simpleaction.h' which was accidentally removed.
+ Also re-sort the includes by the base filename (without the .h) as
+ they were before.
+
+2012-11-12 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm.h: Include missing headers.
+
+ * gio/giomm.h: Include all the headers generated from the .hg files.
+
+2012-11-11 José Alburquerque <jaalburquerque@gmail.com>
+
+ giomm: Add the TlsCertificate class.
+
+ * gio/src/filelist.am:
+ * gio/src/tlscertificate.{ccg,hg}: Add the sources wrapping the
+ constructors, methods and (most) properties and include the sources in
+ the build.
+ * gio/src/enums.hg: Add the TlsCertificateFlags enum (wrapping the C
+ enum).
+ * tools/extra_defs_gen/generate_defs_gio.cc: Add the GTlsCertificate
+ GType to the list of types for which signal and property defs are to
+ be generated.
+ * gio/src/gio_signals.defs: Regenerate the signal and property defs
+ file.
+ * tools/m4/convert_gio.m4: Add necessary conversions.
+
+ * gio/src/gio_extra_objects.defs: Add TlsClientConnection to avoid a
+ gmmproc docs warning.
+
+2012-11-08 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: _WRAP_CTOR: Handle *_new() functions with a final GError**.
+
+ * tools/pm/WrapParser.pm (on_wrap_ctor): Add code to parse an
+ additional "errthrow" optional option in a _WRAP_CTOR() macro.
+ * tools/pm/Output.pm (output_wrap_ctor): Pass the "errorthrow" option
+ along as a string to:
+ (get_ctor_properties): Ignore the final GError** parameter of the C
+ *_new() function because it does not form part of the property list
+ that the constructor to has to set.
+
+ Bug #687959.
+
+2012-11-07 José Alburquerque <jaalburquerque@gmail.com>
+
+ DesktopAppInfo: Add some new getter methods.
+
+ * gio/src/desktopappinfo.hg: Add the get_keywords(),
+ get_startup_wm_class(), get_generic_name(), get_show_in(),
+ get_nodisplay() and get_categories() getter methods wrapping the
+ corresponding C functions.
+
+2012-11-06 José Alburquerque <jaalburquerque@gmail.com>
+
+ Variant: Don't refsink variants created using the custom cast ctor.
+
+ * glib/src/variant.ccg:
+ * glib/src/variant.hg:
+ * glib/src/variant_basictypes.cc.m4: Remove the call to
+ g_variant_ref_sink() in the create() methods of the variant types that
+ use the custom cast constructor to wrap the newly created C object
+ because the custom cast constructor already refsinks the object if
+ necessary.
+
+2012-11-06 José Alburquerque <jaalburquerque@gmail.com>
+
+ MemoryOutputStream: Add the steal_as_bytes() method.
+
+ * gio/src/memoryoutputstream.{ccg,hg}: Add the method that wraps the
+ corresponding C function.
+
+2012-11-06 José Alburquerque <jaalburquerque@gmail.com>
+
+ AppInfo: Add create_duplicate().
+
+ * gio/src/appinfo.{hg,ccg}: Add the new method (which creates a
+ duplicate of the AppInfo). Also, use gmmproc's optional parameter
+ functionality to wrap the launch_default_for_uri() method without the
+ optional AppLaunchContext parameter.
+
+2012-11-06 José Alburquerque <jaalburquerque@gmail.com>
+
+ Variant< std::vector<std::string> >: Add create_from_object_paths().
+
+ * glib/src/variant.hg: Add the new method that creates a variant of
+ vector of strings out of object paths. This is so the type of the
+ variant is rightly set to G_VARIANT_TYPE_OBJECT_PATH_ARRAY and not
+ G_VARIANT_TYPE_BYTESTRING_ARRAY in case some application needs to make
+ a distinction.
+ Also _IGNORE the g_variant_get_objv() and g_variant_dup_objv()
+ functions because it's possible to get object paths from a variant of
+ vector of strings if it contains them with the existing getter
+ methods because object paths are merely strings.
+ * glib/src/variantiter.hg: Add an _IGNORE.
+ * glib/src/checksum.ccg:
+ * glib/src/convert.ccg: Whitespace.
+
+2012-11-05 José Alburquerque <jaalburquerque@gmail.com>
+
+ Regenerate the XML docs files for glibmm and giomm.
+
+ * gio/src/gio_docs.xml:
+ * glib/src/glib_docs.xml: These files now include enum XML
+ documentation.
+ * glib/src/glib_extra_objects.defs: Add IOChannel to avoid a gmmproc
+ documentation warning.
+
+2012-11-04 José Alburquerque <jaalburquerque@gmail.com>
+
+ gmmproc: Make enum documentation possible.
+
+ * tools/defs_gen/docextract.py (enum_name_pattern): Add a new regular
+ expression that recognizes gtk-doc enum comment blocks (though
+ imperfectly because it also catches things such as structure comment
+ blocks).
+ (identifier_patterns): Append the new enum_name_pattern to the list of
+ patterns used to test each gtk-doc block's identifier to see what type
+ of block it is.
+ (parse_file): Do not add a particular gtk-doc block if it has been
+ marked as a block initially thought to be an enum comment block but
+ later found not to be so.
+ (skip_to_identifier): Mark the current comment block as an enum type
+ if the enum_name_pattern matches the identifier.
+ (process_params): Mark the current block as invalid if the block was
+ recognized as an enum type but no parameters are found or if any of
+ the parameter names are not all caps.
+ (parse_dir): Include .h files for processing because gtk-doc enum
+ comment blocks are included in those files.
+ * tools/defs_gen/docextract_to_xml.py: Add an option to not print out
+ enum docs. Assume that enum docs should be printed out by default.
+ * tools/pm/DocsParser.pm (parse_on_start):
+ (parse_on_end): Add logic to correctly parse an <enum> tag (which is
+ just like the already existing <function> and <signal> tags. The only
+ difference is in the name of the tags. The function name syntax is
+ the same as a C function name, the signal name has the form
+ 'CStructName::signal-name' while the enum name has the form
+ 'CEnumName')
+ (lookup_enum_description): Add this subroutine that gets the
+ the description of the specified enum.
+ (lookup_enum_value_documentation): Add this subroutine that gets the
+ description of an enum value as a Doxygen block.
+ (lookup_documentation): Use the new remove_example_code subroutine
+ described below.
+ (remove_example_code): Add this subroutine that removes example code
+ from the specified text so that it can be used in other places.
+ * tools/pm/Enum.pm (c_prefix): Add a new field to the class storing
+ the enum's C prefix. This field is used when looking up an enum's
+ value documentation.
+ (parse_values): Modified to store the C prefix of the enum.
+ (build_element_list): Modified to lookup the documentation of the
+ values of the enum and insert the Doxygen block just before each
+ value. This allows Doxygen to document each value of the enum.
+ * tools/pm/Output.pm (output_wrap_enum): Modified to lookup
+ the description of the enum previously parsed by the DocParser and
+ merge it with an already passed in comment for the enum which is then
+ passed as before to the _ENUM macro.
+ * tools/m4/enum.m4: Whitespace correction.
+
+ Bug #544694.
+
+2012-11-04 Murray Cumming <murrayc@murrayc.com>
+
+ MountOperation: Correct an ABI break.
+
+ * gio/src/mountoperation.hg: Use the no_default_handler option with
+ the new _WRAP_SIGNAL() to avoid a new on_*() vfunc increasing the size
+ of the class. This got into the 2.34.0 release at the last moment
+ but it seems better to correct it before people use it than to leave it.
+
+2012-11-05 José Alburquerque <jaalburquerque@gmail.com>
+
+ UnixConnection: Remove the const receive_credentials_finish() method.
+
+ * gio/src/unixconnection.hg: It doesn't make sense and there are no
+ other const *_finish() methods in giomm. Further, it's not needed for
+ getting a const Credentials. That's already possible with the
+ existing receive_credentials_finish() method.
+
+2012-11-04 José Alburquerque <jaalburquerque@gmail.com>
+
+ UnixConnection: Add [receive|send]_credentials_[async|finish]().
+
+ * gio/src/unixconnection.{ccg,hg}: Add the new methods (adding
+ non-cancellable versions for the async methods) wrapping the
+ corresponding C functions.
+ * gio/src/socketconnection.hg: Typo.
+
+2012-11-04 José Alburquerque <jaalburquerque@gmail.com>
+
+ ThemedIcon: Wrap the "names" property.
+
+ * gio/src/themedicon.hg:
+
+2012-11-04 José Alburquerque <jaalburquerque@gmail.com>
+
+ SocketConnection: Add connect*() and is_connected() methods.
+
+ * gio/src/socketconnection.{ccg,hg}: Add connect(), connect_async(),
+ connect_finish() and is_connected() methods (wrapping the
+ corresponding C functions).
+ * gio/src/resolver.hg: Add an _IGNORE.
+
+2012-11-04 José Alburquerque <jaalburquerque@gmail.com>
+
+ docextract_to_xml.py: Replace : with ':' in generated XML files.
+
+ * tools/defs_gen/docextract_to_xml.py: Otherwise gmmproc reports
+ errors if this entity is encountered when trying to parse the XML
+ documentation.
+
+2012-11-01 Kjell Ahlstedt <kjell.ahlstedt@bredband.net>
+
+ gmmproc: Improve the documentation of properties.
+
+ * tools/m4/property.m4: Change "the property of the value" to "the value of
+ the property". Make the description of the return value different for
+ PropertyProxy, PropertyProxy_ReadOnly and PropertyProxy_WriteOnly.
+
+2012-10-30 José Alburquerque <jaalburquerque@gmail.com>
+
+ Resolver: Add lookup_records() and lookup_records_finish().
+
+ * glib/glibmm/containerhandle_shared.h: Add TypeTraits specializations
+ for VariantBase (for the futre) and VariantContainerBase.
+ * gio/src/resolver.hg: Add the new methods (mentioned above) because
+ the VariantContainerBase TypeTraits specialization allows the vector
+ utilities to convert to/from GVariants in a GList correctly.
+
+2012-10-29 José Alburquerque <jaalburquerque@gmail.com>
+
+ Resolver: Add the lookup_records_async() methods.
+
+ * gio/src/resolver.{ccg,hg}: Add the methods (cancellable and
+ non-cancellable versions) adding TODO's about wrapping the remaining
+ related methods (lookup_records() and lookup_records_finish()).
+ * tools/m4/convert_gio.m4: Add a necessary enum conversion.
+ * glib/src/variant.hg: Typo discovered while adding above methods.
+
+2012-10-29 José Alburquerque <jaalburquerque@gmail.com>
+
+ Add some TODO's.
+
+ * gio/src/menuitem.hg:
+ * gio/src/menumodel.hg: Add TODO's about possibly adding methods to
+ the classes in these files (these TODO's were added a few days ago and
+ being commited now). Also add a TODO about an unwrapped signal in
+ MenuModel.
+ * glib/src/glib_extra_objects.defs: Add GArray to the list of objects
+ to avoid a gmmproc documentation warning.
+
+2012-10-29 Mark Vender <markv743@yahoo.co.uk>
+
+ Strip trailing whitespace.
+
+ * gio/giomm/*.[h|cc]:
+ * gio/src/*.[hg|ccg]:
+ * glib/glibmm/*.[h|cc]:
+ * glib/src/*.[hg|ccg]: Strip trailing whitespace. Bug #681072.
+
+2012-10-25 José Alburquerque <jaalburquerque@gmail.com>
+
+ ContentType: Fix typo in the content_type_get_symbolic_icon() name.
+
+ * gio/giomm/contenttype.cc: The name was misspelled because the 'o'
+ and 'l' in 'symbolic' were interchanged. The name is correctly
+ spelled in the .h file so I guess it's safe to rename it in the .cc
+ file for 2.34 and the master branch.
+
+2012-10-24 José Alburquerque <jaalburquerque@gmail.com>
+
+ DBus::[Connection|Proxy]: Use ifdefs for the UnixFDList call*() methods.
+
+ * gio/src/dbusconnection.hg:
+ * gio/src/dbusproxy.hg: Place the call*() methods taking a UnixFDList
+ parameter within '#ifdef G_OS_UNIX' ifdefs because the UnixFDList
+ class exists only on the Unix platform.
+
+2012-10-24 José Alburquerque <jaalburquerque@gmail.com>
+
+ Remove the use of g_type_init() because it has been deprecated.
+
+ * glib/glibmm/wrap.cc:
+ * tools/extra_defs_gen/generate_defs_gio.cc:
+ * tools/extra_defs_gen/generate_defs_glib.cc: The docs for the
+ function says that the GType system is initialized automatically now
+ as of 2.36.
+ * tools/extra_defs_gen/generate_extra_defs.cc: Whitespace correction.
+
2.34.0:
2012-10-21 Murray Cumming <murrayc@murrayc.com>
+2.35.8 (unstable);
+
+Glib:
+* Resolver: Add lookup_records(), lookup_records_async()
+ and lookup_records_finish().
+ (José Alburquerque)
+* Signal*::connect(): Make them less thread-unsafe.
+ (Kjell Ahlstedt) Bug #396958 (Daniel Elstner, Chris Vine)
+* Threads: Add create(slot, name) to create named threads.
+ (Andrew Potter) Bug #689863
+* Variant: Allow containing complex types in arrays and in variants.
+ (José Alburquerque)
+* Variant: Don't refsink variants created using the custom cast ctor.
+ (José Alburquerque)
+* Variant< std::vector<std::string> >: Add create_from_object_paths().
+ (José Alburquerque)
+* VariantBase: Add operator for BoolExpr (const void*).
+ (Andrew Potter) Bug #690121
+* VariantType: Add create_tuple().
+ (Andrew Potter) Bug #688682
+* VariantType: Correct the referencing in the create*() methods.
+ (José Alburquerque) Bug #688440 (Andrew Potter)
+
+Gio:
+* AppInfo: Add create_duplicate().
+ (José Alburquerque)
+* DesktopAppInfo: Add some new getter methods.
+ (José Alburquerque)
+* File: Remove refreturn to avoid memory leaks.
+ (Kjell Ahlstedt) Bug #691606 (Dodak4Gi)
+* MemoryOutputStream: Add the steal_as_bytes() method.
+ (José Alburquerque)
+* SimpleAction: Fix stateful action constructor typo, allowing use.
+ (Andrew Potter) Bug #690122
+* SocketConnection: Add connect*() and is_connected() methods.
+ (José Alburquerque)
+* ThemedIcon: Wrap the "names" property.
+ (José Alburquerque)
+* Add TlsConnection, TlsClient, TlsServer, TlsDatabase,
+ TlsCertificate, TlsPassword, TlsFileDatabase and TlsInteraction.
+ (José Alburquerque)
+* UnixConnection: Add [receive|send]_credentials_[async|finish]().
+ (José Alburquerque)
+
+Gio::DBus:
+* DBus::[Connection|Proxy]: Use ifdefs for the UnixFDList call*() methods.
+ (José Alburquerque)
+
+gmmproc:
+* gmmproc: _WRAP_VFUNC: Support the wrapping of slots.
+ (José Alburquerque)
+* gmmproc: _WRAP_METHOD: Support wrapping methods with slots.
+ (José Alburquerque) Bug #688587
+* gmmproc: _WRAP_METHOD: Ensure that slot parameters can be optional.
+ (José Alburquerque)
+* gmmproc: _WRAP_[CREATE|CTOR|METHOD]: Allow any order of {} options.
+ (José Alburquerque)
+* gmmproc: _WRAP_ENUM: Skip enum constants whose names are deleted.
+ (Kjell Ahlstedt) Bug #544694 (Murray Cumming)
+* gmmproc: _WRAP_CTOR: Handle *_new() functions with a final GError**.
+ (José Alburquerque) Bug #687959
+
+Documentation:
+* Signal[Timeout|Idle]::connect_once() docs: Warn about thread-unsafety.
+ (Kjell Ahlstedt) Bug #396963 (Daniel Elstner, Chris Vine)
+* ThreadPool::push() docs: Note that sigc::trackable is not thread-safe.
+ (Kjell Ahlstedt) Bug #512348 (Chris Vine)
+* Threads::Thread::create(): Update the documentation.
+ (Kjell Ahlstedt) Bug #512348 (Chris Vine)
+* SignalProxy: Fix the documentation, especially of connect_notify().
+ (Kjell Ahlstedt) Bug #126213, comment 5.
+* Gio::Action: Add more documentation of get_state_hint() and get_state().
+ (Kjell Ahlstedt) Bug #690134 (Andrew Potter)
+* Predefine G_OS_UNIX or G_OS_WIN32 in Doxygen's configuration file.
+ (Kjell Ahlstedt)
+* gmmproc: Improve the conversion of documentation to Doxygen format.
+ (Kjell Ahlstedt)
+* Documentation: Fix many warnings from Doxygen.
+ (Kjell Ahlstedt)
+* gmmproc: Make enum documentation possible.
+ (José Alburquerque) Bug #544694 (Murray Cumming)
+* gmmproc: Improve the search for documentation of enums.
+ (Kjell Ahlstedt)
+* gmmproc: Documentation: Adjust if the method has a slot param.
+ (José Alburquerque) Bug #688587.
+* docextract_to_xml.py: Replace : with ':' in generated XML files.
+ (José Alburquerque)
+* gmmproc: Improve the documentation of properties.
+ (Kjell Ahlstedt)
+* ustring docs: The global locale should be set when using C++ streams.
+ (Debarshi Ray) Bug #661588
+
+Build/Other:
+* DBus::[Connection|Proxy]: Change ifdef G_OS_LINUX to ifdef G_OS_UNIX.
+ (Kjell Ahlstedt)
+* ContentType: Fix typo in the content_type_get_symbolic_icon() implementation.
+ (José Alburquerque)
+* Remove the use of g_type_init() because it has been deprecated.
+ (José Alburquerque)
+* Strip trailing whitespace.
+ (Mark Vender)
+* Fix the build with warnings enabled.
+ (Murray Cumming)
+
+
+Changes in 2.34 compared to 2.32:
+
+Glib:
+* Added the Bytes class, wrapping GBytes.
+ (Murray Cumming)
+* RegEx: Add get_has_cr_or_lf().
+ (José Alburquerque)
+* Threads::Mutex, RecMutex: Add wrap() functions.
+ (Kjell Ahlstedt) Bug #483790
+* VariantIter: Add init() method.
+ (José Alburquerque)
+
+Gio:
+* ActionGroup: Add the query_action() methods.
+ (José Alburquerque)
+* AppInfo: Added get_display_name(),
+ set_as_last_used_for_type() and get_supported_types().
+ (Murray Cumming)
+* AppLaunchContext: Add setenv(), unsetenv() and get_environment().
+ (Murray Cumming)
+* Application:
+ - Added get_dbus_connection()
+ and get_dbus_object_path().
+ - Allow the application ID to be empty.
+ (Murray Cumming)
+* ContentType:
+ - get_icon(): Fix a refcount error.
+ - Added get_symbolic_icon().
+ (Murray Cumming)
+* Add Converter, ZlibCompressor, ZlibDecompressor and
+ CharsetConverter classes.
+ (José Alburquerque)
+* Add ConverterInputStream and ConverterOutputStream.
+ (José Alburquerque)
+* DBusAuthObserver: Added allow_mechanism().
+ (Murray Cumming)
+* Drive: Added get_symbolic_icon().
+ (Murray Cumming)
+* File: Add remove_async() and remove_finish().
+ (Murray Cumming)
+* FileAttributeMatcher: Add create_difference() and to_string().
+ (José Alburquerque)
+* FileInfo:
+ - Add has_namespace(), [get|set]_attribute_status(),
+ and [get|set]_attribute_strings().
+ (José Alburquerque)
+ - Added get_symbolic_icon().
+ (Murray Cumming)
+* InetSocketAddress: Added get_flowinfo() and get_scope_id()
+ (Murray Cumming)
+* InputStream: Added read_bytes(), read_bytes_async() and read_bytes_finish().
+ (Murray Cumming)
+* IOStream: Add splice_async() splice_finish().
+ (José Alburquerque)
+* Menu: Added append_section().
+ (Murray Cumming)
+* MenuItem:
+ - Added get_link().
+ (Murray Cumming)
+ - Add get_attribute().
+ (José Alburquerque)
+* MenuModel: Added is_mutable() and get_n_items().
+ (Murray Cumming)
+* Mount: Added get_symbolic_icon().
+ (Murray Cumming)
+* MountOperation: Wrap the "show-unmount-progess" signal.
+ (José Alburquerque)
+* OutputStream: Added write_bytes(), write_bytes_async() and write_bytes_finish().
+ (Murray Cumming)
+* Add PollableInputStream and PollableOutputStream.
+ (José Alburquerque)
+* Proxy: Add call(), call_sync() and call_finish() for unix_fd_list.
+ (Murray Cumming)
+* ProxyAddress: Added get_destination_protocol()
+ and get_uri().
+ (Murray Cumming)
+* Add Resource
+ Bug #674545 (Kalev Lember)
+* Socket: Added get_available_bytes(), get_ttl(), set_ttl(),
+ get_broadcast(), set_broadcast(),
+ get_multicast_loopback(), set_multicast_loopback(),
+ get_multicast_ttl(), set_multicast_ttl(),
+ join_multicast_group(), leave_multicast_group(),
+ and properties.
+ (Murray Cumming)
+* Volume:
+ - Added get_symbolic_icon().
+ - Added get_sort_key().
+ (Murray Cumming)
+
+Gio::DBus:
+* Connection:
+ - Added get_last_serial().
+ (Murray Cumming)
+ - Added call_[finish|sync]() with UnixFDLists.
+ (José Alburquerque)#662371.
+
+gmmproc:
+* Add _INCLUDE_IN_WRAP_INIT, _GMMPROC_WRAP_CONDITIONALLY.
+ (Kjell Ahlstedt) Bug #678883.
+* Add _CUSTOM_CTOR_CAST
+ (Krzesimir Nowak)
+* _WRAP_VFUNC: Handle virtual functions that throw GErrors.
+ (José Alburquerque) Bug #683460
+* Add a _NO_WRAP_INIT_REGISTRATION macro
+ (José Alburquerque) Bug #684006
+* _CLASS_GOBJECT: Allow classes to have custom wrap() functions.
+ (José Alburquerque) Bug #684006
+* _WRAP_METHOD: Allow setting parameters from C output params.
+ (José Alburquerque) Bug #662371
+
+
2.34.0 (stable):
* Some minor documentation improvements.
## You should have received a copy of the GNU Lesser General Public License
## along with this library. If not, see <http://www.gnu.org/licenses/>.
-AC_INIT([glibmm], [2.34.0],
+AC_INIT([glibmm], [2.35.8],
[http://bugzilla.gnome.org/enter_bug.cgi?product=glibmm],
[glibmm], [http://www.gtkmm.org/])
AC_PREREQ([2.59])
AC_DEFINE([GIOMM_STATIC_LIB], [1], [Define if giomm is built as a static library])
])
-glibreq='2.0 >= 2.34.0'
+glibreq='2.0 >= 2.35.8'
GLIBMM_MODULES="sigc++-2.0 >= 2.2.10 glib-$glibreq gobject-$glibreq gmodule-$glibreq"
GIOMM_MODULES="$GLIBMM_MODULES gio-$glibreq"
-# Doxyfile 1.6.1
+# Doxyfile 1.8.3
# @configure_input@
+# When Doxyfile.in is updated with 'doxygen -s -u Doxyfile.in' some lines
+# will be distorted or removed, and must be manually restored.
+# - These comment lines, including the configure_input line.
+# - The lines with HOST_WINDOWS_NATIVE_[FALSE|TRUE].
+# (True of Doxygen 1.8.3. Don't know how future releases will behave.)
+
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = @PACKAGE_NAME@
PROJECT_NUMBER = @PACKAGE_VERSION@
+PROJECT_BRIEF =
+PROJECT_LOGO =
OUTPUT_DIRECTORY = reference
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
-ALIASES = "newin{2}=\xrefitem since_\1_\2 \"Since @PACKAGE_NAME@ \1.\2\" \"New API in @PACKAGE_NAME@ \1.\2\""
+ALIASES = "newin{2}=\xrefitem since_\1_\2 \"Since @PACKAGE_NAME@ \1.\2\" \"New API in @PACKAGE_NAME@ \1.\2\"" \
+ "newin{3}=\xrefitem since_\1_\2_\3 \"Since @PACKAGE_NAME@ \1.\2.\3\" \"New API in @PACKAGE_NAME@ \1.\2.\3\""
+TCL_SUBST =
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
+MARKDOWN_SUPPORT = YES
+AUTOLINK_SUPPORT = YES
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS = NO
TYPEDEF_HIDES_STRUCT = NO
SYMBOL_CACHE_SIZE = 0
+LOOKUP_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = NO
+EXTRACT_PACKAGE = NO
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = NO
EXTRACT_LOCAL_METHODS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
+FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_MEMBERS_CTORS_1ST = YES
SORT_GROUP_NAMES = YES
SORT_BY_SCOPE_NAME = YES
+STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = NO
GENERATE_TESTLIST = NO
GENERATE_BUGLIST = NO
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 2
SHOW_USED_FILES = NO
-SHOW_DIRECTORIES = NO
SHOW_FILES = NO
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
+CITE_BIB_FILES =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET = "@abs_top_srcdir@/docs/doxygen.css"
-HTML_ALIGN_MEMBERS = YES
+HTML_EXTRA_STYLESHEET =
+HTML_EXTRA_FILES =
+HTML_COLORSTYLE_HUE = 220
+HTML_COLORSTYLE_SAT = 100
+HTML_COLORSTYLE_GAMMA = 80
+HTML_TIMESTAMP = YES
HTML_DYNAMIC_SECTIONS = NO
+HTML_INDEX_NUM_ENTRIES = 100
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME = Publisher
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
+GENERATE_ECLIPSEHELP = NO
+ECLIPSE_DOC_ID = org.doxygen.Project
DISABLE_INDEX = NO
+GENERATE_TREEVIEW = NO
ENUM_VALUES_PER_LINE = 1
-GENERATE_TREEVIEW = NONE
-USE_INLINE_TREES = NO
TREEVIEW_WIDTH = 250
+EXT_LINKS_IN_WINDOW = NO
FORMULA_FONTSIZE = 10
+FORMULA_TRANSPARENT = YES
+USE_MATHJAX = NO
+MATHJAX_FORMAT = HTML-CSS
+MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS =
SEARCHENGINE = NO
+SERVER_BASED_SEARCH = NO
+EXTERNAL_SEARCH = NO
+SEARCHENGINE_URL =
+SEARCHDATA_FILE = searchdata.xml
+EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
+LATEX_FOOTER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
LATEX_SOURCE_CODE = NO
+LATEX_BIB_STYLE = plain
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GLIBMM_HAVE_WIDE_STREAM \
GLIBMM_PROPERTIES_ENABLED \
GLIBMM_VFUNCS_ENABLED
+@HOST_WINDOWS_NATIVE_FALSE@PREDEFINED += G_OS_UNIX
+@HOST_WINDOWS_NATIVE_TRUE@PREDEFINED += G_OS_WIN32
EXPAND_AS_DEFINED = GLIBMM_MAJOR_VERSION \
GLIBMM_MINOR_VERSION \
GLIBMM_MICRO_VERSION \
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = NO
HAVE_DOT = YES
+DOT_NUM_THREADS = 0
DOT_FONTNAME = Sans
DOT_FONTSIZE = 10
DOT_FONTPATH =
COLLABORATION_GRAPH = NO
GROUP_GRAPHS = NO
UML_LOOK = NO
+UML_LIMIT_NUM_FIELDS = 10
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = NO
INCLUDED_BY_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = NO
DOT_IMAGE_FORMAT = png
+INTERACTIVE_SVG = NO
DOT_PATH =
DOTFILE_DIRS =
+MSCFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
namespace
{
-class MessageQueue : public sigc::trackable
+class MessageQueue
{
public:
MessageQueue();
#include <giomm/action.h>
#include <giomm/actiongroup.h>
+#include <giomm/actionmap.h>
#include <giomm/appinfo.h>
+#include <giomm/applaunchcontext.h>
#include <giomm/application.h>
#include <giomm/applicationcommandline.h>
+#include <giomm/asyncinitable.h>
#include <giomm/asyncresult.h>
#include <giomm/bufferedinputstream.h>
#include <giomm/bufferedoutputstream.h>
#include <giomm/cancellable.h>
+#include <giomm/charsetconverter.h>
#include <giomm/contenttype.h>
+#include <giomm/converter.h>
+#include <giomm/converterinputstream.h>
+#include <giomm/converteroutputstream.h>
+#include <giomm/credentials.h>
#include <giomm/datainputstream.h>
#include <giomm/dataoutputstream.h>
+#include <giomm/dbusactiongroup.h>
#include <giomm/dbusaddress.h>
#include <giomm/dbusauthobserver.h>
#include <giomm/dbusconnection.h>
#include <giomm/dbuserror.h>
#include <giomm/dbuserrorutils.h>
+#include <giomm/dbusinterface.h>
+#include <giomm/dbusinterfacevtable.h>
#include <giomm/dbusintrospection.h>
#include <giomm/dbusmenumodel.h>
#include <giomm/dbusmessage.h>
#include <giomm/dbusmethodinvocation.h>
+#include <giomm/dbusobject.h>
#include <giomm/dbusownname.h>
#include <giomm/dbusproxy.h>
#include <giomm/dbusserver.h>
+#include <giomm/dbussubtreevtable.h>
#include <giomm/dbusutils.h>
#include <giomm/dbuswatchname.h>
#ifndef G_OS_WIN32
# include <giomm/desktopappinfo.h>
#endif
#include <giomm/drive.h>
-#include <giomm/emblemedicon.h>
#include <giomm/emblem.h>
+#include <giomm/emblemedicon.h>
#include <giomm/enums.h>
#include <giomm/error.h>
+#include <giomm/file.h>
#include <giomm/fileattributeinfo.h>
#include <giomm/fileattributeinfolist.h>
#include <giomm/fileenumerator.h>
-#include <giomm/file.h>
#include <giomm/fileicon.h>
#include <giomm/fileinfo.h>
#include <giomm/fileinputstream.h>
#include <giomm/inputstream.h>
#include <giomm/iostream.h>
#include <giomm/loadableicon.h>
+#include <giomm/memoryinputstream.h>
+#include <giomm/memoryoutputstream.h>
#include <giomm/menu.h>
+#include <giomm/menuattributeiter.h>
#include <giomm/menuitem.h>
+#include <giomm/menulinkiter.h>
#include <giomm/menumodel.h>
-#include <giomm/memoryinputstream.h>
-#include <giomm/memoryoutputstream.h>
#include <giomm/mount.h>
#include <giomm/mountoperation.h>
#include <giomm/networkaddress.h>
#include <giomm/networkservice.h>
#include <giomm/outputstream.h>
+#include <giomm/pollableinputstream.h>
+#include <giomm/pollableoutputstream.h>
#include <giomm/proxy.h>
+#include <giomm/proxyaddress.h>
#include <giomm/proxyresolver.h>
+#include <giomm/remoteactiongroup.h>
#include <giomm/resolver.h>
+#include <giomm/resource.h>
#include <giomm/seekable.h>
#include <giomm/settings.h>
#include <giomm/simpleaction.h>
#include <giomm/socketconnectable.h>
#include <giomm/socketconnection.h>
#include <giomm/socketcontrolmessage.h>
+#include <giomm/socketlistener.h>
+#include <giomm/socketservice.h>
#include <giomm/srvtarget.h>
#include <giomm/tcpconnection.h>
#include <giomm/themedicon.h>
+#include <giomm/threadedsocketservice.h>
+#include <giomm/tlscertificate.h>
+#include <giomm/tlsclientconnection.h>
+#include <giomm/tlsconnection.h>
+#include <giomm/tlsdatabase.h>
+#include <giomm/tlsfiledatabase.h>
+#include <giomm/tlsinteraction.h>
+#include <giomm/tlspassword.h>
+#include <giomm/tlsserverconnection.h>
#ifndef G_OS_WIN32
# include <giomm/unixconnection.h>
# include <giomm/unixcredentialsmessage.h>
#endif
#include <giomm/volume.h>
#include <giomm/volumemonitor.h>
+#include <giomm/zlibcompressor.h>
+#include <giomm/zlibdecompressor.h>
#endif /* #ifndef _GIOMM_H */
return retvalue;
}
-Glib::RefPtr<Gio::Icon> content_type_get_symbloic_icon(const Glib::ustring& type)
+Glib::RefPtr<Gio::Icon> content_type_get_symbolic_icon(const Glib::ustring& type)
{
Glib::RefPtr<Icon> retvalue = Glib::wrap(g_content_type_get_symbolic_icon(type.c_str()));
if(retvalue)
* given data.
*/
Glib::ustring content_type_guess(const std::string& filename,
- const guchar* data, gsize data_size,
+ const guchar* data, gsize data_size,
bool& result_uncertain);
/**
* given data.
*/
Glib::ustring content_type_guess(const std::string& filename,
- const std::string& data,
+ const std::string& data,
bool& result_uncertain);
/** Tries to guess the type of the tree with root @a root, by
* of content types, with the best guess coming first.
*
* The types returned all have the form x-content/foo, e.g.
- * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
+ * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
* (for a camera memory card). See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink>
* specification for more on x-content types.
*
/* init.cc
- *
+ *
* Copyright (C) 2007 The gtkmm team
*
* This library is free software; you can redistribute it and/or
#include "wrap_init.h"
/* init.h
- *
+ *
* Copyright (C) 2007 The gtkmm development team
*
* This library is free software; you can redistribute it and/or
#define _GIOMM_WRAP_INIT_H
/* wrap_init.h
- *
+ *
* Copyright (C) 2007 The gtkmm development team
*
* This library is free software; you can redistribute it and/or
_WRAP_METHOD(Glib::ustring get_name() const, g_action_get_name)
_WRAP_METHOD(Glib::VariantType get_parameter_type() const, g_action_get_parameter_type)
_WRAP_METHOD(Glib::VariantType get_state_type() const, g_action_get_state_type)
+
+ //TODO: Change the return type of get_state_hint() when we can break ABI.
+ // See https://bugzilla.gnome.org/show_bug.cgi?id=690134
+ /** Requests a hint about the valid range of values for the state of
+ * @a action.
+ *
+ * @note
+ * This method is useless in its present form. It should return Glib::VariantBase,
+ * but it returns @c void. This bug cannot be fixed until the ABI of glibmm can be broken.
+ * Meanwhile you can use the C function in glib like so:
+ * @code
+ * Glib::VariantBase state_hint = Glib::wrap(g_action_get_state_hint(myAction.gobj()));
+ * @endcode
+ * If myAction is a const object:
+ * @code
+ * Glib::VariantBase state_hint = Glib::wrap(g_action_get_state_hint(const_cast<GAction*>(myAction.gobj())));
+ * @endcode
+ *
+ * If <tt>0</tt> is returned it either means that the action is not stateful
+ * or that there is no hint about the valid range of values for the
+ * state of the action.
+ *
+ * If a Variant array is returned then each item in the array is a
+ * possible value for the state. If a Variant pair (ie: two-tuple) is
+ * returned then the tuple specifies the inclusive lower and upper bound
+ * of valid values for the state.
+ *
+ * In any case, the information is merely a hint. It may be possible to
+ * have a state value outside of the hinted range and setting a value
+ * within the range may fail.
+ *
+ * @newin{2,28}
+ * @return The state range hint.
+ */
_WRAP_METHOD(void get_state_hint() const, g_action_get_state_hint)
+
_WRAP_METHOD(bool get_enabled() const, g_action_get_enabled)
+
+ //TODO: Change the return type of get_state() when we can break ABI.
+ // See https://bugzilla.gnome.org/show_bug.cgi?id=690134
+ /** Queries the current state of @a action.
+ *
+ * @note
+ * This method is useless in its present form. It should return Glib::VariantBase,
+ * but it returns @c void. This bug cannot be fixed until the ABI of glibmm can be broken.
+ * Meanwhile you can use property_state() like so:
+ * @code
+ * Glib::VariantBase state = myAction.property_state();
+ * @endcode
+ * You can also use the C function in glib like so:
+ * @code
+ * Glib::VariantBase state = Glib::wrap(g_action_get_state(myAction.gobj()));
+ * @endcode
+ * If myAction is a const object:
+ * @code
+ * Glib::VariantBase state = Glib::wrap(g_action_get_state(const_cast<GAction*>(myAction.gobj())));
+ * @endcode
+ *
+ * If the action is not stateful then <tt>0</tt> will be returned. If the
+ * action is stateful then the type of the return value is the type
+ * given by get_state_type().
+ *
+ * @newin{2,28}
+ * @return The current state of the action.
+ */
_WRAP_METHOD(void get_state() const, g_action_get_state)
_WRAP_METHOD(void change_state(const Glib::VariantBase& value), g_action_change_state)
return Glib::wrap(capp_info);
}
-bool AppInfo::launch_default_for_uri(const std::string& uri)
+Glib::RefPtr<AppInfo> AppInfo::create_duplicate() const
{
- GError* gerror = 0;
- const bool retvalue = g_app_info_launch_default_for_uri(uri.c_str(), 0, &(gerror));
-
- if(gerror)
- ::Glib::Error::throw_exception(gerror);
-
- return retvalue;
+ return Glib::wrap(g_app_info_dup(const_cast<GAppInfo*>(gobj())));
}
bool AppInfo::launch(const Glib::RefPtr<Gio::File>& file, const Glib::RefPtr<AppLaunchContext>& launch_context)
{
std::vector< Glib::RefPtr<Gio::File> > vec;
vec.push_back(file);
-
+
GError* gerror = 0;
bool retvalue = g_app_info_launch(gobj(), Glib::ListHandler<Glib::RefPtr<Gio::File> >::vector_to_list(vec).data (), Glib::unwrap(launch_context), &(gerror));
if(gerror)
{
std::vector< Glib::RefPtr<Gio::File> > vec;
vec.push_back(file);
-
+
GError* gerror = 0;
bool retvalue = g_app_info_launch(gobj(), Glib::ListHandler<Glib::RefPtr<Gio::File> >::vector_to_list(vec).data (), 0, &(gerror));
if(gerror)
{
std::vector<std::string> vec;
vec.push_back(uri);
-
+
GError* gerror = 0;
bool retvalue = g_app_info_launch_uris(gobj(), Glib::ListHandler<std::string>::vector_to_list(vec).data (), Glib::unwrap(launch_context), &(gerror));
if(gerror)
{
std::vector<std::string> vec;
vec.push_back(uri);
-
+
GError* gerror = 0;
bool retvalue = g_app_info_launch_uris(gobj(), Glib::ListHandler<std::string>::vector_to_list(vec).data (), 0, &(gerror));
if(gerror)
class File;
-/** Application information, to describe applications installed on the system,
+/** Application information, to describe applications installed on the system,
* and launch them.
* See also AppLaunchContext.
*
const std::string& application_name,
AppInfoCreateFlags flags);
- //_IGNORE(g_app_info_dup)
- _IGNORE(g_app_info_equal)
+ /** Creates a duplicate of this AppInfo.
+ * @return A duplicate of this AppInfo.
+ * @newin{2,36}
+ */
+ Glib::RefPtr<AppInfo> create_duplicate() const;
+ _IGNORE(g_app_info_dup)
// Note that the implementation of equal() is virtual via equal_vfunc().
+ /** Checks if two AppInfo<!-- -->s are equal.
+ * @param other The other AppInfo.
+ * @return <tt>true</tt> if @a *this is equal to @a other, <tt>false</tt> otherwise.
+ */
_WRAP_METHOD(bool equal(const Glib::RefPtr<AppInfo>& other) const, g_app_info_equal)
_WRAP_METHOD(std::string get_id() const, g_app_info_get_id)
* as an argument, using the optional @a launch_context to get information
* about the details of the launcher (like what screen it is on).
* On error, an exception will be thrown accordingly.
- *
+ *
* Note that even if the launch is successful the application launched
* can fail to start if it runs into problems during startup. There is
* no way to detect this.
- *
+ *
* Some URIs can be changed when passed through a GFile (for instance
* unsupported uris with strange formats like mailto:), so if you have
* a textual uri you want to pass in as argument, consider using
* launch_uris() instead.
- *
- * On UNIX, this function sets the <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>
+ *
+ * On UNIX, this function sets the @c GIO_LAUNCHED_DESKTOP_FILE
* environment variable with the path of the launched desktop file and
- * <envar>GIO_LAUNCHED_DESKTOP_FILE_PID</envar> to the process
+ * @c GIO_LAUNCHED_DESKTOP_FILE_PID to the process
* id of the launched process. This can be used to ignore
- * <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>, should it be inherited
- * by further processes. The <envar>DISPLAY</envar> and
- * <envar>DESKTOP_STARTUP_ID</envar> environment variables are also
+ * @c GIO_LAUNCHED_DESKTOP_FILE, should it be inherited
+ * by further processes. The @c DISPLAY and
+ * @c DESKTOP_STARTUP_ID environment variables are also
* set, based on information provided in @a launch_context.
- * @param files A List of File objects.
+ * @param file A File object.
* @param launch_context An AppLaunchContext.
* @return <tt>true</tt> on successful launch, <tt>false</tt> otherwise.
*
* @newin{3,2}
*/
bool launch(const Glib::RefPtr<Gio::File>& file, const Glib::RefPtr<AppLaunchContext>& launch_context);
-
+
/** Launches the application. This passes the @a file to the launched application
- * as an arguments.
+ * as an argument.
* On error, an exception will be thrown accordingly.
- *
+ *
* Note that even if the launch is successful the application launched
* can fail to start if it runs into problems during startup. There is
* no way to detect this.
- *
+ *
* Some URIs can be changed when passed through a GFile (for instance
* unsupported uris with strange formats like mailto:), so if you have
* a textual uri you want to pass in as argument, consider using
* launch_uris() instead.
- *
- * On UNIX, this function sets the <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>
+ *
+ * On UNIX, this function sets the @c GIO_LAUNCHED_DESKTOP_FILE
* environment variable with the path of the launched desktop file and
- * <envar>GIO_LAUNCHED_DESKTOP_FILE_PID</envar> to the process
+ * @c GIO_LAUNCHED_DESKTOP_FILE_PID to the process
* id of the launched process. This can be used to ignore
- * <envar>GIO_LAUNCHED_DESKTOP_FILE</envar>, should it be inherited
- * by further processes. The <envar>DISPLAY</envar> and
- * <envar>DESKTOP_STARTUP_ID</envar> environment variables are also
+ * @c GIO_LAUNCHED_DESKTOP_FILE, should it be inherited
+ * by further processes. The @c DISPLAY and
+ * @c DESKTOP_STARTUP_ID environment variables are also
* set, based on information provided in @a launch_context.
- * @param files A File object.
+ * @param file A File object.
* @return <tt>true</tt> on successful launch, <tt>false</tt> otherwise.
*
* @newin{3,2}
*/
bool launch(const Glib::RefPtr<Gio::File>& file);
-
+
_WRAP_METHOD(bool launch(const std::vector< Glib::RefPtr<Gio::File> >& files,
const Glib::RefPtr<AppLaunchContext>& launch_context{?}),
g_app_info_launch,
const Glib::RefPtr<AppLaunchContext>& launch_context{?}),
g_app_info_launch_uris,
errthrow)
-
+
/** Launches the application. This passes the @a uri to the launched application
* as an arguments, using the optional @a launch_context to get information
* about the details of the launcher (like what screen it is on).
* On error, an exception will be thrown accordingly.
- *
+ *
* Note that even if the launch is successful the application launched
* can fail to start if it runs into problems during startup. There is
* no way to detect this.
* @newin{3,2}
*/
bool launch_uri(const std::string& uris);
-
+
_WRAP_METHOD(bool should_show() const, g_app_info_should_show)
// FIXME: use better terminology than delete/do_delete
_WRAP_METHOD(bool can_delete() const, g_app_info_can_delete)
_WRAP_METHOD(static Glib::RefPtr<AppInfo> get_default_for_type(const std::string& content_type, bool must_support_uris = true), g_app_info_get_default_for_type)
_WRAP_METHOD(static Glib::RefPtr<AppInfo> get_default_for_uri_scheme(const std::string& uri_scheme), g_app_info_get_default_for_uri_scheme)
_WRAP_METHOD(static void reset_type_associations(const std::string& content_type), g_app_info_reset_type_associations)
- _WRAP_METHOD(static bool launch_default_for_uri(const std::string& uri, const Glib::RefPtr<AppLaunchContext>& context), g_app_info_launch_default_for_uri, errthrow)
- // same as above but without optional AppLaunchContext
- static bool launch_default_for_uri(const std::string& uri);
+ _WRAP_METHOD(static bool launch_default_for_uri(const std::string& uri, const Glib::RefPtr<AppLaunchContext>& launch_context{?}), g_app_info_launch_default_for_uri, errthrow)
protected:
//_WRAP_VFUNC(Glib::RefPtr<AppInfo> dup(), "dup")
};
} // namespace Gio
-
namespace
{
-static void Application_signal_open_callback(GApplication* self, GFile** files,
+static void Application_signal_open_callback(GApplication* self, GFile** files,
gint n_files, const gchar* hint, void* data)
{
typedef sigc::slot< void, const Gio::Application::type_vec_files&, const Glib::ustring& > SlotType;
{
vec_files[i] = Glib::wrap(files[i], true);
}
-
+
const Glib::ustring hint_str = (hint ? hint : Glib::ustring());
// Do not try to call a signal on a disassociated wrapper.
{
vec_files[i] = Glib::wrap(files[i], true);
}
-
+
const Glib::ustring hint_str = (hint ? hint : Glib::ustring());
// Do not try to call a signal on a disassociated wrapper.
Glib::ObjectBase(0),
Glib::Object(Glib::ConstructParams(custom_class_init(), "application_id", (application_id.empty() ? 0 : application_id.c_str()), "flags", ((GApplicationFlags)(flags)), static_cast<char*>(0)))
{
-
+
}
//static
g_application_set_default(0);
}
-void Application_Class::open_callback(GApplication* self, GFile** files,
+void Application_Class::open_callback(GApplication* self, GFile** files,
gint n_files, const gchar *hint)
{
Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
for (int i = 0; i < n_files; i++) {
vec_files[i] = Glib::wrap(files[i], true);
}
-
+
const Glib::ustring hint_str = (hint ? hint : Glib::ustring());
-
+
obj->on_open(vec_files, hint_str);
return;
}
}
}
}
-
+
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
);
);
if(base && base->open) {
- (*base->open)(gobj(),
+ (*base->open)(gobj(),
Glib::ArrayHandler<type_vec_files::value_type>::vector_to_array(files).data(),
files.size(),
hint.c_str());
void Application::open(const type_vec_files& files, const Glib::ustring& hint)
{
- g_application_open(gobj(),
+ g_application_open(gobj(),
Glib::ArrayHandler<type_vec_files::value_type>::vector_to_array(files).data(),
files.size(),
hint.c_str());
/** Constructs an application instance.
* If no application ID is given then some features (most notably application uniqueness) will be disabled.
*
- * @aparam application_id The application ID.
+ * @param application_id The application ID.
* @param flags The application flags.
*/
explicit Application(const Glib::ustring& application_id = Glib::ustring(), ApplicationFlags flags = APPLICATION_FLAGS_NONE);
/** Creates an application instance.
* If no application ID is given then some features (most notably application uniqueness) will be disabled.
*
- * @aparam application_id The application ID.
+ * @param application_id The application ID.
* @param flags The application flags.
*/
_WRAP_CREATE(const Glib::ustring& application_id = Glib::ustring(), ApplicationFlags flags = APPLICATION_FLAGS_NONE)
*/
void open(const type_vec_files& files, const Glib::ustring& hint = Glib::ustring());
_IGNORE(g_application_open)
-
+
/* Opens the given file.
*
* In essence, this results in the open signal being emitted
_WRAP_SIGNAL(void startup(), "startup")
_WRAP_SIGNAL(void activate(), "activate")
-
+
//We wrap the open signal without _WRAP_SIGNAL(), because we need to change its parameters.
//See bug https://bugzilla.gnome.org/show_bug.cgi?id=637457
Glib::SignalProxy2< void, const type_vec_files&, const Glib::ustring& > signal_open();
#m4 _CONVERSION(`char**&', `gchar***',`&($3)')
#m4 _CONVERSION(`gchar***', `char**&',`*($3)')
_WRAP_VFUNC(bool local_command_line(char**& arguments, int& exit_status), local_command_line)
-
+
#m4 _CONVERSION(`GVariant*',`const Glib::VariantBase&',`Glib::wrap($3,true)')
_WRAP_VFUNC(void before_emit(const Glib::VariantBase& platform_data), "before_emit")
private:
/** This is just a way to call Glib::init() (which calls g_type_init()) before
- * calling application_class_.init(), so that
+ * calling application_class_.init(), so that
* g_application_get_type() will always succeed.
* See https://bugzilla.gnome.org/show_bug.cgi?id=639925
*/
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-
+
#include <gio/gio.h>
#include <glibmm/vectorutils.h>
void ApplicationCommandLine::print(const Glib::ustring& message)
{
- g_application_command_line_print(gobj(), "%s", message.c_str());
+ g_application_command_line_print(gobj(), "%s", message.c_str());
}
void ApplicationCommandLine::printerr(const Glib::ustring& message)
{
- g_application_command_line_printerr(gobj(), "%s", message.c_str());
+ g_application_command_line_printerr(gobj(), "%s", message.c_str());
}
} //namespace Gio
public:
_WRAP_METHOD(char** get_arguments(int& argc) const, g_application_command_line_get_arguments)
-
+
//We use std::string instead of ustring because the C documentation says that it may be non-UTF-8 data:
_WRAP_METHOD(std::string get_cwd() const, g_application_command_line_get_cwd)
//We use std::string instead of ustring because the C documentation says that it may be non-UTF-8 data:
#m4 _CONVERSION(`const gchar* const*',`std::vector<std::string>',`Glib::ArrayHandler<std::string>::array_to_vector($3, Glib::OWNERSHIP_NONE)')
_WRAP_METHOD(std::vector<std::string> get_environ() const, g_application_command_line_get_environ)
-
+
//We use std::string instead of ustring because the C documentation says that it may be non-UTF-8 data:
_WRAP_METHOD(std::string getenv(const Glib::ustring& name) const, g_application_command_line_getenv)
-
+
_WRAP_METHOD(bool is_remote() const, g_application_command_line_get_is_remote)
#m4 _CONVERSION(`GVariant*',`Glib::Variant< std::map<Glib::ustring, Glib::VariantBase> >',`$2($3)')
_WRAP_METHOD(Glib::Variant< std::map<Glib::ustring, Glib::VariantBase> > get_platform_data() const, g_application_command_line_get_platform_data)
-
+
_WRAP_METHOD(void set_exit_status(int exit_status), g_application_command_line_set_exit_status)
_WRAP_METHOD(int get_exit_status() const, g_application_command_line_get_exit_status)
-
+
/** Formats a message and prints it using the stdout print handler in the invoking process.
* If this is a local invocation then this is exactly equivalent to g_print().
* If this is remote then this is equivalent to calling g_print() in the invoking process.
*/
void print(const Glib::ustring& message);
_IGNORE(g_application_command_line_print)
-
+
/** Formats a message and prints it using the stderr print handler in the invoking process.
* If this is a local invocation then this is exactly equivalent to g_printerr().
* If this is remote then this is equivalent to calling g_printerr() in the invoking process.
#endif //GLIBMM_EXCEPTIONS_ENABLED
}
}
-
+
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
#endif //GLIBMM_EXCEPTIONS_ENABLED
}
}
-
+
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
typedef gboolean RType;
return RType();
}
-bool Gio::AsyncInitable::init_finish_vfunc(const Glib::RefPtr<AsyncResult>& res)
+bool Gio::AsyncInitable::init_finish_vfunc(const Glib::RefPtr<AsyncResult>& res)
{
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
* C applications you generally just call g_async_initable_new_async()
* directly, or indirectly via a foo_thing_new_async() wrapper. This will call
* g_async_initable_init_async() under the cover, calling back with NULL and a
- * set GError on failure.
+ * set GError on failure.
*/
class AsyncInitable : public Glib::Interface
{
void init_async(const SlotAsyncReady& slot,
int io_priority = Glib::PRIORITY_DEFAULT);
- _WRAP_METHOD(bool init_finish(const Glib::RefPtr<AsyncResult>& result), g_async_initable_init_finish, errthrow)
+ _WRAP_METHOD(bool init_finish(const Glib::RefPtr<AsyncResult>& res), g_async_initable_init_finish, errthrow)
_WRAP_METHOD(Glib::RefPtr<Glib::Object> create_finish(const Glib::RefPtr<AsyncResult>& res), g_async_initable_new_finish, errthrow)
/** @throw Glib::Errror.
*/
virtual bool init_finish_vfunc(const Glib::RefPtr<AsyncResult>& res);
-
+
protected:
#m4begin
_PUSH(SECTION_PCC_CLASS_INIT_VFUNCS)
typedef sigc::slot<void, Glib::RefPtr<AsyncResult>& > SlotAsyncReady;
/** Provides a base class for implementing asynchronous function results.
- * Asynchronous operations are broken up into two separate operations which are chained together by a SlotAsyncReady.
- * To begin an asynchronous operation, provide a SlotAsyncReady to the asynchronous function. This callback will be triggered
- * when the operation has completed, and will be passed an AsyncResult instance filled with the details of the operation's success or
- * failure, the object the asynchronous function was started for and any error codes returned. The asynchronous callback function is then
+ * Asynchronous operations are broken up into two separate operations which are chained together by a SlotAsyncReady.
+ * To begin an asynchronous operation, provide a SlotAsyncReady to the asynchronous function. This callback will be triggered
+ * when the operation has completed, and will be passed an AsyncResult instance filled with the details of the operation's success or
+ * failure, the object the asynchronous function was started for and any error codes returned. The asynchronous callback function is then
* expected to call the corresponding "_finish()" function with the object the function was called for, and the AsyncResult instance.
*
- * The purpose of the "_finish()" function is to take the generic result of type AsyncResult and return the specific result that the operation
- * in question yields (e.g. a FileEnumerator for an "enumerate children" operation). If the result or error status of the operation is not needed,
- * there is no need to call the "_finish()" function and GIO will take care of cleaning up the result and error information after the
+ * The purpose of the "_finish()" function is to take the generic result of type AsyncResult and return the specific result that the operation
+ * in question yields (e.g. a FileEnumerator for an "enumerate children" operation). If the result or error status of the operation is not needed,
+ * there is no need to call the "_finish()" function and GIO will take care of cleaning up the result and error information after the
* SlotAsyncReady returns. You may also store the AsyncResult and call "_finish()" later.
*
* Example of a typical asynchronous operation flow:
* @code
- * void _theoretical_frobnitz_async(const Glib::RefPtr<Theoretical>& t,
+ * void _theoretical_frobnitz_async(const Glib::RefPtr<Theoretical>& t,
* const SlotAsyncReady& slot);
- *
+ *
* gboolean _theoretical_frobnitz_finish(const Glib::RefPtr<Theoretical>& t,
* const Glib::RefPtr<AsyncResult>& result);
- *
- * static void
+ *
+ * static void
* on_frobnitz_result(Glib::RefPtr<AsyncResult>& result)
* {
- *
+ *
* Glib::RefPtr<Glib::Object> source_object = result->get_source_object();
* bool success = _theoretical_frobnitz_finish(source_object, res);
- *
+ *
* if (success)
* std::cout << "Hurray" << std::endl;
- * else
+ * else
* std::cout << "Uh oh!" << std::endl;
- *
+ *
* ...
* }
- *
+ *
* int main (int argc, void *argv[])
* {
* ...
- *
- * _theoretical_frobnitz_async (theoretical_data,
+ *
+ * _theoretical_frobnitz_async (theoretical_data,
* sigc::ptr_fun(&on_frobnitz_result) );
- *
+ *
* ...
* }
* @endcode
*
* The async function could also take an optional Glib::Cancellable object, allowing the calling function to cancel the asynchronous operation.
*
- * The callback for an asynchronous operation is called only once, and is always called, even in the case of a cancelled operation.
+ * The callback for an asynchronous operation is called only once, and is always called, even in the case of a cancelled operation.
* On cancellation the result is a ERROR_CANCELLED error.
*
- * Some ascynchronous operations are implemented using synchronous calls. These are run in a separate GThread, but otherwise they are sent
+ * Some ascynchronous operations are implemented using synchronous calls. These are run in a separate GThread, but otherwise they are sent
* to the Main Event Loop and processed in an idle function. So, if you truly need asynchronous operations, make sure to initialize GThread.
*
* @newin{2,16}
{
/** @defgroup Streams Stream Classes
- *
+ *
*/
/** The buffered input stream implements FilterInputStream and provides for buffered reads.
- * By default, BufferedInputStream's buffer size is set at 4 kilobytes, but you can specify
+ * By default, BufferedInputStream's buffer size is set at 4 kilobytes, but you can specify
* this to the constructor.
- *
- * To get the size of a buffer within a buffered input stream, use get_buffer_size().
- * To change the size of a buffered input stream's buffer, use set_buffer_size().
+ *
+ * To get the size of a buffer within a buffered input stream, use get_buffer_size().
+ * To change the size of a buffered input stream's buffer, use set_buffer_size().
* Note that the buffer's size cannot be reduced below the size of the data within the buffer.
*
* @ingroup Streams
_CLASS_GOBJECT(BufferedInputStream, GBufferedInputStream, G_BUFFERED_INPUT_STREAM, Gio::FilterInputStream, GFilterInputStream)
protected:
_WRAP_CTOR(BufferedInputStream(const Glib::RefPtr<InputStream>& base_stream), g_buffered_input_stream_new)
-
+
//Note that we rename the size parameter to buffer_size because that is the actual name of the property.
_WRAP_CTOR(BufferedInputStream(const Glib::RefPtr<InputStream>& base_stream, gsize buffer_size), g_buffered_input_stream_new_sized)
public:
- /** Creates a new InputStream from the given base_stream, with a buffer set to the default size (4 kilobytes).
+ /** Creates a new InputStream from the given base_stream, with a buffer set to the default size (4 kilobytes).
*
* @param base_stream An InputStream.
* @result an InputStream for the given base_stream.
*/
_WRAP_CREATE(const Glib::RefPtr<InputStream>& base_stream)
-
+
/** Creates a new InputStream from the given base_stream, with a buffer set to size.
*
* @param base_stream An InputStream.
- * @param size A size.
+ * @param buffer_size A size.
* @result an InputStream for the given base_stream.
*/
static Glib::RefPtr<BufferedInputStream> create_sized(const Glib::RefPtr<InputStream>& base_stream, gsize buffer_size);
{
/** The buffered output stream implements FilterOutputStream and provides for buffered writes.
- * By default, BufferedOutputStream's buffer size is set at 4 kilobytes, but you
+ * By default, BufferedOutputStream's buffer size is set at 4 kilobytes, but you
* can specify this to the constructor.
*
- * To get the size of a buffer within a buffered input stream, use get_buffer_size().
- * To change the size of a buffered output stream's buffer, use set_buffer_size().
+ * To get the size of a buffer within a buffered input stream, use get_buffer_size().
+ * To change the size of a buffered output stream's buffer, use set_buffer_size().
* Note that the buffer's size cannot be reduced below the size of the data within the buffer.
*
* @ingroup Streams
_CLASS_GOBJECT(BufferedOutputStream, GBufferedOutputStream, G_BUFFERED_OUTPUT_STREAM, Gio::FilterOutputStream, GFilterOutputStream)
protected:
_WRAP_CTOR(BufferedOutputStream(const Glib::RefPtr<OutputStream>& base_stream), g_buffered_output_stream_new)
-
+
//Note that we rename the size parameter to buffer_size because that is the actual name of the property.
_WRAP_CTOR(BufferedOutputStream(const Glib::RefPtr<OutputStream>& base_stream, gsize buffer_size), g_buffered_output_stream_new_sized)
* @result an OutputStream for the given base stream.
*/
_WRAP_CREATE(const Glib::RefPtr<OutputStream>& base_stream)
-
- /** Creates a new buffered output stream with a given buffer size.
+
+ /** Creates a new buffered output stream with a given buffer size.
*
* @param base_stream An InputStream.
- * @param size A size.
- * @result an OutputStream with an internal buffer set to size.
+ * @param buffer_size A size.
+ * @result an OutputStream with an internal buffer set to size.
*/
static Glib::RefPtr<BufferedOutputStream> create_sized(const Glib::RefPtr<OutputStream>& base_stream, gsize buffer_size);
} // extern "C"
gulong
-Cancellable::connect(const SlotCancelledCallback& callback)
+Cancellable::connect(const SlotCancelledCallback& slot)
{
- SlotCancelledCallback* slot_copy = new SlotCancelledCallback(callback);
+ SlotCancelledCallback* slot_copy = new SlotCancelledCallback(slot);
return g_cancellable_connect (gobj(),
G_CALLBACK(slot_cancelled_proxy),
slot_copy,
// TODO: is this useful in the C++ API?
//_WRAP_METHOD(void make_pollfd(PollFD* pollfd), g_cancellable_make_pollfd)
- _WRAP_METHOD_DOCS_ONLY(g_cancellable_connect)
- gulong connect(const SlotCancelledCallback& callback);
+ /** Convenience function to connect to the Cancellable::signal_cancelled()
+ * signal. Also handles the race condition that may happen
+ * if the cancellable is cancelled right before connecting.
+ *
+ * @a slot is called at most once, either directly at the
+ * time of the connect if @a cancellable is already cancelled,
+ * or when @a cancellable is cancelled in some thread.
+ *
+ * See Cancellable::signal_cancelled() for details on how to use this.
+ *
+ * @newin{2,22}
+ * @param slot The slot to connect.
+ * @return The id of the signal handler or 0 if @a cancellable has already
+ * been cancelled.
+ */
+ gulong connect(const SlotCancelledCallback& slot);
_IGNORE(g_cancellable_connect)
+
_WRAP_METHOD(void disconnect(gulong handler_id), g_cancellable_disconnect)
_WRAP_SIGNAL(void cancelled(), cancelled)
_IGNORE(g_charset_converter_new)
public:
- _WRAP_METHOD_DOCS_ONLY(g_charset_converter_new)
+ /** Creates a new CharsetConverter.
+ *
+ * @newin{2,24}
+ * @param to_charset Destination charset.
+ * @param from_charset Source charset.
+ * @return A new CharsetConverter, or <tt>0</tt> on error.
+ */
_WRAP_CREATE(const Glib::ustring& to_charset, const Glib::ustring& from_charset)
_WRAP_METHOD(void set_use_fallback(bool use_fallback), g_charset_converter_set_use_fallback)
* ways. The conversion can be stateful and may fail at any place.
*
* Some example conversions are: character set conversion, compression,
- * decompression and regular expression replace.
+ * decompression and regular expression replace.
*
* @newin{2,34}
*/
class ConverterInputStream : public FilterInputStream,
public PollableInputStream
{
- _CLASS_GOBJECT(ConverterInputStream, GConverterInputStream, G_CONVERTER_INPUT_STREAM, FilterInputStream, GFilterInputStream)
+ _CLASS_GOBJECT(ConverterInputStream, GConverterInputStream, G_CONVERTER_INPUT_STREAM, FilterInputStream, GFilterInputStream)
_IMPLEMENTS_INTERFACE(PollableInputStream)
protected:
class ConverterOutputStream : public FilterOutputStream,
public PollableOutputStream
{
- _CLASS_GOBJECT(ConverterOutputStream, GConverterOutputStream, G_CONVERTER_OUTPUT_STREAM, FilterOutputStream, GFilterOutputStream)
+ _CLASS_GOBJECT(ConverterOutputStream, GConverterOutputStream, G_CONVERTER_OUTPUT_STREAM, FilterOutputStream, GFilterOutputStream)
_IMPLEMENTS_INTERFACE(PollableOutputStream)
protected:
* another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * @param data A string to fill with the read data (without the newlines).
+ * @param line A string to fill with the read data (without the newlines).
* @param cancellable A cancellable object.
* @result true if the read succeeded without error.
*/
/** A non-cancellable version of read_line().
*
- * @param data A string to fill with the read data (without the newlines).
+ * @param line A string to fill with the read data (without the newlines).
* @result true if the read succeeded without error.
*/
bool read_line(std::string& line);
* read_upto() instead, but note that that method
* does not consume the stop character.
*
- * @param stop_chars Characters to terminate the read.
* @param data A string to fill with the read data.
+ * @param stop_chars Characters to terminate the read.
* @result true if the read succeeded without error.
*/
bool read_until(std::string& data, const std::string& stop_chars);
* occurrence of any of the stop characters.
*
* In contrast to read_until(), this method
- * does <emphasis>not</emphasis> consume the stop character. You have
+ * does <em>not</em> consume the stop character. You have
* to use read_byte() to get it before calling
* read_upto() again.
*
_IGNORE(g_data_input_stream_read_upto)
/** A non-cancellable version of read_upto().
- * @param stop_chars Characters to terminate the read.
* @param data A string to fill with the read data.
+ * @param stop_chars Characters to terminate the read.
* @result true if the read succeeded without error.
*/
bool read_upto(std::string& data, const std::string& stop_chars);
* an error to have two outstanding calls to this function.
*
* In contrast to read_until(), this method
- * does <emphasis>not</emphasis> consume the stop character. You have
+ * does <em>not</em> consume the stop character. You have
* to use read_byte() to get it before calling
* read_upto() again.
*
/** Finish an asynchronous call started by read_upto_async().
*
- * Note that this function does <emphasis>not</emphasis> consume the
+ * Note that this function does <em>not</em> consume the
* stop character. You have to use read_byte() to
* get it before calling read_upto_async() again.
*
* in @a address and that key/value pairs for each transport are valid.
*
* @param address A supposed address.
- * @return <tt>true</t> if @a address is a valid D-Bus address that is
+ * @return <tt>true</tt> if @a address is a valid D-Bus address that is
* supported by this library, <tt>false</tt> otherwise.
* @throw Glib::Error.
* @newin{2,28}
* asynchronous version.
*
* @param address A valid D-Bus address.
+ * @param cancellable A Cancellable.
* @param out_guid A return location to store the GUID extracted from address,
* if any.
- * @param cancellable A Cancellable.
- * @param Returns A IOStream.
+ * @return A IOStream.
* @throw Glib::Error.
* @newin{2,28}
* @ingroup DBus
*
* @param address A valid D-Bus address.
* @param cancellable A Cancellable.
- * @param Returns A IOStream.
+ * @return A IOStream.
* @throw Glib::Error.
* @newin{2,28}
* @ingroup DBus
return Glib::VariantContainerBase(gvariant, false); //Dont' take an extra reference.
}
-#ifdef G_OS_LINUX
+#ifdef G_OS_UNIX
// With a UnixFDList.
void Connection::call(
const Glib::ustring& object_path,
static_cast<GDBusCallFlags>(flags), timeout_msec, Glib::unwrap(fd_list),
0, &SignalProxy_async_callback, slot_copy);
}
-#endif // G_OS_LINUX
+#endif // G_OS_UNIX
void Connection::emit_signal(
const Glib::ustring& object_path,
/** @defgroup DBus D-Bus API
*
* API to use D-Bus services as a client or to implement a D-Bus service.
- * To write client code, see Gio::DBus::Proxy.
+ * To write client code, see Gio::DBus::Proxy.
* To export objects on the bus for other clients, see Gio::DBus::own_name(), for instance.
*/
void close(const SlotAsyncReady& slot);
_IGNORE(g_dbus_connection_close)
- _WRAP_METHOD(bool close_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(bool close_finish(const Glib::RefPtr<AsyncResult>& res),
g_dbus_connection_close_finish, errthrow)
_WRAP_METHOD(void close_sync(const Glib::RefPtr<Cancellable>& cancellable{?}), g_dbus_connection_close_sync, errthrow)
void flush(const SlotAsyncReady& slot);
_IGNORE(g_dbus_connection_flush)
- _WRAP_METHOD(bool flush_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(bool flush_finish(const Glib::RefPtr<AsyncResult>& res),
g_dbus_connection_flush_finish, errthrow)
_WRAP_METHOD(void flush_sync(const Glib::RefPtr<Cancellable>& cancellable{?}), g_dbus_connection_flush_sync, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_connection_send_message_with_reply_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(Glib::RefPtr<Message> send_message_with_reply_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_connection_send_message_with_reply_finish, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<Message> send_message_with_reply_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_send_message_with_reply_finish, errthrow)
/** Synchronously sends @a message to the peer represented by the connection
* and blocks the calling thread until a reply is received or the timeout is
CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType());
-#ifdef G_OS_LINUX
+#ifdef G_OS_UNIX
/** Like call() but also takes a GUnixFDList object.
* This method is only available on UNIX.
*
int timeout_msec = -1,
CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type = Glib::VariantType());
-#endif // G_OS_LINUX
/** Finishes an operation started with call() (with a UnixFDList).
* @param res A AsyncResult obtained from the SlotAsyncReady passed to
* @throw Glib::Error.
* @newin{2,34}
*/
- _WRAP_METHOD(Glib::VariantContainerBase call_finish(const Glib::RefPtr<AsyncResult>& res{.}, Glib::RefPtr<UnixFDList>& out_fd_list{.>>}), g_dbus_connection_call_with_unix_fd_list_finish, errthrow)
+ _WRAP_METHOD(Glib::VariantContainerBase call_finish(const Glib::RefPtr<AsyncResult>& res{.}, Glib::RefPtr<UnixFDList>& out_fd_list{.>>}), g_dbus_connection_call_with_unix_fd_list_finish, errthrow, ifdef G_OS_UNIX)
+#endif // G_OS_UNIX
_WRAP_METHOD(
Glib::VariantContainerBase call_sync(
CallFlags flags{.} = Gio::DBus::CALL_FLAGS_NONE,
const Glib::VariantType& reply_type{.} = Glib::VariantType()
),
- g_dbus_connection_call_with_unix_fd_list_sync, errthrow
+ g_dbus_connection_call_with_unix_fd_list_sync, errthrow, ifdef G_OS_UNIX
)
/** Emits a signal.
const Glib::RefPtr<InterfaceInfo>& interface_info,
const InterfaceVTable& vtable);
_IGNORE(g_dbus_connection_register_object)
-
+
/** Registers exported objects at @a object_path with the D-Bus
- * interface that is described in @a interface_info. This method overload,
- * which does not take a VTable, is useful for
- * <a href=="http://en.wikipedia.org/wiki/Marker_interface_pattern">marker
- * interfaces</href>.
+ * interface that is described in @a interface_info. This method overload,
+ * which does not take a VTable, is useful for
+ * <a href="http://en.wikipedia.org/wiki/Marker_interface_pattern">marker
+ * interfaces</a>.
*
* If an existing slot is already registered at @a object_path and @a
* interface_name, then a Glib::Error is thrown.
/** Checks if @a error represents an error received via D-Bus from a remote
* peer. If so, use get_remote_error() to get the name of the error.
*
- * @param error A Glib::Error.
+ * @param error A Glib::Error.
* @return <tt>true</tt> if error represents an error from a remote peer,
- * <tt>false</tt> otherwise.
+ * <tt>false</tt> otherwise.
* @newin{2,28}
* @ingroup DBus
*/
*
* This is typically used when presenting errors to the end user.
*
- * @param error A Glib::Error.
+ * @param error A Glib::Error.
* @return <tt>true</tt> if information was stripped, <tt>false</tt>
- * otherwise.
+ * otherwise.
* @newin{2,28}
* @ingroup DBus
*/
namespace DBus
{
-//We hand-code this because g_dbus_node_info_lookup_interface() doesn't
+//We hand-code this because g_dbus_node_info_lookup_interface() doesn't
//do this when it takes a NULL.
//See bug https://bugzilla.gnome.org/show_bug.cgi?id=646417
Glib::RefPtr<InterfaceInfo> NodeInfo::lookup_interface()
{
Glib::RefPtr<InterfaceInfo> retvalue;
-
+
if(!gobj() || !(gobj()->interfaces))
return retvalue;
retvalue = Glib::wrap(gobj()->interfaces[0]);
-
+
if(retvalue)
retvalue->reference(); //The function does not do a ref for us.
{
return const_cast<NodeInfo*>(this)->lookup_interface();
}
-
+
} //namespace DBus
-
+
} // namespace Gio
_WRAP_METHOD(Glib::RefPtr<InterfaceInfo> lookup_interface(const Glib::ustring& name), g_dbus_node_info_lookup_interface, refreturn)
_WRAP_METHOD(Glib::RefPtr<const InterfaceInfo> lookup_interface(const Glib::ustring& name) const, g_dbus_node_info_lookup_interface, constversion, refreturn)
-
+
/** Looks up information about the first interface.
*/
Glib::RefPtr<InterfaceInfo> lookup_interface();
/** Looks up information about the first interface.
*/
Glib::RefPtr<const InterfaceInfo> lookup_interface() const;
-
+
//TODO: _WRAP_METHOD(void generate_xml(guint indent, GString* string_builder), g_dbus_node_info_generate_xml)
};
// See here about whether the parameters should be ustring or std::string:
// http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names
- // They are generally UTF-8 that can only contain the ASCII subset,
+ // They are generally UTF-8 that can only contain the ASCII subset,
// so ustring still seems preferrable to std::string, which generally implies an unknown endoding for us.
_WRAP_METHOD(static Glib::RefPtr<Message> create_signal(const Glib::ustring& path, const Glib::ustring& interface, const Glib::ustring& signal), g_dbus_message_new_signal)
return Glib::VariantContainerBase(gvariant, false); //Dont' take an extra reference.
}
-#ifdef G_OS_LINUX
+#ifdef G_OS_UNIX
// With a UnixFDList.
-void Connection::call(
+void Proxy::call(
const Glib::ustring& method_name,
const Glib::VariantContainerBase& parameters,
const SlotAsyncReady& slot,
}
// Non-cancellable version (with a UnixFDList).
-void Connection::call(
+void Proxy::call(
const Glib::ustring& method_name,
const Glib::VariantContainerBase& parameters,
const SlotAsyncReady& slot,
const Glib::RefPtr<UnixFDList>& fd_list,
int timeout_msec,
- CallFlags flags,
- const Glib::VariantType& reply_type)
+ CallFlags flags)
{
// Create a copy of the slot.
// A pointer to it will be passed through the callback's data parameter
static_cast<GDBusCallFlags>(flags), timeout_msec, Glib::unwrap(fd_list),
0, &SignalProxy_async_callback, slot_copy);
}
-#endif // G_OS_LINUX
+#endif // G_OS_UNIX
} //namespace DBus
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<Proxy> create_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Proxy> create_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_proxy_new_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_sync)
static Glib::RefPtr<Proxy>
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus_finish)
/// @throw Glib::Error.
- _WRAP_METHOD(static Glib::RefPtr<Proxy> create_for_bus_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_proxy_new_for_bus_finish, errthrow)
+ _WRAP_METHOD(static Glib::RefPtr<Proxy> create_for_bus_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_proxy_new_for_bus_finish, errthrow)
_WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus_sync)
static Glib::RefPtr<Proxy>
);
-#ifdef G_OS_LINUX
+#ifdef G_OS_UNIX
//TODO: Use _WRAP_METHOD() for this?
/** Like call() but also takes a GUnixFDList object.
* This method is only available on UNIX.
* @newin{2,34}
*/
void call(
- const Glib::ustring& object_path,
- const Glib::ustring& interface_name,
const Glib::ustring& method_name,
const Glib::VariantContainerBase& parameters,
const SlotAsyncReady& slot,
const Glib::RefPtr<UnixFDList>& fd_list,
- const Glib::ustring& bus_name = Glib::ustring(),
int timeout_msec = -1,
- CallFlags flags = Gio::DBus::CALL_FLAGS_NONE,
- const Glib::VariantType& reply_type = Glib::VariantType());
-#endif // G_OS_LINUX
+ CallFlags flags = Gio::DBus::CALL_FLAGS_NONE);
/** Finishes an operation started with call() (with a UnixFDList).
* @param res A AsyncResult obtained from the SlotAsyncReady passed to
* @throw Glib::Error.
* @newin{2,34}
*/
- _WRAP_METHOD(Glib::VariantContainerBase call_finish(const Glib::RefPtr<AsyncResult>& res{.}, Glib::RefPtr<UnixFDList>& out_fd_list{.>>}), g_dbus_proxy_call_with_unix_fd_list_finish, errthrow)
+ _WRAP_METHOD(Glib::VariantContainerBase call_finish(const Glib::RefPtr<AsyncResult>& res{.}, Glib::RefPtr<UnixFDList>& out_fd_list{.>>}), g_dbus_proxy_call_with_unix_fd_list_finish, errthrow, ifdef G_OS_UNIX)
+#endif // G_OS_UNIX
_WRAP_METHOD(
Glib::VariantContainerBase call_sync(
int timeout_msec{.} = -1,
CallFlags flags{.} = Gio::DBus::CALL_FLAGS_NONE
),
- g_dbus_proxy_call_with_unix_fd_list_sync, errthrow
+ g_dbus_proxy_call_with_unix_fd_list_sync, errthrow, ifdef G_OS_UNIX
)
//_WRAP_PROPERTY("g-bus-type", BusType) // write-only construct-only
* application should create object proxies in @a name_appeared_slot and
* destroy them again (if any) in @a name_vanished_slot.
*
- * @param bus_type The type of bus to watch a name on.
- * @param name The name (well-known or unique) to watch.
- * @param name_appeared_slot Slot to invoke when name is known to exist.
- * @param name_vanished_slot Slot to invoke when name is known to not
+ * @param bus_type The type of bus to watch a name on.
+ * @param name The name (well-known or unique) to watch.
+ * @param name_appeared_slot Slot to invoke when name is known to exist.
+ * @param name_vanished_slot Slot to invoke when name is known to not
* exist.
- * @param flags Flags from the BusNameWatcherFlags enumeration.
- * @return An identifier (never 0) that can be used with unwatch_name() to
+ * @param flags Flags from the BusNameWatcherFlags enumeration.
+ * @return An identifier (never 0) that can be used with unwatch_name() to
* stop watching the name.
*
* @newin{2,28}
/** A watch_name() function that takes a Connection instead of a BusType.
*
- * @param connection A Connection.
- * @param name The name (well-known or unique) to watch.
- * @param name_appeared_slot Slot to invoke when name is known to exist.
- * @param name_vanished_slot Slot to invoke when name is known to not
+ * @param connection A Connection.
+ * @param name The name (well-known or unique) to watch.
+ * @param name_appeared_slot Slot to invoke when name is known to exist.
+ * @param name_vanished_slot Slot to invoke when name is known to not
* exist.
- * @param flags Flags from the BusNameWatcherFlags enumeration.
- * @return An identifier (never 0) that can be used with unwatch_name() to
+ * @param flags Flags from the BusNameWatcherFlags enumeration.
+ * @return An identifier (never 0) that can be used with unwatch_name() to
* stop watching the name.
*
* @newin{2,28}
_WRAP_METHOD(std::string get_filename() const, g_desktop_app_info_get_filename)
_WRAP_METHOD(bool is_hidden() const, g_desktop_app_info_get_is_hidden)
_WRAP_METHOD(static void set_desktop_env(const std::string& desktop_env), g_desktop_app_info_set_desktop_env)
+
+#m4 _CONVERSION(`const char* const*', `std::vector<Glib::ustring>', `Glib::ArrayHandler<Glib::ustring>::array_to_vector($3, Glib::OWNERSHIP_NONE)')
+ _WRAP_METHOD(std::vector<Glib::ustring> get_keywords() const, g_desktop_app_info_get_keywords)
+
+ _WRAP_METHOD(std::string get_startup_wm_class() const, g_desktop_app_info_get_startup_wm_class)
+ _WRAP_METHOD(bool get_nodisplay() const, g_desktop_app_info_get_nodisplay)
+ _WRAP_METHOD(bool get_show_in(const std::string& desktop_env) const, g_desktop_app_info_get_show_in)
+ _WRAP_METHOD(std::string get_generic_name() const, g_desktop_app_info_get_generic_name)
+ _WRAP_METHOD(std::string get_categories() const, g_desktop_app_info_get_categories)
};
} // namespace Gio
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
g_drive_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0, // mount_operation
0, // cancellable
&SignalProxy_async_callback,
void Drive::eject(const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags)
{
g_drive_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
Glib::unwrap(mount_operation),
0, // cancellable
0, // callback
void Drive::eject(MountUnmountFlags flags)
{
g_drive_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0, // mount_operation
0, // cancellable
0, // callback
/** Virtual File System drive management.
*
* This represent a piece of hardware connected to the machine. It's generally only created for removable hardware or hardware with removable media.
- * Gio::Drive is a container class for Gio::Volume objects that stem from the same piece of media. As such, Gio::Drive abstracts a drive with
- * (or without) removable media and provides operations for querying whether media is available, determing whether media change is automatically
+ * Gio::Drive is a container class for Gio::Volume objects that stem from the same piece of media. As such, Gio::Drive abstracts a drive with
+ * (or without) removable media and provides operations for querying whether media is available, determing whether media change is automatically
* detected and ejecting the media.
*
- * If the Gio::Drive reports that media isn't automatically detected, one can poll for media; typically one should not do this periodically as a
+ * If the Gio::Drive reports that media isn't automatically detected, one can poll for media; typically one should not do this periodically as a
* poll for media operation is potententially expensive and may spin up the drive, creating noise.
*
* @newin{2,16}
void eject(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
/** Ejects the drive.
- * @param slot A callback which will be called when the eject is completed.
* @param flags Flags affecting the unmount if required for eject.
*/
void eject(MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
errthrow)
_WRAP_METHOD(std::string get_identifier(const std::string& kind) const, g_drive_get_identifier)
-
+
#m4 _CONVERSION(`char**',`Glib::StringArrayHandle',`Glib::StringArrayHandle($3, Glib::OWNERSHIP_DEEP)')
_WRAP_METHOD(Glib::StringArrayHandle enumerate_identifiers() const, g_drive_enumerate_identifiers)
namespace Container_Helpers
{
-/** This specialization of TypeTraits exists
- * because the default use of Glib::wrap(GObject*),
+/** This specialization of TypeTraits exists
+ * because the default use of Glib::wrap(GObject*),
* instead of a specific Glib::wrap(GSomeInterface*),
* would not return a wrapper for an interface.
- */
+ */
template <>
struct TypeTraits< Glib::RefPtr<Gio::Drive> >
{
static CppType to_cpp_type (const CType& item)
{
- //Use a specific Glib::wrap() function,
+ //Use a specific Glib::wrap() function,
//because CType has the specific type (not just GObject):
return Glib::wrap(item, true /* take_copy */);
}
protected:
//We have this constructor because g_emblemed_icon_new() may take a NULL emblem parameter.
- /** Creates a new emblemed icon for @a icon with the emblem @a emblem.
+ /** Creates a new emblemed icon for @a icon with no emblem.
* @param icon An Icon.
- * @param emblem An Emblem.
*
* @newin{2,28}
*/
_WRAP_ENUM(DataStreamNewlineType, GDataStreamNewlineType, NO_GTYPE)
_WRAP_ENUM(ErrorEnum, GIOErrorEnum, NO_GTYPE)
_WRAP_ENUM(SocketFamily, GSocketFamily)
+_WRAP_ENUM(TlsAuthenticationMode, GTlsAuthenticationMode)
+_WRAP_ENUM(TlsCertificateFlags, GTlsCertificateFlags)
} // namespace Gio
File::unmount_mountable(MountUnmountFlags flags)
{
g_file_unmount_mountable_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0,
0,
0,
File::unmount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags)
{
g_file_unmount_mountable_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
Glib::unwrap(mount_operation),
0,
0,
/** File and directory handling.
- * Gio::File is a high level abstraction for manipulating files on a virtual file system. Gio::Files are lightweight, immutable objects that do no
- * I/O upon creation. It is necessary to understand that a Gio::File object does not represent a file, merely a handle to a file. All file I/O is
+ * Gio::File is a high level abstraction for manipulating files on a virtual file system. Gio::Files are lightweight, immutable objects that do no
+ * I/O upon creation. It is necessary to understand that a Gio::File object does not represent a file, merely a handle to a file. All file I/O is
* implemented as streaming operations (see Gio::InputStream and Gio::OutputStream).
*
* A GioFile can be constructed from a path, URI, or a command line argument.
*
- * You can move through the filesystem with Gio::File handles with get_parent() to get a handle to the parent directory,
+ * You can move through the filesystem with Gio::File handles with get_parent() to get a handle to the parent directory,
* get_child() to get a handle to a child within a directory, and resolve_relative_path() to resolve a relative path between two Gio::Files.
*
- * Many Gio::File operations have both synchronous and asynchronous versions to suit your application. Asynchronous versions of synchronous
- * functions simply have _async() appended to their function names. The asynchronous I/O functions call a SlotAsyncReady callback slot which is
+ * Many Gio::File operations have both synchronous and asynchronous versions to suit your application. Asynchronous versions of synchronous
+ * functions simply have _async() appended to their function names. The asynchronous I/O functions call a SlotAsyncReady callback slot which is
* then used to finalize the operation, producing a AsyncResult which is then passed to the function's matching _finish() operation.
*
- * Some Gio::File operations do not have synchronous analogs, as they may take a very long time to finish, and blocking may leave an application
- * unusable. Notable cases include: mount_mountable() to mount a mountable file, unmount_mountable() to unmount a mountable file,
+ * Some Gio::File operations do not have synchronous analogs, as they may take a very long time to finish, and blocking may leave an application
+ * unusable. Notable cases include: mount_mountable() to mount a mountable file, unmount_mountable() to unmount a mountable file,
* and eject_mountable() to eject a mountable file.
- *
- * One notable feature of Gio::Files are entity tags, or "etags" for short. Entity tags are somewhat like a more abstract version of the
- * traditional mtime, and can be used to quickly determine if the file has been modified from the version on the file system.
+ *
+ * One notable feature of Gio::Files are entity tags, or "etags" for short. Entity tags are somewhat like a more abstract version of the
+ * traditional mtime, and can be used to quickly determine if the file has been modified from the version on the file system.
* See the HTTP 1.1 specification for HTTP Etag headers, which are a very similar concept.
*
* @newin{2,16}
- */
+ */
class File : public Glib::Interface
{
_CLASS_INTERFACE(File, GFile, G_FILE, GFileIface)
public:
-
-
-
_IGNORE(g_file_icon_new) //g_file_icon_new is not a GFile method.
// Although this is an interface, it is possible to create objects using
static Glib::RefPtr<File> create_for_uri(const std::string& uri);
_IGNORE(g_file_new_for_uri)
- /** Constructs a File for a given argument from the command line.
- * The value of @a arg can be either a URI, an absolute path or a relative path resolved relative to the current working directory.
+ /** Constructs a File for a given argument from the command line.
+ * The value of @a arg can be either a URI, an absolute path or a relative path resolved relative to the current working directory.
* This operation never fails, but the returned object might not support any I/O operation if arg points to a malformed path.
*
* @param arg A string containing a relative or absolute path.
// (g_hash_table_new in C).
_WRAP_METHOD(guint hash() const, g_file_hash)
- //Not that the implementation of equal() is already virtual via equal_vfunc().
+ //Note that the implementation of equal() is already virtual via equal_vfunc().
+ /** Checks equality of two given Files.
+ *
+ * Note that two Files that differ can still refer to the same
+ * file on the filesystem due to various forms of filename
+ * aliasing.
+ *
+ * This call does no blocking I/O.
+ * @param other The other File.
+ * @return <tt>true</tt> if @a *this and @a other are equal.
+ * <tt>false</tt> if either is not a File.
+ */
_WRAP_METHOD(bool equal(const Glib::RefPtr<const File>& other) const, g_file_equal)
_WRAP_METHOD(std::string get_basename() const, g_file_get_basename)
_WRAP_METHOD(std::string get_uri() const, g_file_get_uri)
_WRAP_METHOD(Glib::ustring get_parse_name() const, g_file_get_parse_name)
- //Note that these return a reference (usually new instances,
+ //Note that these return a reference (usually new instances),
//so we don't need to use refreturn.
//TODO: Do we need const and unconst versions of these get_*() methods,
/** Checks if the file has any parent at all.
* @result true if the file is a child of any parent.
*
- * @newin2p24
+ * @newin{2,24}
*/
bool has_parent() const;
//TODO: We don't have both const and unconst versions because a FileInputStream can't really change the File.
_WRAP_METHOD(Glib::RefPtr<FileInputStream> read(const Glib::RefPtr<Cancellable>& cancellable{?}),
g_file_read,
- refreturn, errthrow)
+ errthrow)
/** Asynchronously opens the file for reading.
* For more details, see read() which is the synchronous version of this call.
_WRAP_METHOD(Glib::RefPtr<FileInputStream> read_finish(const Glib::RefPtr<AsyncResult>& result),
g_file_read_finish,
- refreturn, errthrow)
+ errthrow)
/** Gets an output stream for appending data to the file. If
* the file doesn't already exist it is created.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
* Some filesystems don't allow all filenames, and may
* throw a Gio::Error with INVALID_FILENAME.
* If the file is a directory a Gio::Error with IS_DIRECTORY will be
/** Gets an output stream for appending data to the file. If
* the file doesn't already exist it is created.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
+ *
* Some filesystems don't allow all filenames, and may
* throw a Gio::Error with INVALID_FILENAME.
- * If the file is a directory a Gio::Error with IS_DIRECTORY will be
+ * If the file is a directory a Gio::Error with IS_DIRECTORY will be
* thrown. Other errors are possible too, and depend on what kind of
* filesystem the file is on.
* @param flags A set of FileCreateFlags.
Glib::RefPtr<FileOutputStream> append_to(FileCreateFlags flags = FILE_CREATE_NONE);
_IGNORE(g_file_append_to)
- //We renamed this to create_file from (g_file_create() and g_file_create_readwrite), to avoid confusion with static create() methods,
+ //We renamed this to create_file from (g_file_create() and g_file_create_readwrite), to avoid confusion with static create() methods,
//but I would still like to choose a different word, but can't think of a good one. murrayc.
/** Creates a new file and returns an output stream for writing to it.
* The file must not already exist.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
- * If a file with this name already exists a Gio::Error with EXISTS
+ *
+ * If a file with this name already exists a Gio::Error with EXISTS
* will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
* will be thrown.
*
/** Creates a new file and returns an output stream for writing to it.
* The file must not already exist.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
- * If a file with this name already exists a Gio::Error with EXISTS
+ *
+ * If a file with this name already exists a Gio::Error with EXISTS
* will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
* will be thrown.
*
/** Creates a new file and returns a stream for reading and writing to it.
* The file must not already exist.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
- * If a file with this name already exists a Gio::Error with EXISTS
+ *
+ * If a file with this name already exists a Gio::Error with EXISTS
* will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
* will be thrown.
*
/** Creates a new file and returns a stream for reading and writing to it.
* The file must not already exist.
- *
+ *
* By default files created are generally readable by everyone,
* but if you pass FILE_CREATE_PRIVATE in @a flags the file
* will be made readable only to the current user, to the level that
* is supported on the target filesystem.
- *
- * If a file with this name already exists a Gio::Error with EXISTS
+ *
+ * If a file with this name already exists a Gio::Error with EXISTS
* will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
* will be thrown.
*
/** Returns an output stream for overwriting the file, possibly creating a backup copy of the file first.
- * This will try to replace the file in the safest way possible so that any errors during the writing will
- * not affect an already existing copy of the file. For instance, for local files it may write to a
+ * This will try to replace the file in the safest way possible so that any errors during the writing will
+ * not affect an already existing copy of the file. For instance, for local files it may write to a
* temporary file and then atomically rename over the destination when the stream is closed.
*
- * By default files created are generally readable by everyone, but if you pass FILE_CREATE_PRIVATE in
- * @a flags the file will be made readable only to the current user, to the level that is supported on the
+ * By default files created are generally readable by everyone, but if you pass FILE_CREATE_PRIVATE in
+ * @a flags the file will be made readable only to the current user, to the level that is supported on the
* target filesystem.
*
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * If you pass in an etag value, then this value is compared to the current entity tag of the file,
- * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
- * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
- * after you've finished writing and closed the FileOutputStream. When you load a new file you can
+ * If you pass in an etag value, then this value is compared to the current entity tag of the file,
+ * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
+ * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
+ * after you've finished writing and closed the FileOutputStream. When you load a new file you can
* use FileInputStream::query_info() to get the etag of the file.
*
- * If @a make_backup is true, this function will attempt to make a backup of the current file before
- * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
+ * If @a make_backup is true, this function will attempt to make a backup of the current file before
+ * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
* anyway, try again with @a make_backup set to false.
*
- * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
- * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
- * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
- * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
+ * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
+ * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
+ * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
+ * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
* depend on what kind of filesystem the file is on.
- *
+ *
* @param etag An optional entity tag for the current Glib::File.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
/** Returns an output stream for overwriting the file, possibly creating a backup copy of the file first.
- * This will try to replace the file in the safest way possible so that any errors during the writing will
- * not affect an already existing copy of the file. For instance, for local files it may write to a
+ * This will try to replace the file in the safest way possible so that any errors during the writing will
+ * not affect an already existing copy of the file. For instance, for local files it may write to a
* temporary file and then atomically rename over the destination when the stream is closed.
*
- * By default files created are generally readable by everyone, but if you pass FILE_CREATE_PRIVATE in
- * @a flags the file will be made readable only to the current user, to the level that is supported on the
+ * By default files created are generally readable by everyone, but if you pass FILE_CREATE_PRIVATE in
+ * @a flags the file will be made readable only to the current user, to the level that is supported on the
* target filesystem.
*
- * If you pass in an etag value, then this value is compared to the current entity tag of the file,
- * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
- * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
- * after you've finished writing and closed the FileOutputStream. When you load a new file you can
+ * If you pass in an etag value, then this value is compared to the current entity tag of the file,
+ * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
+ * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
+ * after you've finished writing and closed the FileOutputStream. When you load a new file you can
* use FileInputStream::query_info() to get the etag of the file.
*
- * If @a make_backup is true, this function will attempt to make a backup of the current file before
- * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
+ * If @a make_backup is true, this function will attempt to make a backup of the current file before
+ * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
* anyway, try again with @a make_backup set to false.
*
- * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
- * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
- * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
- * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
+ * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
+ * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
+ * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
+ * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
* depend on what kind of filesystem the file is on.
- *
+ *
* @param etag An optional entity tag for the current Glib::File.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
/** Asynchronously opens the file for appending.
* For more details, see append_to() which is the synchronous version of this call.
- *
+ *
* When the operation is finished, @a slot will be called. You can then call append_to_finish() to get the result of the operation.
* @param slot A callback slot which will be called when the request is satisfied.
* @param cancellable A Cancellable object which can be used to cancel the operation.
/** Asynchronously opens the file for appending.
* For more details, see append_to() which is the synchronous version of this call.
- *
+ *
* When the operation is finished, @a slot will be called. You can then call append_to_finish() to get the result of the operation.
* @param slot A callback slot which will be called when the request is satisfied.
* @param flags a set of FileCreateFlags.
void append_to_async(const SlotAsyncReady& slot, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_append_to_async)
- _WRAP_METHOD(Glib::RefPtr<FileOutputStream> append_to_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileOutputStream> append_to_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_append_to_finish,
- refreturn, errthrow)
-
+ errthrow)
- //We renamed this to create_file_async from (g_file_create_async() and g_file_create_readwrite_async), to avoid confusion with static create() methods,
+ //We renamed this to create_file_async from (g_file_create_async() and g_file_create_readwrite_async), to avoid confusion with static create() methods,
//but I would still like to choose a different word, but can't think of a good one. murrayc. See also create_file().
/** Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist.
* For more details, see create_file() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call create_file_finish() to get the result of the operation.
- *
+ *
* @param slot A callback slot which will be called when the request is satisfied.
* @param cancellable A Cancellable object which can be used to cancel the operation.
* @param flags a set of FileCreateFlags.
* For more details, see create_file() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call create_file_finish() to get the result of the operation.
- *
+ *
* @param slot A callback slot which will be called when the request is satisfied.
* @param flags a set of FileCreateFlags.
* @param io_priority The I/O priority of the request.
void create_file_async(const SlotAsyncReady& slot, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_create_async)
- _WRAP_METHOD(Glib::RefPtr<FileOutputStream> create_file_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileOutputStream> create_file_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_create_finish,
- refreturn, errthrow)
+ errthrow)
/** Asynchronously creates a new file and returns a stream for reading and
* For more details, see create_file_readwrite() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call create_file_readwrite_finish() to get the result of the operation.
- *
+ *
* @param slot A callback slot which will be called when the request is satisfied.
* @param cancellable A Cancellable object which can be used to cancel the operation.
* @param flags a set of FileCreateFlags.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void create_file_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
* For more details, see create_file_readwrite() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call create_file_readwrite_finish() to get the result of the operation.
- *
+ *
* @param slot A callback slot which will be called when the request is satisfied.
* @param flags a set of FileCreateFlags.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void create_file_readwrite_async(const SlotAsyncReady& slot, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_create_readwrite_async)
- _WRAP_METHOD(Glib::RefPtr<FileIOStream> create_file_readwrite_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileIOStream> create_file_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_create_readwrite_finish,
- refreturn, errthrow)
-
+ errthrow)
/** Asyncronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first.
* For more details, see replace() which is the synchronous version of this call.
void replace_async(const SlotAsyncReady& slot, const std::string& etag = std::string(), bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_replace_async)
- _WRAP_METHOD(Glib::RefPtr<FileOutputStream> replace_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileOutputStream> replace_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_replace_finish,
- refreturn, errthrow)
-
+ errthrow)
_WRAP_METHOD(Glib::RefPtr<FileIOStream> open_readwrite(const Glib::RefPtr<Cancellable>& cancellable{?}),
g_file_open_readwrite,
- refreturn, errthrow)
+ errthrow)
/** Opens an existing file for reading and writing.
* The result is a FileIOStream that can be used to read and write the contents of the file.
* @param cancellable A Cancellable object which can be used to cancel the operation.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void open_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
* @param slot A callback slot which will be called when the request is satisfied.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void open_readwrite_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_open_readwrite_async)
- _WRAP_METHOD(Glib::RefPtr<FileIOStream> open_readwrite_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileIOStream> open_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_open_readwrite_finish,
- refreturn, errthrow)
-
+ errthrow)
/** Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first.
- *
+ *
* If the file doesn't exist, it will be created.
*
* For details about the behaviour, see replace() which does the same thing but returns an output stream only.
*
- * Note that in many non-local file cases read and write streams are not supported,
+ * Note that in many non-local file cases read and write streams are not supported,
* so make sure you really need to do read and write streaming,
* rather than just opening for reading or writing.
- *
+ *
+ * @param cancellable A Cancellable object which can be used to cancel the operation.
* @param etag An optional entity tag for the current Glib::File.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
* @return A FileOutputStream.
*
- * @newin2p24
+ * @newin{2,24}
*/
Glib::RefPtr<FileIOStream> replace_readwrite(const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = std::string(), bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
/** Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first.
- *
+ *
* If the file doesn't exist, it will be created.
*
* For details about the behaviour, see replace() which does the same thing but returns an output stream only.
*
- * Note that in many non-local file cases read and write streams are not supported,
+ * Note that in many non-local file cases read and write streams are not supported,
* so make sure you really need to do read and write streaming,
* rather than just opening for reading or writing.
- *
+ *
* @param etag An optional entity tag for the current Glib::File.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
* @return A FileOutputStream.
*
- * @newin2p24
+ * @newin{2,24}
*/
Glib::RefPtr<FileIOStream> replace_readwrite(const std::string& etag = std::string(), bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
* @param flags A set of FileCreateFlags.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void replace_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = std::string(), bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
* @param flags A set of FileCreateFlags.
* @param io_priority The I/O priority of the request.
*
- * @newin2p24
+ * @newin{2,24}
*/
void replace_readwrite_async(const SlotAsyncReady& slot, const std::string& etag = std::string(), bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_replace_readwrite_async)
- _WRAP_METHOD(Glib::RefPtr<FileIOStream> replace_readwrite_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileIOStream> replace_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_replace_readwrite_finish,
- refreturn, errthrow)
-
-
-
-
-
+ errthrow)
/** Gets the requested information about the file. The result
* is a FileInfo object that contains key-value attributes (such as the type or size
* means all attributes, and a wildcard like "standard::*" means all attributes in the standard
* namespace. An example attribute query be "standard::*,owner::user".
* The standard attributes are available as defines, like #G_FILE_ATTRIBUTE_STANDARD_NAME.
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* For symlinks, normally the information about the target of the
* symlink is returned, rather than information about the symlink itself.
//We cannot use the {?} format here because we want a default value for flags, but gmmproc then generates a method with a default value for flags when it is not the last parameter.
_WRAP_METHOD(FileType query_file_type(FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable) const, g_file_query_file_type)
- /** Utility function to inspect the #GFileType of a file. This is
+ /** Utility function to inspect the FileType of a file. This is
* implemented using query_info() and as such does blocking I/O.
*
* The primary use case of this method is to check if a file is a regular file,
_IGNORE(g_file_query_info_async)
- _WRAP_METHOD(Glib::RefPtr<FileInfo> query_info_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileInfo> query_info_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_query_info_finish,
- refreturn, errthrow)
+ errthrow)
/** Similar to query_info(), but obtains information
* about the filesystem the file is on, rather than the file itself.
* For instance the amount of space availible and the type of
* the filesystem.
- *
+ *
* The @a attribute value is a string that specifies the file attributes that
* should be gathered. It is not an error if its not possible to read a particular
* requested attribute from a file, it just won't be set. @a attribute should
* Common attributes of interest are FILE_ATTRIBUTE_FILESYSTEM_SIZE
* (the total size of the filesystem in bytes), FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
* bytes availible), and FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
* If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
* Other errors are possible too, and depend on what kind of filesystem the file is on.
* @param cancellable A Cancellable object.
* about the filesystem the file is on, rather than the file itself.
* For instance the amount of space availible and the type of
* the filesystem.
- *
+ *
* The @a attribute value is a string that specifies the file attributes that
* should be gathered. It is not an error if its not possible to read a particular
* requested attribute from a file, it just won't be set. @a attribute should
* Common attributes of interest are FILE_ATTRIBUTE_FILESYSTEM_SIZE
* (the total size of the filesystem in bytes), FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
* bytes availible), and FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
- *
- *
+ *
+ *
* If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
* Other errors are possible too, and depend on what kind of filesystem the file is on.
* @param attributes An attribute query string.
Glib::RefPtr<FileInfo> query_filesystem_info(const std::string& attributes = "*");
_IGNORE(g_file_query_filesystem_info)
- _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount(const Glib::RefPtr<Cancellable>& cancellable{?}),
- g_file_find_enclosing_mount, retreturn, errthrow)
-
+ _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount(const Glib::RefPtr<Cancellable>& cancellable{?}),
+ g_file_find_enclosing_mount, errthrow)
/** Asynchronously gets the requested information about the filesystem
* that the file is on. The result is a FileInfo object
* that contains key-value attributes (such as type or size for the
* file).
- *
+ *
* For more details, see query_filesystem_info() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call query_filesystem_info_finish() to get the result of the operation.
* that the file is on. The result is a FileInfo object
* that contains key-value attributes (such as type or size for the
* file).
- *
+ *
* For more details, see query_filesystem_info() which is the synchronous version of this call.
*
* When the operation is finished, @a slot will be called. You can then call query_filesystem_info_finish() to get the result of the operation.
void query_filesystem_info_async(const SlotAsyncReady& slot, const std::string& attributes = "*", int io_priority = Glib::PRIORITY_DEFAULT) const;
_IGNORE(g_file_query_filesystem_info_async)
-
- _WRAP_METHOD(Glib::RefPtr<FileInfo> query_filesystem_info_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileInfo> query_filesystem_info_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_query_filesystem_info_finish,
- refreturn, errthrow)
+ errthrow)
/** Asynchronously gets the mount for the file.
*
void find_enclosing_mount_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_find_enclosing_mount_async)
- _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount_finish(const Glib::RefPtr<AsyncResult>& result),
- g_file_find_enclosing_mount_finish, refreturn, errthrow)
-
+ _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount_finish(const Glib::RefPtr<AsyncResult>& res),
+ g_file_find_enclosing_mount_finish, errthrow)
/** Gets the requested information about the files in a directory. The result
* is a FileEnumerator object that will give out FileInfo objects for
* all the files in the directory.
- *
+ *
* The @a attribute value is a string that specifies the file attributes that
* should be gathered. It is not an error if its not possible to read a particular
* requested attribute from a file, it just won't be set. @a attribute should
* means all attributes, and a wildcard like "standard::*" means all attributes in the standard
* namespace. An example attribute query be "standard::*,owner::user".
* The standard attributes are availible as defines, like FILE_ATTRIBUTE_STANDARD_NAME.
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
* If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
* If the file is not a directory, a Glib::FileError with NOTDIR will be thrown.
* Other errors are possible too.
/** Gets the requested information about the files in a directory. The result
* is a FileEnumerator object that will give out FileInfo objects for
* all the files in the directory.
- *
+ *
* The @a attribute value is a string that specifies the file attributes that
* should be gathered. It is not an error if its not possible to read a particular
* requested attribute from a file, it just won't be set. @a attribute should
* means all attributes, and a wildcard like "standard::*" means all attributes in the standard
* namespace. An example attribute query be "standard::*,owner::user".
* The standard attributes are availible as defines, like FILE_ATTRIBUTE_STANDARD_NAME.
- *
+ *
* If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
* If the file is not a directory, a Glib::FileError with NOTDIR will be thrown.
* Other errors are possible too.
void enumerate_children_async(const SlotAsyncReady& slot, const std::string& attributes = "*", FileQueryInfoFlags flags = FILE_QUERY_INFO_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_enumerate_children_async)
- _WRAP_METHOD(Glib::RefPtr<FileEnumerator> enumerate_children_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<FileEnumerator> enumerate_children_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_enumerate_children_finish,
errthrow)
_WRAP_METHOD(Glib::RefPtr<File> set_display_name(const Glib::ustring& display_name, const Glib::RefPtr<Cancellable>& cancellable{?}),
g_file_set_display_name,
- refreturn, errthrow)
+ errthrow)
/** Asynchronously sets the display name for a given Gio::File. For the synchronous version of this function, see set_display_name().
* When the operation is finished, @a slot will be called. You can then call set_display_name_finish() to get the result of the operation.
void set_display_name_async(const Glib::ustring& display_name, const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_set_display_name_async)
- _WRAP_METHOD(Glib::RefPtr<File> set_display_name_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(Glib::RefPtr<File> set_display_name_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_set_display_name_finish,
errthrow)
- /** Deletes a file.
+ /** Deletes a file.
* If the file is a directory, it will only be deleted if it is empty.
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Glib::FileError with ERROR_CANCELLED will be thrown.
*
* @param cancellable A Cancellable object which can be used to cancel the operation.
errthrow)
/** Asynchronously delete a file.
- * If the @file is a directory, it will
+ * If the file is a directory, it will
* only be deleted if it is empty. This has the same semantics as
* g_unlink().
*
void remove_async(const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
/** Asynchronously delete a file.
- * If the @file is a directory, it will
+ * If the file is a directory, it will
* only be deleted if it is empty. This has the same semantics as
* g_unlink().
*
*
* If FILE_COPY_OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
*
- * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
+ * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
* If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
*
- * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
+ * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
* then a Gio::Error with WOULD_RECURSE will be thrown.
*
* If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
*
* If FILE_COPY_OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
*
- * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
+ * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
* If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
*
- * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
+ * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
* then a Gio::Error with WOULD_RECURSE will be thrown.
*
* If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
*
* If FILE_COPY_OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
*
- * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
+ * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
* If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
*
- * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
+ * If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file,
* then a Gio::Error with WOULD_RECURSE will be thrown.
*
* If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
void copy_async(const Glib::RefPtr<File>& destination, const SlotAsyncReady& slot_ready, FileCopyFlags flags = FILE_COPY_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_file_copy_async)
- _WRAP_METHOD(bool copy_finish(const Glib::RefPtr<AsyncResult>& result),
+ _WRAP_METHOD(bool copy_finish(const Glib::RefPtr<AsyncResult>& res),
g_file_copy_finish,
errthrow)
- /** Tries to move the file or directory source to the location specified by destination. If native move operations are supported then this is
- * used, otherwise a copy and delete fallback is used. The native implementation may support moving directories (for instance on moves inside
+ /** Tries to move the file or directory source to the location specified by destination. If native move operations are supported then this is
+ * used, otherwise a copy and delete fallback is used. The native implementation may support moving directories (for instance on moves inside
* the same filesystem), but the fallback code does not.
*
* If the flag FILE_COPY_OVERWRITE is specified an already existing destination file is overwritten.
- *
+ *
* If the flag FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* The operation can be monitored via the @a slot callback.
* If the source file does not exist then a Gio::Error with NOT_FOUND will be thrown, independent on the status of the destination.
- *
+ *
* If G_FILE_COPY_OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
- *
- * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
+ *
+ * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
* If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
- *
+ *
* If the source is a directory and the target does not exist, or FILE_COPY_OVERWRITE is specified and the target is a file, then a Gio::Error with WOULD_RECURSE may be thrown (if the native move operation isn't available).
*/
bool move(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, const Glib::RefPtr<Cancellable>& cancellable, FileCopyFlags flags = FILE_COPY_NONE);
GError **error);
*/
- /** Tries to set all attributes in the FileInfo on the target values,
+ /** Tries to set all attributes in the FileInfo on the target values,
* not stopping on the first error.
- *
+ *
* If there is any error during this operation then a Gio::Error will be thrown.
- * Error on particular fields are flagged by setting
- * the "status" field in the attribute value to
+ * Error on particular fields are flagged by setting
+ * the "status" field in the attribute value to
* FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
* further errors.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* @param info A FileInfo.
*/
bool set_attributes_from_info(const Glib::RefPtr<FileInfo>& info, const Glib::RefPtr<Cancellable>& cancellable, FileQueryInfoFlags flags = FILE_QUERY_INFO_NONE);
- /** Tries to set all attributes in the FileInfo on the target values,
+ /** Tries to set all attributes in the FileInfo on the target values,
* not stopping on the first error.
- *
+ *
* If there is any error during this operation then a Gio::Error will be thrown.
- * Error on particular fields are flagged by setting
- * the "status" field in the attribute value to
+ * Error on particular fields are flagged by setting
+ * the "status" field in the attribute value to
* FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
* further errors.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* @param info A FileInfo.
g_file_set_attribute_int64,
errthrow)
- /** Starts a @a mount_operation, mounting the volume that contains the file.
- *
- * When this operation has completed, @a slot will be called with,
+ /** Starts a @a mount_operation, mounting the volume that contains the file.
+ *
+ * When this operation has completed, @a slot will be called with,
* and the operation can be finalized with mount_enclosing_volume_finish().
- *
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* @param mount_operation A MountOperation.
* @param slot A callback slot which will be called when the request is satisfied.
* @param cancellable A Cancellable object.
+ * @param flags Flags affecting the operation.
*/
void mount_enclosing_volume(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, MountMountFlags flags = MOUNT_MOUNT_NONE);
- /** Starts a @a mount_operation, mounting the volume that contains the file.
- *
- * When this operation has completed, @a slot will be called with,
+ /** Starts a @a mount_operation, mounting the volume that contains the file.
+ *
+ * When this operation has completed, @a slot will be called with,
* and the operation can be finalized with mount_enclosing_volume_finish().
*
* @param mount_operation A MountOperation.
* @param slot A callback slot which will be called when the request is satisfied.
+ * @param flags Flags affecting the operation.
*/
void mount_enclosing_volume(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
- /** Starts a @a mount_operation, mounting the volume that contains the file.
- *
- * When this operation has completed, @a slot will be called with,
+ /** Starts a @a mount_operation, mounting the volume that contains the file.
+ *
+ * When this operation has completed, @a slot will be called with,
* and the operation can be finalized with mount_enclosing_volume_finish().
*
* @param slot A callback slot which will be called when the request is satisfied.
+ * @param flags Flags affecting the operation.
*/
void mount_enclosing_volume(const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
_IGNORE(g_file_mount_enclosing_volume)
- /** Starts a @a mount_operation, mounting the volume that contains the file.
+ /** Starts a @a mount_operation, mounting the volume that contains the file.
*
+ * @param flags Flags affecting the operation.
*/
void mount_enclosing_volume(MountMountFlags flags = MOUNT_MOUNT_NONE);
_IGNORE(g_file_mount_enclosing _volume)
g_file_mount_enclosing_volume_finish,
errthrow)
- /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
+ /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
* @param mount_operation A MountOperation.
* @param cancellable A Cancellable object which can be used to cancel the operation.
* @param slot A callback slot which will be called when the request is satisfied.
+ * @param flags Flags affecting the operation.
*/
void mount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, MountMountFlags flags = MOUNT_MOUNT_NONE);
- /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
+ /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
* When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
*
* @param mount_operation A MountOperation.
* @param slot A callback slot which will be called when the request is satisfied.
+ * @param flags Flags affecting the operation.
*/
void mount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
* When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
*
* @param slot A callback slot which will be called when the request is satisfied.
+ * @param flags Flags affecting the operation.
*/
void mount_mountable(const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Mounts a file of type FILE_TYPE_MOUNTABLE without user interaction.
+ *
+ * @param flags Flags affecting the operation.
*/
void mount_mountable(MountMountFlags flags = MOUNT_MOUNT_NONE);
_IGNORE(g_file_mount_mountable)
_WRAP_METHOD(Glib::RefPtr<File> mount_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
g_file_mount_mountable_finish,
- refreturn, errthrow)
+ errthrow)
/** Unmounts a file of type FILE_TYPE_MOUNTABLE.
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
/** Unmounts a file of type FILE_TYPE_MOUNTABLE.
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void unmount_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void unmount_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void unmount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
/** Starts an asynchronous eject on a mountable.
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
/** Starts an asynchronous eject on a mountable.
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void eject_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void eject_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
* @param mount_operation A MountOperation
* @param flags Flags affecting the operation.
*
- * @newin2p24
+ * @newin{2,24}
*/
void eject_mountable(const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
errthrow)
- /** Copies the file attributes from @a source to @a destination.
+ /** Copies the file attributes from @a source to @a destination.
*
* Normally only a subset of the file attributes are copied,
* those that are copies in a normal file copy operation
*/
bool copy_attributes(const Glib::RefPtr<File>& destination, const Glib::RefPtr<Cancellable>& cancellable, FileCopyFlags flags = FILE_COPY_NONE);
- /** Copies the file attributes from @a source to @a destination.
+ /** Copies the file attributes from @a source to @a destination.
*
* Normally only a subset of the file attributes are copied,
* those that are copies in a normal file copy operation
*/
bool copy_attributes(const Glib::RefPtr<File>& destination, FileCopyFlags flags = FILE_COPY_NONE);
_IGNORE(g_file_copy_attributes)
-
+
/** Obtains a directory monitor for the given file.
* This may fail if directory monitoring is not supported.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
/** Obtains a directory monitor for the given file.
* This may fail if directory monitoring is not supported.
- *
+ *
* @param flags A set of FileMonitorFlags.
* @return A FileMonitor for the file.
*/
/** Obtains a file monitor for the given file. If no file notification
* mechanism exists, then regular polling of the file is used.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
+ * @param cancellable A Cancellable object.
* @param flags A set of FileMonitorFlags.
- * @param A Cancellable object.
* @return A FileMonitor for the file.
*/
Glib::RefPtr<FileMonitor> monitor_file(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags = FILE_MONITOR_NONE);
/** Obtains a file monitor for the given file. If no file notification
* mechanism exists, then regular polling of the file is used.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* @param flags A set of FileMonitorFlags.
- * @param A Cancellable object.
* @return A FileMonitor for the file.
*/
Glib::RefPtr<FileMonitor> monitor_file(FileMonitorFlags flags = FILE_MONITOR_NONE);
/** Obtains a file monitor for the given file. If no file notification
* mechanism exists, then regular polling of the file is used.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
+ * @param cancellable A Cancellable object.
* @param flags A set of FileMonitorFlags.
- * @param A Cancellable object.
* @return A FileMonitor for the file.
*
* @newin{2,18}
/** Obtains a file monitor for the given file. If no file notification
* mechanism exists, then regular polling of the file is used.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* @param flags A set of FileMonitorFlags.
- * @param A Cancellable object.
* @return A FileMonitor for the file.
*
* @newin{2,18}
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with start_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * @param slot: A callback to call when the request is satisfied.
+ * @param slot A callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
+ * @param start_operation A MountOperation, or <tt>0</tt> to avoid user interaction.
* @param flags Flags affecting the operation
*
- * @newin2p24
+ * @newin{2,24}
*/
void start_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& start_operation, DriveStartFlags flags = DRIVE_START_NONE);
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with start_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * @param slot: A callback to call when the request is satisfied.
- * @param cancellable A Cancellable object.
+ * @param slot A callback to call when the request is satisfied.
+ * @param start_operation A MountOperation, or <tt>0</tt> to avoid user interaction.
* @param flags Flags affecting the operation
*
- * @newin2p24
+ * @newin{2,24}
*/
void start_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& start_operation, DriveStartFlags flags = DRIVE_START_NONE);
_IGNORE(g_file_start_mountable)
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with stop_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * @param slot: A callback to call when the request is satisfied.
+ * @param slot A callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
+ * @param start_operation A MountOperation, or <tt>0</tt> to avoid user interaction.
* @param flags Flags affecting the operation
*
- * @newin2p24
+ * @newin{2,24}
*/
void stop_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& start_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with stop_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
- * @param slot: A callback to call when the request is satisfied.
- * @param start_operation A Cancellable object.
+ * @param slot A callback to call when the request is satisfied.
+ * @param start_operation A MountOperation, or <tt>0</tt> to avoid user interaction.
* @param flags Flags affecting the operation
*
- * @newin2p24
+ * @newin{2,24}
*/
void stop_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& start_operation, MountUnmountFlags flags = MOUNT_UNMOUNT_NONE);
_IGNORE(g_file_stop_mountable)
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with stop_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* @param slot: A callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
*
- * @newin2p24
+ * @newin{2,24}
*/
void poll_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
* Using @a start_operation, you can request callbacks when, for instance,
* passwords are needed during authentication.
*
- * When this operation has completed, @a slot will be called
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with stop_mountable_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* @param slot: A callback to call when the request is satisfied.
*
- * @newin2p24
+ * @newin{2,24}
*/
void poll_mountable(const SlotAsyncReady& slot);
_IGNORE(g_file_poll_mountable)
errthrow)
//TODO: Something better than char*& for contents?
- /** Loads the content of the file into memory, returning the size of the data.
+ /** Loads the content of the file into memory, returning the size of the data.
* The data is always zero terminated, but this is not included in the resultant @a length.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error exception with CANCELLED will be returned.
*
* @param cancellable A cancellable object.
- * @param contents A location to place the contents of the file.
+ * @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @param etag_out A location to place the current entity tag for the file.
*/
bool load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length, std::string& etag_out);
- /** Loads the content of the file into memory, returning the size of the data.
+ /** Loads the content of the file into memory, returning the size of the data.
* The data is always zero terminated, but this is not included in the resultant @a length.
- *
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ *
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error exception with CANCELLED will be returned.
*
* @param cancellable A cancellable object.
- * @param contents A location to place the contents of the file.
+ * @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @newin{2,22}
*/
bool load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length);
//TODO: Something better than char*& for contents?
- /** Loads the content of the file into memory, returning the size of the data.
+ /** Loads the content of the file into memory, returning the size of the data.
* The data is always zero terminated, but this is not included in the resultant @a length.
*
- * @param contents A location to place the contents of the file.
+ * @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @param etag_out A location to place the current entity tag for the file.
*/
bool load_contents(char*& contents, gsize& length, std::string& etag_out);
- /** Loads the content of the file into memory, returning the size of the data.
+ /** Loads the content of the file into memory, returning the size of the data.
* The data is always zero terminated, but this is not included in the resultant @a length.
*
- * @param contents A location to place the contents of the file.
+ * @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @newin{2,22}
*/
/** Starts an asynchronous load of the file's contents.
* For more details, see load_contents() which is the synchronous version of this call.
*
- * When the load operation has completed, the @a slot will be called. To finish the operation,
+ * When the load operation has completed, the @a slot will be called. To finish the operation,
* call load_contents_finish() with the AsyncResult provided to the @a slot.
*
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
*
* @param slot A callback slot which will be called when the request is satisfied.
/** Starts an asynchronous load of the file's contents.
* For more details, see load_contents() which is the synchronous version of this call.
*
- * When the load operation has completed, the @a slot will be called. To finish the operation,
+ * When the load operation has completed, the @a slot will be called. To finish the operation,
* call load_contents_finish() with the AsyncResult provided to the @a slot.
*
* @param slot A callback slot which will be called when the request is satisfied.
void load_contents_async(const SlotAsyncReady& slot);
_IGNORE(g_file_load_contents_async)
- /** Finishes an asynchronous load of the @a file's contents.
- * The contents are placed in @a contents, and @a length is set to the
- * size of the @a contents string. If @a etag_out is present, it will be
+ /** Finishes an asynchronous load of the @a file's contents.
+ * The contents are placed in @a contents, and @a length is set to the
+ * size of the @a contents string. If @a etag_out is present, it will be
* set to the new entity tag for the @a file.
- * @param res A AsyncResult.
+ * @param result A AsyncResult.
* @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @param etag_out A location to place the current entity tag for the file.
- * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
+ * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
* present, it will be set appropriately.
*/
bool load_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out);
- /** Finishes an asynchronous load of the @a file's contents.
- * The contents are placed in @a contents, and @a length is set to the
- * size of the @a contents string. If @a etag_out is present, it will be
+ /** Finishes an asynchronous load of the @a file's contents.
+ * The contents are placed in @a contents, and @a length is set to the
+ * size of the @a contents string. If @a etag_out is present, it will be
* set to the new entity tag for the @a file.
- * @param res A AsyncResult.
+ * @param result A AsyncResult.
* @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
- * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
+ * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
* present, it will be set appropriately.
* @newin{2,22}
*/
*/
typedef sigc::slot<bool, const char*, goffset> SlotReadMore;
- //Note that slot_read_more can be NULL but that would not be a useful method overload, because the documentation says that it would
+ //Note that slot_read_more can be NULL but that would not be a useful method overload, because the documentation says that it would
//then be equivalent to load_contents_async.
/** Reads the partial contents of a file.
* The @a slot_read_more callback slot should be used to stop reading from the file when appropriate. This operation can be finished by load_partial_contents_finish().
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call load_partial_contents_finish() to get the result of the operation.
/** Reads the partial contents of a file.
* The @a slot_read_more callback slot should be used to stop reading from the file when appropriate. This operation can be finished by load_partial_contents_finish().
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call load_partial_contents_finish() to get the result of the operation.
/** Finishes an asynchronous partial load operation that was started
* with load_partial_contents_async().
- * @param res A AsyncResult.
+ * @param result A AsyncResult.
* @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
* @param etag_out A location to place the current entity tag for the file.
- * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
+ * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
* present, it will be set appropriately.
*/
bool load_partial_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out);
/** Finishes an asynchronous partial load operation that was started
* with load_partial_contents_async().
- * @param res A AsyncResult.
+ * @param result A AsyncResult.
* @param contents A location to place the contents of the file.
* @param length A location to place the length of the contents of the file.
- * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
+ * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
* present, it will be set appropriately.
* @newin{2,22}
*/
_IGNORE(g_file_load_partial_contents_finish)
/** Replaces the contents of the file with @a contents of @a length bytes.
- *
+ *
* If @a etag is specified (not an empty string) any existing file must have that etag, or
* a Gio::Error with WRONG_ETAG will be thrown.
- *
+ *
* If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
* The returned @a new_etag can be used to verify that the file hasn't changed the
* next time it is saved over.
* @param contents A string containing the new contents for the file.
* @param length The length of @a contents in bytes.
- * @param etag The old entity tag
+ * @param etag The old entity tag
* for the document.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
void replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
/** Replaces the contents of the file with @a contents of @a length bytes.
- *
+ *
* If @a etag is specified (not an empty string) any existing file must have that etag, or
* a Gio::Error with WRONG_ETAG will be thrown.
- *
+ *
* If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
- *
+ *
* The returned @a new_etag can be used to verify that the file hasn't changed the
* next time it is saved over.
* @param contents A string containing the new contents for the file.
* @param length The length of @a contents in bytes.
- * @param etag The old entity tag
+ * @param etag The old entity tag
* for the document.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
void replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
/** Replaces the contents of the file with @a contents.
- *
+ *
* If @a etag is specified (not an empty string) any existing file must have that etag, or
* a Gio::Error with WRONG_ETAG will be thrown.
- *
+ *
* If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
* The returned @a new_etag can be used to verify that the file hasn't changed the
* next time it is saved over.
* @param contents A string containing the new contents for the file.
- * @param etag The old entity tag
+ * @param etag The old entity tag
* for the document.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
void replace_contents(const std::string& contents, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
/** Replaces the contents of the file with @a contents.
- *
+ *
* If @a etag is specified (not an empty string) any existing file must have that etag, or
* a Gio::Error with WRONG_ETAG will be thrown.
- *
+ *
* If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
- *
+ *
* The returned @a new_etag can be used to verify that the file hasn't changed the
* next time it is saved over.
* @param contents A string containing the new contents for the file.
- * @param etag The old entity tag
+ * @param etag The old entity tag
* for the document.
* @param make_backup <tt>true</tt> if a backup should be created.
* @param flags A set of FileCreateFlags.
//TODO: Add replace_contents() without the etags?
- /** Starts an asynchronous replacement of the file with the given
- * @a contents of @a length bytes. @a etag will replace the document's
+ /** Starts an asynchronous replacement of the file with the given
+ * @a contents of @a length bytes. @a etag will replace the document's
* current entity tag.
- *
- * When this operation has completed, @a slot will be called
+ *
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with replace_contents_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
- * If @a make_backup is true, this function will attempt to
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
+ * If @a make_backup is true, this function will attempt to
* make a backup of the file.
*
* @param slot: A callback to call when the request is satisfied.
*/
void replace_contents_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const char* contents, gsize length, const std::string& etag, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
- /** Starts an asynchronous replacement of the file with the given
- * @a contents of @a length bytes. @a etag will replace the document's
+ /** Starts an asynchronous replacement of the file with the given
+ * @a contents of @a length bytes. @a etag will replace the document's
* current entity tag.
- *
- * When this operation has completed, @a slot will be called
+ *
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with replace_contents_finish().
- *
- * If @a make_backup is true, this function will attempt to
+ *
+ * If @a make_backup is true, this function will attempt to
* make a backup of the file.
*
* @param slot: A callback to call when the request is satisfied.
*/
void replace_contents_async(const SlotAsyncReady& slot, const char* contents, gsize length, const std::string& etag, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
- /** Starts an asynchronous replacement of the file with the given
- * @a contents of @a length bytes. @a etag will replace the document's
+ /** Starts an asynchronous replacement of the file with the given
+ * @a contents of @a length bytes. @a etag will replace the document's
* current entity tag.
- *
- * When this operation has completed, @a slot will be called
+ *
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with replace_contents_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
- * If @a make_backup is true, this function will attempt to
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
+ * If @a make_backup is true, this function will attempt to
* make a backup of the file.
*
* @param slot: A callback to call when the request is satisfied.
*/
void replace_contents_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& contents, const std::string& etag, bool make_backup = false, FileCreateFlags flags = FILE_CREATE_NONE);
- /** Starts an asynchronous replacement of the file with the given
- * @a contents. @a etag will replace the document's
+ /** Starts an asynchronous replacement of the file with the given
+ * @a contents. @a etag will replace the document's
* current entity tag.
- *
- * When this operation has completed, @a slot will be called
+ *
+ * When this operation has completed, @a slot will be called
* and the operation can be finalized with replace_contents_finish().
- *
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED will be thrown.
- *
- * If @a make_backup is true, this function will attempt to
+ * was cancelled, a Gio::Error with CANCELLED will be thrown.
+ *
+ * If @a make_backup is true, this function will attempt to
* make a backup of the file.
*
* @param slot: A callback to call when the request is satisfied.
_IGNORE(g_file_replace_contents_async)
/** Finishes an asynchronous replace of the given file . See
- * replace_contents_async(). Sets @a new_etag to the new entity
+ * replace_contents_async(). Sets @a new_etag to the new entity
* tag for the document.
* @param result A AsyncResult.
- * @param new_etag A location of a new entity tag
+ * @param new_etag A location of a new entity tag
* for the document.
*/
void replace_contents_finish(const Glib::RefPtr<AsyncResult>& result, std::string& etag);
/** Finishes an asynchronous replace of the given file . See
- * replace_contents_async(). Sets @a new_etag to the new entity
+ * replace_contents_async(). Sets @a new_etag to the new entity
* tag for the document.
* @param result A AsyncResult.
* for the document.
namespace Container_Helpers
{
-/** This specialization of TypeTraits exists
- * because the default use of Glib::wrap(GObject*),
+/** This specialization of TypeTraits exists
+ * because the default use of Glib::wrap(GObject*),
* instead of a specific Glib::wrap(GSomeInterface*),
* would not return a wrapper for an interface.
- */
+ */
template <>
struct TypeTraits< Glib::RefPtr<Gio::File> >
{
static CppType to_cpp_type (const CType& item)
{
- //Use a specific Glib::wrap() function,
+ //Use a specific Glib::wrap() function,
//because CType has the specific type (not just GObject):
return Glib::wrap(item, true /* take_copy */);
}
/** Key-Value paired file attributes.
* File attributes in GIO consist of a list of key-value pairs.
*
- * Keys are strings that contain a key namespace and a key name, separated by a colon, e.g. "namespace:keyname".
- * Namespaces are included to sort key-value pairs by namespaces for relevance. Keys can be retreived using wildcards,
+ * Keys are strings that contain a key namespace and a key name, separated by a colon, e.g. "namespace:keyname".
+ * Namespaces are included to sort key-value pairs by namespaces for relevance. Keys can be retreived using wildcards,
* e.g. "standard::*" will return all of the keys in the "standard" namespace.
*
- * Values are stored within the list in Gio::FileAttributeValue structures. Values can store different types, listed in the enum
+ * Values are stored within the list in Gio::FileAttributeValue structures. Values can store different types, listed in the enum
* Gio::FileAttributeType. Upon creation of a Gio::FileAttributeValue, the type will be set to Gio::FILE_ATTRIBUTE_TYPE_INVALID.
*
- * The list of possible attributes for a filesystem (pointed to by a Gio::File) is availible as a Gio::FileAttributeInfoList.
+ * The list of possible attributes for a filesystem (pointed to by a Gio::File) is availible as a Gio::FileAttributeInfoList.
* This list is queryable by key names as indicated earlier.
*
- * Classes that implement Gio::FileIface will create a Gio::FileAttributeInfoList and install default keys and values for their given file
- * system, architecture, and other possible implementation details (e.g., on a UNIX system, a file attribute key will be registered for
+ * Classes that implement Gio::FileIface will create a Gio::FileAttributeInfoList and install default keys and values for their given file
+ * system, architecture, and other possible implementation details (e.g., on a UNIX system, a file attribute key will be registered for
* the user id for a given file).
*
* See http://library.gnome.org/devel/gio/unstable/gio-GFileAttribute.html for the list of default namespaces and the list of default keys.
*/
bool empty() const;
- /** Gets the file attribute with the name name from list.
+ /** Gets the file attribute with the name name from list.
* @param name The name of the attribute to lookup.
* @result A FileAttributeInfo for the name.
*/
//TODO: Consider wrapping this like a std::iterator (or at least renaming it), though the asyncness probably makes that unsuitable.
/** Enumerated Files Routines.
- * FileEnumerator allows you to operate on a set of Gio::Files, returning a Gio::FileInfo instance for each file enumerated
+ * FileEnumerator allows you to operate on a set of Gio::Files, returning a Gio::FileInfo instance for each file enumerated
* (e.g. Gio::File::enumerate_children() will return a FileEnumerator for each of the children within a directory).
*
- * To get the next file's information from a Gio::FileEnumerator, use next_file() or its asynchronous version, next_file_async().
- * Note that the asynchronous version will return a list of Gio::FileInfos, whereas the synchronous version will only return the next
+ * To get the next file's information from a Gio::FileEnumerator, use next_file() or its asynchronous version, next_file_async().
+ * Note that the asynchronous version will return a list of Gio::FileInfos, whereas the synchronous version will only return the next
* file in the enumerator.
*
- * To close a Gio::FileEnumerator, use FileEnumerator::close(), or its asynchronous version, close_async(). Once a FileEnumerator is closed,
+ * To close a Gio::FileEnumerator, use FileEnumerator::close(), or its asynchronous version, close_async(). Once a FileEnumerator is closed,
* no further actions may be performed on it.
*
* @newin{2,16}
errthrow)
- /** Request information for a number of files from the enumerator asynchronously.
+ /** Request information for a number of files from the enumerator asynchronously.
* When all I/O for the operation is finished the callback slot will be called with the requested information.
*
- * The callback could be called with less than num_files files in case of error or at the end of the enumerator.
- * In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported.
+ * The callback could be called with less than num_files files in case of error or at the end of the enumerator.
+ * In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported.
* If a request is cancelled the callback will be called with ERROR_CANCELLED.
*
* During an async request no other sync and async calls are allowed, and will result in ERROR_PENDING errors.
*
- * Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority.
+ * Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority.
* The default priority is PRIORITY_DEFAULT.
* @param slot A callback to call when the request is satisfied.
* @param cancellable An cancellable object which can be used to cancel the request.
*/
void next_files_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int num_files = 1, int io_priority = Glib::PRIORITY_DEFAULT);
- /** Request information for a number of files from the enumerator asynchronously.
+ /** Request information for a number of files from the enumerator asynchronously.
* When all I/O for the operation is finished the callback slot will be called with the requested information.
*
- * The callback could be called with less than num_files files in case of error or at the end of the enumerator.
- * In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported.
+ * The callback could be called with less than num_files files in case of error or at the end of the enumerator.
+ * In case of a partial error the callback will be called with any succeeding items and no error, and on the next request the error will be reported.
* If a request is cancelled the callback will be called with ERROR_CANCELLED.
*
* During an async request no other sync and async calls are allowed, and will result in ERROR_PENDING errors.
*
- * Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority.
+ * Any outstanding I/O request with higher priority (lower numerical value) will be executed before an outstanding request with lower priority.
* The default priority is PRIORITY_DEFAULT.
* @param slot A callback to call when the request is satisfied.
* @param num_files The number of file info objects to request.
*
* See close(), which is the synchronous version of this function.
*
- * The operation can be cancelled by triggering the cancellable object from another thread.
+ * The operation can be cancelled by triggering the cancellable object from another thread.
* If the operation was cancelled, a Gio::Error with CANCELLED will be thrown by close_finish().
*
* @param io_priority The I/O priority of the request.
_WRAP_METHOD(Glib::RefPtr<FileAttributeMatcher> create_difference(const Glib::RefPtr<const FileAttributeMatcher>& subtract) const, g_file_attribute_matcher_subtract)
- _WRAP_METHOD(bool matches(const std::string& full_name) const, g_file_attribute_matcher_matches)
- _WRAP_METHOD(bool matches_only(const std::string& full_name) const, g_file_attribute_matcher_matches_only)
+ _WRAP_METHOD(bool matches(const std::string& attribute) const, g_file_attribute_matcher_matches)
+ _WRAP_METHOD(bool matches_only(const std::string& attribute) const, g_file_attribute_matcher_matches_only)
_WRAP_METHOD(bool enumerate_namespace(const std::string& ns), g_file_attribute_matcher_enumerate_namespace)
_WRAP_METHOD(std::string enumerate_next(), g_file_attribute_matcher_enumerate_next)
_WRAP_METHOD(std::string to_string() const, g_file_attribute_matcher_to_string)
_WRAP_METHOD(Glib::RefPtr<FileInfo> dup() const,
g_file_info_dup)
- _WRAP_METHOD(void copy_into(Glib::RefPtr<FileInfo>& dest) const,
+ _WRAP_METHOD(void copy_into(Glib::RefPtr<FileInfo>& dest_info) const,
g_file_info_copy_into)
_WRAP_METHOD(bool has_attribute(const std::string& attribute) const,
g_file_info_has_attribute)
#m4 _CONVERSION(`const std::vector<Glib::ustring>&',`char**',`const_cast<char**>(Glib::ArrayHandler<Glib::ustring>::vector_to_array($3).data())')
_WRAP_METHOD(void set_attribute_strings(const std::string& attribute, const std::vector<Glib::ustring>& attr_value), g_file_info_set_attribute_stringv)
- _WRAP_METHOD(void set_attribute_byte_string(const std::string& attribute, const std::string& value),
+ _WRAP_METHOD(void set_attribute_byte_string(const std::string& attribute, const std::string& attr_value),
g_file_info_set_attribute_byte_string)
- _WRAP_METHOD(void set_attribute_boolean(const std::string& attribute, bool value),
+ _WRAP_METHOD(void set_attribute_boolean(const std::string& attribute, bool attr_value),
g_file_info_set_attribute_boolean)
- _WRAP_METHOD(void set_attribute_uint32(const std::string& attribute, guint32 value),
+ _WRAP_METHOD(void set_attribute_uint32(const std::string& attribute, guint32 attr_value),
g_file_info_set_attribute_uint32)
- _WRAP_METHOD(void set_attribute_int32(const std::string& attribute, gint32 value),
+ _WRAP_METHOD(void set_attribute_int32(const std::string& attribute, gint32 attr_value),
g_file_info_set_attribute_int32)
- _WRAP_METHOD(void set_attribute_uint64(const std::string& attribute, guint64 value),
+ _WRAP_METHOD(void set_attribute_uint64(const std::string& attribute, guint64 attr_value),
g_file_info_set_attribute_uint64)
- _WRAP_METHOD(void set_attribute_int64(const std::string& attribute, gint64 value),
+ _WRAP_METHOD(void set_attribute_int64(const std::string& attribute, gint64 attr_value),
g_file_info_set_attribute_int64)
- _WRAP_METHOD(void set_attribute_object(const std::string& attribute, const Glib::RefPtr<Glib::Object>& object),
+ _WRAP_METHOD(void set_attribute_object(const std::string& attribute, const Glib::RefPtr<Glib::Object>& attr_value),
g_file_info_set_attribute_object)
_WRAP_METHOD(void clear_status(), g_file_info_clear_status)
/** FileInputStream provides input streams that take their content from a file.
*
- * FileInputStream implements Seekable, which allows the input stream to jump to arbitrary positions in the file,
+ * FileInputStream implements Seekable, which allows the input stream to jump to arbitrary positions in the file,
* provided the file system of the file allows it.
* Use the methods of the Seekable base class for seeking and positioning.
*
*
* @newin{2,16}
*/
-class FileInputStream
-: public Gio::InputStream,
+class FileInputStream
+: public Gio::InputStream,
public Seekable
{
_CLASS_GOBJECT(FileInputStream, GFileInputStream, G_FILE_INPUT_STREAM, Gio::InputStream, GInputStream)
public:
- /** Queries a file input stream the given @a attributes. This function blocks
- * while querying the stream. For the asynchronous (non-blocking) version
- * of this function, see query_info_async(). While the
- * stream is blocked, the stream will set the pending flag internally, and
+ /** Queries a file input stream the given @a attributes. This function blocks
+ * while querying the stream. For the asynchronous (non-blocking) version
+ * of this function, see query_info_async(). While the
+ * stream is blocked, the stream will set the pending flag internally, and
* any other operations on the stream will throw a Gio::Error with PENDING.
*
* @param attributes A file attribute query string.
*/
Glib::RefPtr<FileInfo> query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*");
- /** Queries a file input stream the given @a attributes. This function blocks
- * while querying the stream. For the asynchronous (non-blocking) version
- * of this function, see query_info_async(). While the
- * stream is blocked, the stream will set the pending flag internally, and
+ /** Queries a file input stream the given @a attributes. This function blocks
+ * while querying the stream. For the asynchronous (non-blocking) version
+ * of this function, see query_info_async(). While the
+ * stream is blocked, the stream will set the pending flag internally, and
* any other operations on the stream will throw a Gio::Error with PENDING.
*
* @param attributes A file attribute query string.
/** Queries the stream information asynchronously. For the synchronous version of this function, see query_info().
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call query_info_finish() to get the result of the operation.
/** FileIOStream provides input streams that take their content from a file.
*
- * FileInputStream implements Seekable, which allows the input stream to jump to arbitrary positions in the file,
+ * FileInputStream implements Seekable, which allows the input stream to jump to arbitrary positions in the file,
* provided the file system of the file allows it.
* Use the methods of the Seekable base class for seeking and positioning.
*
public:
- /** Queries a file input stream the given @a attributes. This function blocks
- * while querying the stream. For the asynchronous (non-blocking) version
- * of this function, see query_info_async(). While the
- * stream is blocked, the stream will set the pending flag internally, and
+ /** Queries a file input stream the given @a attributes. This function blocks
+ * while querying the stream. For the asynchronous (non-blocking) version
+ * of this function, see query_info_async(). While the
+ * stream is blocked, the stream will set the pending flag internally, and
* any other operations on the stream will throw a Gio::Error with PENDING.
*
* @param attributes A file attribute query string.
*/
Glib::RefPtr<FileInfo> query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*");
- /** Queries a file input stream the given @a attributes. This function blocks
- * while querying the stream. For the asynchronous (non-blocking) version
- * of this function, see query_info_async(). While the
- * stream is blocked, the stream will set the pending flag internally, and
+ /** Queries a file input stream the given @a attributes. This function blocks
+ * while querying the stream. For the asynchronous (non-blocking) version
+ * of this function, see query_info_async(). While the
+ * stream is blocked, the stream will set the pending flag internally, and
* any other operations on the stream will throw a Gio::Error with PENDING.
*
* @param attributes A file attribute query string.
/** Queries the stream information asynchronously. For the synchronous version of this function, see query_info().
*
- * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
+ * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
* a Gio::Error with CANCELLED will be thrown.
*
* When the operation is finished, @a slot will be called. You can then call query_info_finish() to get the result of the operation.
tcpconnection.hg \
threadedsocketservice.hg \
themedicon.hg \
+ tlscertificate.hg \
+ tlsclientconnection.hg \
+ tlsconnection.hg \
+ tlsdatabase.hg \
+ tlsfiledatabase.hg \
+ tlsinteraction.hg \
+ tlspassword.hg \
+ tlsserverconnection.hg \
volume.hg \
volumemonitor.hg \
zlibdecompressor.hg \
class File;
/** Monitors a file or directory for changes.
- * To obtain a FileMonitor for a file or directory, use File::monitor_file() or
+ * To obtain a FileMonitor for a file or directory, use File::monitor_file() or
* File::monitor_directory().
- *
- * To get informed about changes to the file or directory you are monitoring,
+ *
+ * To get informed about changes to the file or directory you are monitoring,
* connect to signal_changed().
*
* @newin{2,16}
protected:
public:
-
+
_WRAP_METHOD(bool cancel(), g_file_monitor_cancel)
_WRAP_METHOD(bool is_cancelled() const, g_file_monitor_is_cancelled)
_WRAP_METHOD(void set_rate_limit(int limit_msecs), g_file_monitor_set_rate_limit)
#m4 _CONVERSION(`GFile*',`const Glib::RefPtr<File>&',`Glib::wrap($3, true)')
_WRAP_SIGNAL(void changed(const Glib::RefPtr<File>& file, const Glib::RefPtr<File>& other_file, FileMonitorEvent event_type), "changed")
-
+
//_WRAP_VFUNC(bool cancel(), cancel);
_WRAP_PROPERTY("rate-limit", int)
class File;
-/** Completes partial file and directory names given a partial string by looking in the file system for clues.
+/** Completes partial file and directory names given a partial string by looking in the file system for clues.
* Can return a list of possible completion strings for widget implementation.
*
* @newin{2,16}
_WRAP_CREATE()
_WRAP_METHOD(std::string get_completion_suffix(const std::string& initial_text) const, g_filename_completer_get_completion_suffix)
-
+
#m4 _CONVERSION(`char**',`Glib::StringArrayHandle',`Glib::StringArrayHandle($3, Glib::OWNERSHIP_DEEP)')
_WRAP_METHOD(Glib::StringArrayHandle get_completions(const std::string& initial_text) const, g_filename_completer_get_completions)
_WRAP_METHOD(void set_dirs_only(bool dirs_only = true), g_filename_completer_set_dirs_only)
/** FileOutputStream provides output streams that write their content to a file.
*
- * FileOutputStream implements Seekable, which allows the output stream to jump
- * to arbitrary positions in the file and to truncate the file, provided the
+ * FileOutputStream implements Seekable, which allows the output stream to jump
+ * to arbitrary positions in the file and to truncate the file, provided the
* file system of the file supports these operations.
- * Use the methods of the Seekable base class for seeking and positioning.
- *
+ * Use the methods of the Seekable base class for seeking and positioning.
+ *
* @ingroup Streams
*
* @newin{2,16}
public:
- /** Queries a file output stream for the given @a attributes .
- * This function blocks while querying the stream. For the asynchronous
- * version of this function, see query_info_async().
- * While the stream is blocked, the stream will set the pending flag
- * internally, and any other operations on the stream will throw a Gio::Error with
+ /** Queries a file output stream for the given @a attributes .
+ * This function blocks while querying the stream. For the asynchronous
+ * version of this function, see query_info_async().
+ * While the stream is blocked, the stream will set the pending flag
+ * internally, and any other operations on the stream will throw a Gio::Error with
* PENDING.
- *
- * Can fail if the stream was already closed (with a
+ *
+ * Can fail if the stream was already closed (with a
* CLOSED error), the stream has pending operations (with a PENDING error),
- * or if querying info is not supported for
+ * or if querying info is not supported for
* the stream's interface (with a NOT_SUPPORTED error). In
* all cases of failure, an empty RefPtr will be returned.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED may be thrown, and an empty RefPtr will
+ * was cancelled, a Gio::Error with CANCELLED may be thrown, and an empty RefPtr will
* be returned.
*
* @param cancellable A Cancellable object.
*/
Glib::RefPtr<FileInfo> query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*");
- /** Queries a file output stream for the given @a attributes .
- * This function blocks while querying the stream. For the asynchronous
- * version of this function, see query_info_async().
- * While the stream is blocked, the stream will set the pending flag
- * internally, and any other operations on the stream will throw a Gio::Error with
+ /** Queries a file output stream for the given @a attributes .
+ * This function blocks while querying the stream. For the asynchronous
+ * version of this function, see query_info_async().
+ * While the stream is blocked, the stream will set the pending flag
+ * internally, and any other operations on the stream will throw a Gio::Error with
* PENDING.
- *
- * Can fail if the stream was already closed (with a CLOSED error),
+ *
+ * Can fail if the stream was already closed (with a CLOSED error),
* the stream has pending operations (with an PENDING error),
- * or if querying info is not supported for
+ * or if querying info is not supported for
* the stream's interface (with a NOT_SUPPORTED error). In
* all cases of failure, an empty RefPtr will be returned.
- *
+ *
* The operation can be cancelled by triggering the cancellable object from another thread. If the operation
- * was cancelled, a Gio::Error with CANCELLED may be thrown, and an empty RefPtr will
+ * was cancelled, a Gio::Error with CANCELLED may be thrown, and an empty RefPtr will
* be returned.
*
- * @param cancellable A Cancellable object.
* @param attributes A file attribute query string.
* @return A FileInfo for the stream, or an empty RefPtr on error.
*/
/** Queries the stream information asynchronously.
- * When the operation is finished @a slot will be called.
- * You can then call query_info_finish()
+ * When the operation is finished @a slot will be called.
+ * You can then call query_info_finish()
* to get the result of the operation.
*
- * For the synchronous version of this function,
- * see query_info().
- *
+ * For the synchronous version of this function,
+ * see query_info().
+ *
* The operation can be cancelled by
* triggering the cancellable object from another thread. If the operation
* was cancelled, a Gio::Error with CANCELLED may be thrown
- *
+ *
* @param slot Callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
* @param attributes A file attribute query string.
void query_info_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", int io_priority = Glib::PRIORITY_DEFAULT);
/** Queries the stream information asynchronously.
- * When the operation is finished @a slot will be called.
- * You can then call query_info_finish()
+ * When the operation is finished @a slot will be called.
+ * You can then call query_info_finish()
* to get the result of the operation.
*
- * For the synchronous version of this function,
- * see query_info().
- *
+ * For the synchronous version of this function,
+ * see query_info().
+ *
* @param slot Callback to call when the request is satisfied.
* @param attributes A file attribute query string.
* @param io_priority The <io-priority of the request.
//These seem to be just C convenience functions - they are already in the Seekable base class:
//See http://bugzilla.gnome.org/show_bug.cgi?id=509990
- _IGNORE(g_file_output_stream_tell, g_file_output_stream_can_seek, g_file_output_stream_seek,
+ _IGNORE(g_file_output_stream_tell, g_file_output_stream_can_seek, g_file_output_stream_seek,
g_file_output_stream_can_truncate, g_file_output_stream_truncate)
// _WRAP_METHOD(goffset tell() const, g_file_output_stream_tell)
// _WRAP_METHOD(bool can_seek() const, g_file_output_stream_can_seek)
{
/** Filter Input Stream.
- * This is a base class for input stream implementations that perform some kind of filtering operation on a base stream.
- & Typical examples of filtering operations are character set conversion, compression and byte order flipping.
+ * This is a base class for input stream implementations that perform some kind of filtering operation on a base stream.
+ & Typical examples of filtering operations are character set conversion, compression and byte order flipping.
*
* @ingroup Streams
*
/** Filter Output Stream.
*
- * This is a base class for output stream implementations that perform some kind of filtering operation on a base stream.
- * Typical examples of filtering operations are character set conversion, compression and byte order flipping.
+ * This is a base class for output stream implementations that perform some kind of filtering operation on a base stream.
+ * Typical examples of filtering operations are character set conversion, compression and byte order flipping.
*
* @ingroup Streams
*
<return></return>
</signal>
+<enum name="GAppInfoCreateFlags">
+<description>
+Flags used when creating a #GAppInfo.
+
+</description>
+<parameters>
+<parameter name="G_APP_INFO_CREATE_NONE">
+<parameter_description> No flags.
+</parameter_description>
+</parameter>
+<parameter name="G_APP_INFO_CREATE_NEEDS_TERMINAL">
+<parameter_description> Application opens in a terminal window.
+</parameter_description>
+</parameter>
+<parameter name="G_APP_INFO_CREATE_SUPPORTS_URIS">
+<parameter_description> Application supports URI arguments.
+</parameter_description>
+</parameter>
+<parameter name="G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION">
+<parameter_description> Application supports startup notification. Since 2.26
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GApplication::activate">
<description>
The ::activate signal is emitted on the primary instance when an
<return></return>
</signal>
+<enum name="GApplicationFlags">
+<description>
+Flags used to define the behaviour of a #GApplication.
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_APPLICATION_FLAGS_NONE">
+<parameter_description> Default
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_IS_SERVICE">
+<parameter_description> Run as a service. In this mode, registration
+fails if the service is already running, and the application will
+stay around for a while when the use count falls to zero.
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_IS_LAUNCHER">
+<parameter_description> Don't try to become the primary instance.
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_HANDLES_OPEN">
+<parameter_description> This application handles opening files (in
+the primary instance). Note that this flag only affects the default
+implementation of local_command_line(), and has no effect if
+%G_APPLICATION_HANDLES_COMMAND_LINE is given.
+See g_application_run() for details.
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_HANDLES_COMMAND_LINE">
+<parameter_description> This application handles command line
+arguments (in the primary instance). Note that this flag only affect
+the default implementation of local_command_line().
+See g_application_run() for details.
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_SEND_ENVIRONMENT">
+<parameter_description> Send the environment of the
+launching process to the primary instance. Set this flag if your
+application is expected to behave differently depending on certain
+environment variables. For instance, an editor might be expected
+to use the <envar>GIT_COMMITTER_NAME</envar> environment variable
+when editing a git commit message. The environment is available
+to the #GApplication::command-line signal handler, via
+g_application_command_line_getenv().
+</parameter_description>
+</parameter>
+<parameter name="G_APPLICATION_NON_UNIQUE">
+<parameter_description> Make no attempts to do any of the typical
+single-instance application negotiation, even if the application
+ID is given. The application neither attempts to become the
+owner of the application ID nor does it check if an existing
+owner already exists. Everything occurs in the local process.
+Since: 2.30.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GAskPasswordFlags">
+<description>
+#GAskPasswordFlags are used to request specific information from the
+user, or to notify the user of their choices in an authentication
+situation.
+
+</description>
+<parameters>
+<parameter name="G_ASK_PASSWORD_NEED_PASSWORD">
+<parameter_description> operation requires a password.
+</parameter_description>
+</parameter>
+<parameter name="G_ASK_PASSWORD_NEED_USERNAME">
+<parameter_description> operation requires a username.
+</parameter_description>
+</parameter>
+<parameter name="G_ASK_PASSWORD_NEED_DOMAIN">
+<parameter_description> operation requires a domain.
+</parameter_description>
+</parameter>
+<parameter name="G_ASK_PASSWORD_SAVING_SUPPORTED">
+<parameter_description> operation supports saving settings.
+</parameter_description>
+</parameter>
+<parameter name="G_ASK_PASSWORD_ANONYMOUS_SUPPORTED">
+<parameter_description> operation supports anonymous users.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GBusNameOwnerFlags">
+<description>
+Flags used in g_bus_own_name().
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_BUS_NAME_OWNER_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT">
+<parameter_description> Allow another message bus connection to claim the name.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_NAME_OWNER_FLAGS_REPLACE">
+<parameter_description> If another message bus connection owns the name and have
+specified #G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GBusNameWatcherFlags">
+<description>
+Flags used in g_bus_watch_name().
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_BUS_NAME_WATCHER_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_NAME_WATCHER_FLAGS_AUTO_START">
+<parameter_description> If no-one owns the name when
+beginning to watch the name, ask the bus to launch an owner for the
+name.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GBusType">
+<description>
+An enumeration for well-known message buses.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_BUS_TYPE_STARTER">
+<parameter_description> An alias for the message bus that activated the process, if any.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_TYPE_NONE">
+<parameter_description> Not a message bus.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_TYPE_SYSTEM">
+<parameter_description> The system-wide message bus.
+</parameter_description>
+</parameter>
+<parameter name="G_BUS_TYPE_SESSION">
+<parameter_description> The login session message bus.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GCancellable::cancelled">
<description>
Emitted when the operation has been cancelled.
<return></return>
</signal>
+<enum name="GConverterFlags">
+<description>
+Flags used when calling a g_converter_convert().
+
+Since: 2.24
+
+</description>
+<parameters>
+<parameter name="G_CONVERTER_NO_FLAGS">
+<parameter_description> No flags.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERTER_INPUT_AT_END">
+<parameter_description> At end of input data
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERTER_FLUSH">
+<parameter_description> Flush data
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GConverterResult">
+<description>
+Results returned from g_converter_convert().
+
+Since: 2.24
+
+</description>
+<parameters>
+<parameter name="G_CONVERTER_ERROR">
+<parameter_description> There was an error during conversion.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERTER_CONVERTED">
+<parameter_description> Some data was consumed or produced
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERTER_FINISHED">
+<parameter_description> The conversion is finished
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERTER_FLUSHED">
+<parameter_description> Flushing is finished
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GCredentialsType">
+<description>
+Enumeration describing different kinds of native credential types.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_CREDENTIALS_TYPE_INVALID">
+<parameter_description> Indicates an invalid native credential type.
+</parameter_description>
+</parameter>
+<parameter name="G_CREDENTIALS_TYPE_LINUX_UCRED">
+<parameter_description> The native credentials type is a <type>struct ucred</type>.
+</parameter_description>
+</parameter>
+<parameter name="G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED">
+<parameter_description> The native credentials type is a <type>struct cmsgcred</type>.
+</parameter_description>
+</parameter>
+<parameter name="G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED">
+<parameter_description> The native credentials type is a <type>struct sockpeercred</type>. Added in 2.30.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusAuthObserver::allow-mechanism">
<description>
Emitted to check if @mechanism is allowed to be used.
</return>
</signal>
+<enum name="GDBusCallFlags">
+<description>
+Flags used in g_dbus_connection_call() and similar APIs.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_CALL_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CALL_FLAGS_NO_AUTO_START">
+<parameter_description> The bus must not launch
+an owner for the destination name in response to this method
+invocation.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusCapabilityFlags">
+<description>
+Capabilities negotiated with the remote peer.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_CAPABILITY_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING">
+<parameter_description> The connection
+supports exchanging UNIX file descriptors with the remote peer.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusConnection::closed">
<description>
Emitted when the connection is closed.
<return></return>
</signal>
+<enum name="GDBusConnectionFlags">
+<description>
+Flags used when creating a new #GDBusConnection.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_CONNECTION_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT">
+<parameter_description> Perform authentication against server.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER">
+<parameter_description> Perform authentication against client.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS">
+<parameter_description> When
+authenticating as a server, allow the anonymous authentication
+method.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION">
+<parameter_description> Pass this flag if connecting to a peer that is a
+message bus. This means that the Hello() method will be invoked as part of the connection setup.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING">
+<parameter_description> If set, processing of D-Bus messages is
+delayed until g_dbus_connection_start_message_processing() is called.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusError">
+<description>
+Error codes for the %G_DBUS_ERROR error domain.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_ERROR_FAILED">
+<parameter_description>
+A generic error; "something went wrong" - see the error message for
+more.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NO_MEMORY">
+<parameter_description>
+There was not enough memory to complete an operation.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SERVICE_UNKNOWN">
+<parameter_description>
+The bus doesn't know how to launch a service to supply the bus name
+you wanted.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NAME_HAS_NO_OWNER">
+<parameter_description>
+The bus name you referenced doesn't exist (i.e. no application owns
+it).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NO_REPLY">
+<parameter_description>
+No reply to a message expecting one, usually means a timeout occurred.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_IO_ERROR">
+<parameter_description>
+Something went wrong reading or writing to a socket, for example.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_BAD_ADDRESS">
+<parameter_description>
+A D-Bus bus address was malformed.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NOT_SUPPORTED">
+<parameter_description>
+Requested operation isn't supported (like ENOSYS on UNIX).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_LIMITS_EXCEEDED">
+<parameter_description>
+Some limited resource is exhausted.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_ACCESS_DENIED">
+<parameter_description>
+Security restrictions don't allow doing what you're trying to do.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_AUTH_FAILED">
+<parameter_description>
+Authentication didn't work.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NO_SERVER">
+<parameter_description>
+Unable to connect to server (probably caused by ECONNREFUSED on a
+socket).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_TIMEOUT">
+<parameter_description>
+Certain timeout errors, possibly ETIMEDOUT on a socket. Note that
+%G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
+this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
+exists. We can't fix it for compatibility reasons so just be
+careful.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_NO_NETWORK">
+<parameter_description>
+No network access (probably ENETUNREACH on a socket).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_ADDRESS_IN_USE">
+<parameter_description>
+Can't bind a socket since its address is in use (i.e. EADDRINUSE).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_DISCONNECTED">
+<parameter_description>
+The connection is disconnected and you're trying to use it.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_INVALID_ARGS">
+<parameter_description>
+Invalid arguments passed to a method call.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_FILE_NOT_FOUND">
+<parameter_description>
+Missing file.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_FILE_EXISTS">
+<parameter_description>
+Existing file and the operation you're using does not silently overwrite.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_UNKNOWN_METHOD">
+<parameter_description>
+Method name you invoked isn't known by the object you invoked it on.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_TIMED_OUT">
+<parameter_description>
+Certain timeout errors, e.g. while starting a service. Warning: this is
+confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
+can't fix it for compatibility reasons so just be careful.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_MATCH_RULE_NOT_FOUND">
+<parameter_description>
+Tried to remove or modify a match rule that didn't exist.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_MATCH_RULE_INVALID">
+<parameter_description>
+The match rule isn't syntactically valid.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_EXEC_FAILED">
+<parameter_description>
+While starting a new process, the exec() call failed.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_FORK_FAILED">
+<parameter_description>
+While starting a new process, the fork() call failed.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_CHILD_EXITED">
+<parameter_description>
+While starting a new process, the child exited with a status code.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_CHILD_SIGNALED">
+<parameter_description>
+While starting a new process, the child exited on a signal.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_FAILED">
+<parameter_description>
+While starting a new process, something went wrong.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_SETUP_FAILED">
+<parameter_description>
+We failed to setup the environment correctly.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_CONFIG_INVALID">
+<parameter_description>
+We failed to setup the config parser correctly.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_SERVICE_INVALID">
+<parameter_description>
+Bus name was not valid.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND">
+<parameter_description>
+Service file not found in system-services directory.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID">
+<parameter_description>
+Permissions are incorrect on the setuid helper.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_FILE_INVALID">
+<parameter_description>
+Service file invalid (Name, User or Exec missing).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SPAWN_NO_MEMORY">
+<parameter_description>
+Tried to get a UNIX process ID and it wasn't available.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN">
+<parameter_description>
+Tried to get a UNIX process ID and it wasn't available.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_INVALID_SIGNATURE">
+<parameter_description>
+A type signature is not valid.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_INVALID_FILE_CONTENT">
+<parameter_description>
+A file contains invalid syntax or is otherwise broken.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN">
+<parameter_description>
+Asked for SELinux security context and it wasn't available.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN">
+<parameter_description>
+Asked for ADT audit data and it wasn't available.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_ERROR_OBJECT_PATH_IN_USE">
+<parameter_description>
+There's already an object with the requested object path.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusInterfaceSkeleton::g-authorize-method">
<description>
Emitted when a method is invoked by a remote caller and used to
</return>
</signal>
+<enum name="GDBusInterfaceSkeletonFlags">
+<description>
+Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_DBUS_INTERFACE_SKELETON_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD">
+<parameter_description> Each method invocation is handled in
+a thread dedicated to the invocation. This means that the method implementation can use blocking IO
+without blocking any other part of the process. It also means that the method implementation must
+use locking to access data structures used by other threads.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusMessageByteOrder">
+<description>
+Enumeration used to describe the byte order of a D-Bus message.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN">
+<parameter_description> The byte order is big endian.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN">
+<parameter_description> The byte order is little endian.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusMessageFlags">
+<description>
+Message flags used in #GDBusMessage.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_MESSAGE_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED">
+<parameter_description> A reply is not expected.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_FLAGS_NO_AUTO_START">
+<parameter_description> The bus must not launch an
+owner for the destination name in response to this message.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusMessageHeaderField">
+<description>
+Header fields used in #GDBusMessage.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_INVALID">
+<parameter_description> Not a valid header field.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_PATH">
+<parameter_description> The object path.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE">
+<parameter_description> The interface name.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_MEMBER">
+<parameter_description> The method or signal name.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME">
+<parameter_description> The name of the error that occurred.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL">
+<parameter_description> The serial number the message is a reply to.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION">
+<parameter_description> The name the message is intended for.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_SENDER">
+<parameter_description> Unique name of the sender of the message (filled in by the bus).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE">
+<parameter_description> The signature of the message body.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS">
+<parameter_description> The number of UNIX file descriptors that accompany the message.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusMessageType">
+<description>
+Message types used in #GDBusMessage.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_MESSAGE_TYPE_INVALID">
+<parameter_description> Message is of invalid type.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_TYPE_METHOD_CALL">
+<parameter_description> Method call.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_TYPE_METHOD_RETURN">
+<parameter_description> Method reply.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_TYPE_ERROR">
+<parameter_description> Error reply.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_MESSAGE_TYPE_SIGNAL">
+<parameter_description> Signal emission.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusObject::interface-added">
<description>
Emitted when @interface is added to @object.
<return></return>
</signal>
+<enum name="GDBusObjectManagerClientFlags">
+<description>
+Flags used when constructing a #GDBusObjectManagerClient.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START">
+<parameter_description> If not set and the
+manager is for a well-known name, then request the bus to launch
+an owner for the name if no-one owns the name. This flag can only
+be used in managers for well-known names.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusObjectSkeleton::authorize-method">
<description>
Emitted when a method is invoked by a remote caller and used to
</return>
</signal>
+<enum name="GDBusPropertyInfoFlags">
+<description>
+Flags describing the access control of a D-Bus property.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_PROPERTY_INFO_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROPERTY_INFO_FLAGS_READABLE">
+<parameter_description> Property is readable.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE">
+<parameter_description> Property is writable.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusProxy::g-properties-changed">
<description>
Emitted when one or more D-Bus properties on @proxy changes. The
<return></return>
</signal>
+<enum name="GDBusProxyFlags">
+<description>
+Flags used when constructing an instance of a #GDBusProxy derived class.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_PROXY_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES">
+<parameter_description> Don't load properties.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS">
+<parameter_description> Don't connect to signals on the remote object.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START">
+<parameter_description> If not set and the proxy if for a well-known name,
+then request the bus to launch an owner for the name if no-one owns the name. This flag can
+only be used in proxies for well-known names.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES">
+<parameter_description> If set, the property value for any <emphasis>invalidated property</emphasis> will be (asynchronously) retrieved upon receiving the <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties">PropertiesChanged</ulink> D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusSendMessageFlags">
+<description>
+Flags used when sending #GDBusMessage<!-- -->s on a #GDBusConnection.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_SEND_MESSAGE_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL">
+<parameter_description> Do not automatically
+assign a serial number from the #GDBusConnection object when
+sending a message.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDBusServer::new-connection">
<description>
Emitted when a new authenticated connection has been made. Use
</return>
</signal>
+<enum name="GDBusServerFlags">
+<description>
+Flags used when creating a #GDBusServer.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_SERVER_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_SERVER_FLAGS_RUN_IN_THREAD">
+<parameter_description> All #GDBusServer::new-connection
+signals will run in separated dedicated threads (see signal for
+details).
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS">
+<parameter_description> Allow the anonymous
+authentication method.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusSignalFlags">
+<description>
+Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_SIGNAL_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE">
+<parameter_description> Don't actually send the AddMatch
+D-Bus call for this signal subscription. This gives you more control
+over which match rules you add (but you must add them manually).
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDBusSubtreeFlags">
+<description>
+Flags passed to g_dbus_connection_register_subtree().
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_DBUS_SUBTREE_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES">
+<parameter_description> Method calls to objects not in the enumerated range
+will still be dispatched. This is useful if you want
+to dynamically spawn objects in the subtree.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDataStreamByteOrder">
+<description>
+#GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
+across various machine architectures.
+
+
+</description>
+<parameters>
+<parameter name="G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN">
+<parameter_description> Selects Big Endian byte order.
+</parameter_description>
+</parameter>
+<parameter name="G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN">
+<parameter_description> Selects Little Endian byte order.
+</parameter_description>
+</parameter>
+<parameter name="G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN">
+<parameter_description> Selects endianness based on host machine's architecture.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDataStreamNewlineType">
+<description>
+#GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
+
+</description>
+<parameters>
+<parameter name="G_DATA_STREAM_NEWLINE_TYPE_LF">
+<parameter_description> Selects "LF" line endings, common on most modern UNIX platforms.
+</parameter_description>
+</parameter>
+<parameter name="G_DATA_STREAM_NEWLINE_TYPE_CR">
+<parameter_description> Selects "CR" line endings.
+</parameter_description>
+</parameter>
+<parameter name="G_DATA_STREAM_NEWLINE_TYPE_CR_LF">
+<parameter_description> Selects "CR, LF" line ending, common on Microsoft Windows.
+</parameter_description>
+</parameter>
+<parameter name="G_DATA_STREAM_NEWLINE_TYPE_ANY">
+<parameter_description> Automatically try to handle any line ending type.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GDrive::changed">
<description>
Emitted when the drive's state has changed.
<return></return>
</signal>
+<enum name="GDriveStartFlags">
+<description>
+Flags used when starting a drive.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_DRIVE_START_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDriveStartStopType">
+<description>
+Enumeration describing how a drive can be started/stopped.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_DRIVE_START_STOP_TYPE_UNKNOWN">
+<parameter_description> Unknown or drive doesn't support
+start/stop.
+</parameter_description>
+</parameter>
+<parameter name="G_DRIVE_START_STOP_TYPE_SHUTDOWN">
+<parameter_description> The stop method will physically
+shut down the drive and e.g. power down the port the drive is
+attached to.
+</parameter_description>
+</parameter>
+<parameter name="G_DRIVE_START_STOP_TYPE_NETWORK">
+<parameter_description> The start/stop methods are used
+for connecting/disconnect to the drive over the network.
+</parameter_description>
+</parameter>
+<parameter name="G_DRIVE_START_STOP_TYPE_MULTIDISK">
+<parameter_description> The start/stop methods will
+assemble/disassemble a virtual drive from several physical
+drives.
+</parameter_description>
+</parameter>
+<parameter name="G_DRIVE_START_STOP_TYPE_PASSWORD">
+<parameter_description> The start/stop methods will
+unlock/lock the disk (for example using the ATA <quote>SECURITY
+UNLOCK DEVICE</quote> command)
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GEmblemOrigin">
+<description>
+GEmblemOrigin is used to add information about the origin of the emblem
+to #GEmblem.
+
+Since: 2.18
+
+</description>
+<parameters>
+<parameter name="G_EMBLEM_ORIGIN_UNKNOWN">
+<parameter_description> Emblem of unknown origin
+</parameter_description>
+</parameter>
+<parameter name="G_EMBLEM_ORIGIN_DEVICE">
+<parameter_description> Emblem adds device-specific information
+</parameter_description>
+</parameter>
+<parameter name="G_EMBLEM_ORIGIN_LIVEMETADATA">
+<parameter_description> Emblem depicts live metadata, such as "readonly"
+</parameter_description>
+</parameter>
+<parameter name="G_EMBLEM_ORIGIN_TAG">
+<parameter_description> Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileAttributeInfoFlags">
+<description>
+Flags specifying the behaviour of an attribute.
+
+</description>
+<parameters>
+<parameter name="G_FILE_ATTRIBUTE_INFO_NONE">
+<parameter_description> no flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE">
+<parameter_description> copy the attribute values when the file is copied.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED">
+<parameter_description> copy the attribute values when the file is moved.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileAttributeStatus">
+<description>
+Used by g_file_set_attributes_from_info() when setting file attributes.
+
+</description>
+<parameters>
+<parameter name="G_FILE_ATTRIBUTE_STATUS_UNSET">
+<parameter_description> Attribute value is unset (empty).
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_STATUS_SET">
+<parameter_description> Attribute value is set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING">
+<parameter_description> Indicates an error in setting the value.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileAttributeType">
+<description>
+The data types for file attributes.
+
+</description>
+<parameters>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_INVALID">
+<parameter_description> indicates an invalid or uninitalized type.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_STRING">
+<parameter_description> a null terminated UTF8 string.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_BYTE_STRING">
+<parameter_description> a zero terminated string of non-zero bytes.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_BOOLEAN">
+<parameter_description> a boolean value.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_UINT32">
+<parameter_description> an unsigned 4-byte/32-bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_INT32">
+<parameter_description> a signed 4-byte/32-bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_UINT64">
+<parameter_description> an unsigned 8-byte/64-bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_INT64">
+<parameter_description> a signed 8-byte/64-bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_OBJECT">
+<parameter_description> a #GObject.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ATTRIBUTE_TYPE_STRINGV">
+<parameter_description> a %NULL terminated char **. Since 2.22
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileCopyFlags">
+<description>
+Flags used when copying or moving files.
+
+</description>
+<parameters>
+<parameter name="G_FILE_COPY_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_OVERWRITE">
+<parameter_description> Overwrite any existing files
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_BACKUP">
+<parameter_description> Make a backup of any existing files.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_NOFOLLOW_SYMLINKS">
+<parameter_description> Don't follow symlinks.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_ALL_METADATA">
+<parameter_description> Copy all file metadata instead of just default set used for copy (see #GFileInfo).
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_NO_FALLBACK_FOR_MOVE">
+<parameter_description> Don't use copy and delete fallback if native move not supported.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_COPY_TARGET_DEFAULT_PERMS">
+<parameter_description> Leaves target file with default perms, instead of setting the source file perms.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileCreateFlags">
+<description>
+Flags used when an operation may create a file.
+
+</description>
+<parameters>
+<parameter name="G_FILE_CREATE_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_CREATE_PRIVATE">
+<parameter_description> Create a file that can only be
+accessed by the current user.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_CREATE_REPLACE_DESTINATION">
+<parameter_description> Replace the destination
+as if it didn't exist before. Don't try to keep any old
+permissions, replace instead of following links. This
+is generally useful if you're doing a "copy over"
+rather than a "save new version of" replace operation.
+You can think of it as "unlink destination" before
+writing to it, although the implementation may not
+be exactly like that. Since 2.20
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GFileMonitor::changed">
<description>
Emitted when @file has been changed.
<return></return>
</signal>
+<enum name="GFileMonitorEvent">
+<description>
+Specifies what type of event a monitor event is.
+
+</description>
+<parameters>
+<parameter name="G_FILE_MONITOR_EVENT_CHANGED">
+<parameter_description> a file changed.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT">
+<parameter_description> a hint that this was probably the last change in a set of changes.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_DELETED">
+<parameter_description> a file was deleted.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_CREATED">
+<parameter_description> a file was created.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED">
+<parameter_description> a file attribute was changed.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_PRE_UNMOUNT">
+<parameter_description> the file location will soon be unmounted.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_UNMOUNTED">
+<parameter_description> the file location was unmounted.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_EVENT_MOVED">
+<parameter_description> the file was moved.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileMonitorFlags">
+<description>
+Flags used to set what a #GFileMonitor will watch for.
+
+</description>
+<parameters>
+<parameter name="G_FILE_MONITOR_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_WATCH_MOUNTS">
+<parameter_description> Watch for mount events.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_MONITOR_SEND_MOVED">
+<parameter_description> Pair DELETED and CREATED events caused
+by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
+event instead (NB: not supported on all backends; the default
+behaviour -without specifying this flag- is to send single DELETED
+and CREATED events).
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileQueryInfoFlags">
+<description>
+Flags used when querying a #GFileInfo.
+
+</description>
+<parameters>
+<parameter name="G_FILE_QUERY_INFO_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS">
+<parameter_description> Don't follow symlinks.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileType">
+<description>
+Indicates the file's on-disk type.
+
+</description>
+<parameters>
+<parameter name="G_FILE_TYPE_UNKNOWN">
+<parameter_description> File's type is unknown.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_REGULAR">
+<parameter_description> File handle represents a regular file.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_DIRECTORY">
+<parameter_description> File handle represents a directory.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_SYMBOLIC_LINK">
+<parameter_description> File handle represents a symbolic link
+(Unix systems).
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_SPECIAL">
+<parameter_description> File is a "special" file, such as a socket, fifo,
+block device, or character device.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_SHORTCUT">
+<parameter_description> File is a shortcut (Windows systems).
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TYPE_MOUNTABLE">
+<parameter_description> File is a mountable location.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GFilenameCompleter::got-completion-data">
<description>
Emitted when the file name completion information comes available.
<return></return>
</signal>
+<enum name="GFilesystemPreviewType">
+<description>
+Indicates a hint from the file system whether files should be
+previewed in a file manager. Returned as the value of the key
+#G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
+
+</description>
+<parameters>
+<parameter name="G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS">
+<parameter_description> Only preview files if user has explicitly requested it.
+</parameter_description>
+</parameter>
+<parameter name="G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL">
+<parameter_description> Preview files if user has requested preview of "local" files.
+</parameter_description>
+</parameter>
+<parameter name="G_FILESYSTEM_PREVIEW_TYPE_NEVER">
+<parameter_description> Never preview files.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOErrorEnum">
+<description>
+Error codes returned by GIO functions.
+
+
+</description>
+<parameters>
+<parameter name="G_IO_ERROR_FAILED">
+<parameter_description> Generic error condition for when any operation fails.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_FOUND">
+<parameter_description> File not found.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_EXISTS">
+<parameter_description> File already exists.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_IS_DIRECTORY">
+<parameter_description> File is a directory.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_DIRECTORY">
+<parameter_description> File is not a directory.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_EMPTY">
+<parameter_description> File is a directory that isn't empty.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_REGULAR_FILE">
+<parameter_description> File is not a regular file.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_SYMBOLIC_LINK">
+<parameter_description> File is not a symbolic link.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_MOUNTABLE_FILE">
+<parameter_description> File cannot be mounted.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_FILENAME_TOO_LONG">
+<parameter_description> Filename is too many characters.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_INVALID_FILENAME">
+<parameter_description> Filename is invalid or contains invalid characters.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_TOO_MANY_LINKS">
+<parameter_description> File contains too many symbolic links.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NO_SPACE">
+<parameter_description> No space left on drive.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_INVALID_ARGUMENT">
+<parameter_description> Invalid argument.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PERMISSION_DENIED">
+<parameter_description> Permission denied.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_SUPPORTED">
+<parameter_description> Operation not supported for the current backend.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_MOUNTED">
+<parameter_description> File isn't mounted.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_ALREADY_MOUNTED">
+<parameter_description> File is already mounted.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_CLOSED">
+<parameter_description> File was closed.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_CANCELLED">
+<parameter_description> Operation was cancelled. See #GCancellable.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PENDING">
+<parameter_description> Operations are still pending.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_READ_ONLY">
+<parameter_description> File is read only.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_CANT_CREATE_BACKUP">
+<parameter_description> Backup couldn't be created.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_WRONG_ETAG">
+<parameter_description> File's Entity Tag was incorrect.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_TIMED_OUT">
+<parameter_description> Operation timed out.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_WOULD_RECURSE">
+<parameter_description> Operation would be recursive.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_BUSY">
+<parameter_description> File is busy.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_WOULD_BLOCK">
+<parameter_description> Operation would block.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_HOST_NOT_FOUND">
+<parameter_description> Host couldn't be found (remote operations).
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_WOULD_MERGE">
+<parameter_description> Operation would merge files.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_FAILED_HANDLED">
+<parameter_description> Operation failed and a helper program has
+already interacted with the user. Do not display any error dialog.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_TOO_MANY_OPEN_FILES">
+<parameter_description> The current process has too many files
+open and can't open any more. Duplicate descriptors do count toward
+this limit. Since 2.20
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NOT_INITIALIZED">
+<parameter_description> The object has not been initialized. Since 2.22
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_ADDRESS_IN_USE">
+<parameter_description> The requested address is already in use. Since 2.22
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PARTIAL_INPUT">
+<parameter_description> Need more input to finish operation. Since 2.24
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_INVALID_DATA">
+<parameter_description> There input data was invalid. Since 2.24
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_DBUS_ERROR">
+<parameter_description> A remote object generated an error that
+doesn't correspond to a locally registered #GError error
+domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
+error name and g_dbus_error_strip_remote_error() to fix up the
+message so it matches what was received on the wire. Since 2.26.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_HOST_UNREACHABLE">
+<parameter_description> Host unreachable. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_NETWORK_UNREACHABLE">
+<parameter_description> Network unreachable. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_CONNECTION_REFUSED">
+<parameter_description> Connection refused. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PROXY_FAILED">
+<parameter_description> Connection to proxy server failed. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PROXY_AUTH_FAILED">
+<parameter_description> Proxy authentication failed. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PROXY_NEED_AUTH">
+<parameter_description> Proxy server needs authentication. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_PROXY_NOT_ALLOWED">
+<parameter_description> Proxy connection is not allowed by ruleset.
+Since 2.26
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOModuleScopeFlags">
+<description>
+Flags for use with g_io_module_scope_new().
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_IO_MODULE_SCOPE_NONE">
+<parameter_description> No module scan flags
+</parameter_description>
+</parameter>
+<parameter name="G_IO_MODULE_SCOPE_BLOCK_DUPLICATES">
+<parameter_description> When using this scope to load or
+scan modules, automatically block a modules which has the same base
+basename as previously loaded module.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOStreamSpliceFlags">
+<description>
+GIOStreamSpliceFlags determine how streams should be spliced.
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_IO_STREAM_SPLICE_NONE">
+<parameter_description> Do not close either stream.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STREAM_SPLICE_CLOSE_STREAM1">
+<parameter_description> Close the first stream after
+the splice.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STREAM_SPLICE_CLOSE_STREAM2">
+<parameter_description> Close the second stream after
+the splice.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STREAM_SPLICE_WAIT_FOR_BOTH">
+<parameter_description> Wait for both splice operations to finish
+before calling the callback.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GMenuModel::items-changed">
<description>
Emitted when a change has occured to the menu.
<return></return>
</signal>
+<enum name="GMountMountFlags">
+<description>
+Flags used when mounting a mount.
+
+</description>
+<parameters>
+<parameter name="G_MOUNT_MOUNT_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GMountOperation::aborted">
<description>
Emitted by the backend when e.g. a device becomes unavailable
<return></return>
</signal>
+<enum name="GMountOperationResult">
+<description>
+#GMountOperationResult is returned as a result when a request for
+information is send by the mounting operation.
+
+</description>
+<parameters>
+<parameter name="G_MOUNT_OPERATION_HANDLED">
+<parameter_description> The request was fulfilled and the
+user specified data is now available
+</parameter_description>
+</parameter>
+<parameter name="G_MOUNT_OPERATION_ABORTED">
+<parameter_description> The user requested the mount operation
+to be aborted
+</parameter_description>
+</parameter>
+<parameter name="G_MOUNT_OPERATION_UNHANDLED">
+<parameter_description> The request was unhandled (i.e. not
+implemented)
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GMountUnmountFlags">
+<description>
+Flags used when an unmounting a mount.
+
+</description>
+<parameters>
+<parameter name="G_MOUNT_UNMOUNT_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_MOUNT_UNMOUNT_FORCE">
+<parameter_description> Unmount even if there are outstanding
+file operations on the mount.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GNetworkMonitor::network-changed">
<description>
Emitted when the network configuration changes. If @available is
<return></return>
</signal>
+<enum name="GOutputStreamSpliceFlags">
+<description>
+GOutputStreamSpliceFlags determine how streams should be spliced.
+
+</description>
+<parameters>
+<parameter name="G_OUTPUT_STREAM_SPLICE_NONE">
+<parameter_description> Do not close either stream.
+</parameter_description>
+</parameter>
+<parameter name="G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE">
+<parameter_description> Close the source stream after
+the splice.
+</parameter_description>
+</parameter>
+<parameter name="G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET">
+<parameter_description> Close the target stream after
+the splice.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GPasswordSave">
+<description>
+#GPasswordSave is used to indicate the lifespan of a saved password.
+
+#Gvfs stores passwords in the Gnome keyring when this flag allows it
+to, and later retrieves it again from there.
+
+</description>
+<parameters>
+<parameter name="G_PASSWORD_SAVE_NEVER">
+<parameter_description> never save a password.
+</parameter_description>
+</parameter>
+<parameter name="G_PASSWORD_SAVE_FOR_SESSION">
+<parameter_description> save a password for the session.
+</parameter_description>
+</parameter>
+<parameter name="G_PASSWORD_SAVE_PERMANENTLY">
+<parameter_description> save a password permanently.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GResolver::reload">
<description>
Emitted when the resolver notices that the system resolver
<return></return>
</signal>
+<enum name="GResolverError">
+<description>
+An error code used with %G_RESOLVER_ERROR in a #GError returned
+from a #GResolver routine.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_RESOLVER_ERROR_NOT_FOUND">
+<parameter_description> the requested name/address/service was not
+found
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_ERROR_TEMPORARY_FAILURE">
+<parameter_description> the requested information could not
+be looked up due to a network error or similar problem
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_ERROR_INTERNAL">
+<parameter_description> unknown error
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GResolverRecordType">
+<description>
+The type of record that g_resolver_lookup_records() or
+g_resolver_lookup_records_async() should retrieve. The records are returned
+as lists of #GVariant tuples. Each record type has different values in
+the variant tuples returned.
+
+%G_RESOLVER_RECORD_SRV records are returned as variants with the signature
+'(qqqs)', containing a guint16 with the priority, a guint16 with the
+weight, a guint16 with the port, and a string of the hostname.
+
+%G_RESOLVER_RECORD_MX records are returned as variants with the signature
+'(qs)', representing a guint16 with the preference, and a string containing
+the mail exchanger hostname.
+
+%G_RESOLVER_RECORD_TXT records are returned as variants with the signature
+'(as)', representing an array of the strings in the text record.
+
+%G_RESOLVER_RECORD_SOA records are returned as variants with the signature
+'(ssuuuuu)', representing a string containing the primary name server, a
+string containing the administrator, the serial as a guint32, the refresh
+interval as guint32, the retry interval as a guint32, the expire timeout
+as a guint32, and the ttl as a guint32.
+
+%G_RESOLVER_RECORD_NS records are returned as variants with the signature
+'(s)', representing a string of the hostname of the name server.
+
+Since: 2.34
+
+</description>
+<parameters>
+<parameter name="G_RESOLVER_RECORD_SRV">
+<parameter_description> lookup DNS SRV records for a domain
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_RECORD_MX">
+<parameter_description> lookup DNS MX records for a domain
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_RECORD_TXT">
+<parameter_description> lookup DNS TXT records for a name
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_RECORD_SOA">
+<parameter_description> lookup DNS SOA records for a zone
+</parameter_description>
+</parameter>
+<parameter name="G_RESOLVER_RECORD_NS">
+<parameter_description> lookup DNS NS records for a domain
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GResourceError">
+<description>
+An error code used with %G_RESOURCE_ERROR in a #GError returned
+from a #GResource routine.
+
+Since: 2.32
+
+</description>
+<parameters>
+<parameter name="G_RESOURCE_ERROR_NOT_FOUND">
+<parameter_description> no file was found at the requested path
+</parameter_description>
+</parameter>
+<parameter name="G_RESOURCE_ERROR_INTERNAL">
+<parameter_description> unknown error
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GResourceFlags">
+<description>
+GResourceFlags give information about a particular file inside a resource
+bundle.
+
+Since: 2.32
+
+</description>
+<parameters>
+<parameter name="G_RESOURCE_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+<parameter name="G_RESOURCE_FLAGS_COMPRESSED">
+<parameter_description> The file is compressed.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GResourceLookupFlags">
+<description>
+GResourceLookupFlags determine how resource path lookups are handled.
+
+Since: 2.32
+
+</description>
+<parameters>
+<parameter name="G_RESOURCE_LOOKUP_FLAGS_NONE">
+<parameter_description> No flags set.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GSettings::change-event">
<description>
The "change-event" signal is emitted once per change event that
<return></return>
</signal>
+<enum name="GSettingsBindFlags">
+<description>
+Flags used when creating a binding. These flags determine in which
+direction the binding works. The default is to synchronize in both
+directions.
+
+</description>
+<parameters>
+<parameter name="G_SETTINGS_BIND_DEFAULT">
+<parameter_description> Equivalent to <literal>G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SETTINGS_BIND_GET">
+<parameter_description> Update the #GObject property when the setting changes.
+It is an error to use this flag if the property is not writable.
+</parameter_description>
+</parameter>
+<parameter name="G_SETTINGS_BIND_SET">
+<parameter_description> Update the setting when the #GObject property changes.
+It is an error to use this flag if the property is not readable.
+</parameter_description>
+</parameter>
+<parameter name="G_SETTINGS_BIND_NO_SENSITIVITY">
+<parameter_description> Do not try to bind a "sensitivity" property to the writability of the setting
+</parameter_description>
+</parameter>
+<parameter name="G_SETTINGS_BIND_GET_NO_CHANGES">
+<parameter_description> When set in addition to #G_SETTINGS_BIND_GET, set the #GObject property
+value initially from the setting, but do not listen for changes of the setting
+</parameter_description>
+</parameter>
+<parameter name="G_SETTINGS_BIND_INVERT_BOOLEAN">
+<parameter_description> When passed to g_settings_bind(), uses a pair of mapping functions that invert
+the boolean value when mapping between the setting and the property. The setting and property must both
+be booleans. You cannot pass this flag to g_settings_bind_with_mapping().
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GSimpleAction::activate">
<description>
Indicates that the action was just activated.
<return></return>
</signal>
+<enum name="GSocketClientEvent">
+<description>
+Describes an event occurring on a #GSocketClient. See the
+#GSocketClient::event signal for more details.
+
+Additional values may be added to this type in the future.
+
+Since: 2.32
+
+</description>
+<parameters>
+<parameter name="G_SOCKET_CLIENT_RESOLVING">
+<parameter_description> The client is doing a DNS lookup.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_RESOLVED">
+<parameter_description> The client has completed a DNS lookup.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_CONNECTING">
+<parameter_description> The client is connecting to a remote
+host (either a proxy or the destination server).
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_CONNECTED">
+<parameter_description> The client has connected to a remote
+host.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_PROXY_NEGOTIATING">
+<parameter_description> The client is negotiating
+with a proxy to connect to the destination server.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_PROXY_NEGOTIATED">
+<parameter_description> The client has negotiated
+with the proxy server.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_TLS_HANDSHAKING">
+<parameter_description> The client is performing a
+TLS handshake.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_TLS_HANDSHAKED">
+<parameter_description> The client has performed a
+TLS handshake.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_CLIENT_COMPLETE">
+<parameter_description> The client is done with a particular
+#GSocketConnectable.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSocketFamily">
+<description>
+The protocol family of a #GSocketAddress. (These values are
+identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
+if available.)
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_SOCKET_FAMILY_INVALID">
+<parameter_description> no address family
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_FAMILY_IPV4">
+<parameter_description> the IPv4 family
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_FAMILY_IPV6">
+<parameter_description> the IPv6 family
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_FAMILY_UNIX">
+<parameter_description> the UNIX domain family
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSocketMsgFlags">
+<description>
+Flags used in g_socket_receive_message() and g_socket_send_message().
+The flags listed in the enum are some commonly available flags, but the
+values used for them are the same as on the platform, and any other flags
+are passed in/out as is. So to use a platform specific flag, just include
+the right system header and pass in the flag.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_SOCKET_MSG_NONE">
+<parameter_description> No flags.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_MSG_OOB">
+<parameter_description> Request to send/receive out of band data.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_MSG_PEEK">
+<parameter_description> Read data from the socket without removing it from
+the queue.
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_MSG_DONTROUTE">
+<parameter_description> Don't use a gateway to send out the packet,
+only send to hosts on directly connected networks.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSocketProtocol">
+<description>
+A protocol identifier is specified when creating a #GSocket, which is a
+family/type specific identifier, where 0 means the default protocol for
+the particular family/type.
+
+This enum contains a set of commonly available and used protocols. You
+can also pass any other identifiers handled by the platform in order to
+use protocols not listed here.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_SOCKET_PROTOCOL_UNKNOWN">
+<parameter_description> The protocol type is unknown
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_PROTOCOL_DEFAULT">
+<parameter_description> The default protocol for the family/type
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_PROTOCOL_TCP">
+<parameter_description> TCP over IP
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_PROTOCOL_UDP">
+<parameter_description> UDP over IP
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_PROTOCOL_SCTP">
+<parameter_description> SCTP over IP
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GSocketService::incoming">
<description>
The ::incoming signal is emitted when a new incoming connection
</return>
</signal>
+<enum name="GSocketType">
+<description>
+Flags used when creating a #GSocket. Some protocols may not implement
+all the socket types.
+
+Since: 2.22
+
+</description>
+<parameters>
+<parameter name="G_SOCKET_TYPE_INVALID">
+<parameter_description> Type unknown or wrong
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_TYPE_STREAM">
+<parameter_description> Reliable connection-based byte streams (e.g. TCP).
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_TYPE_DATAGRAM">
+<parameter_description> Connectionless, unreliable datagram passing.
+(e.g. UDP)
+</parameter_description>
+</parameter>
+<parameter name="G_SOCKET_TYPE_SEQPACKET">
+<parameter_description> Reliable connection-based passing of datagrams
+of fixed maximum length (e.g. SCTP).
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTestDBusFlags">
+<description>
+Flags to define future #GTestDBus behaviour.
+
+Since: 2.34
+
+</description>
+<parameters>
+<parameter name="G_TEST_DBUS_NONE">
+<parameter_description> No flags.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GThreadedSocketService::run">
<description>
The ::run signal is emitted in a worker thread in response to an
</return>
</signal>
+<enum name="GTlsAuthenticationMode">
+<description>
+The client authentication mode for a #GTlsServerConnection.
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_TLS_AUTHENTICATION_NONE">
+<parameter_description> client authentication not required
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_AUTHENTICATION_REQUESTED">
+<parameter_description> client authentication is requested
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_AUTHENTICATION_REQUIRED">
+<parameter_description> client authentication is required
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsCertificateFlags">
+<description>
+A set of flags describing TLS certification validation. This can be
+used to set which validation steps to perform (eg, with
+g_tls_client_connection_set_validation_flags()), or to describe why
+a particular certificate was rejected (eg, in
+#GTlsConnection::accept-certificate).
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_TLS_CERTIFICATE_UNKNOWN_CA">
+<parameter_description> The signing certificate authority is
+not known.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_BAD_IDENTITY">
+<parameter_description> The certificate does not match the
+expected identity of the site that it was retrieved from.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_NOT_ACTIVATED">
+<parameter_description> The certificate's activation time
+is still in the future
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_EXPIRED">
+<parameter_description> The certificate has expired
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_REVOKED">
+<parameter_description> The certificate has been revoked
+according to the #GTlsConnection's certificate revocation list.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_INSECURE">
+<parameter_description> The certificate's algorithm is
+considered insecure.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_GENERIC_ERROR">
+<parameter_description> Some other error occurred validating
+the certificate
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_CERTIFICATE_VALIDATE_ALL">
+<parameter_description> the combination of all of the above
+flags
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GTlsConnection::accept-certificate">
<description>
Emitted during the TLS handshake after the peer certificate has
</return>
</signal>
+<enum name="GTlsDatabaseLookupFlags">
+<description>
+Flags for g_tls_database_lookup_certificate_handle(),
+g_tls_database_lookup_certificate_issuer(),
+and g_tls_database_lookup_certificates_issued_by().
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_TLS_DATABASE_LOOKUP_NONE">
+<parameter_description> No lookup flags
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_DATABASE_LOOKUP_KEYPAIR">
+<parameter_description> Restrict lookup to certificates that have
+a private key.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsDatabaseVerifyFlags">
+<description>
+Flags for g_tls_database_verify_chain().
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_TLS_DATABASE_VERIFY_NONE">
+<parameter_description> No verification flags
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsError">
+<description>
+An error code used with %G_TLS_ERROR in a #GError returned from a
+TLS-related routine.
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_TLS_ERROR_UNAVAILABLE">
+<parameter_description> No TLS provider is available
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_MISC">
+<parameter_description> Miscellaneous TLS error
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_BAD_CERTIFICATE">
+<parameter_description> A certificate could not be parsed
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_NOT_TLS">
+<parameter_description> The TLS handshake failed because the
+peer does not seem to be a TLS server.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_HANDSHAKE">
+<parameter_description> The TLS handshake failed because the
+peer's certificate was not acceptable.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_CERTIFICATE_REQUIRED">
+<parameter_description> The TLS handshake failed because
+the server requested a client-side certificate, but none was
+provided. See g_tls_connection_set_certificate().
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_ERROR_EOF">
+<parameter_description> The TLS connection was closed without proper
+notice, which may indicate an attack. See
+g_tls_connection_set_require_close_notify().
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsInteractionResult">
+<description>
+#GTlsInteractionResult is returned by various functions in #GTlsInteraction
+when finishing an interaction request.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_TLS_INTERACTION_UNHANDLED">
+<parameter_description> The interaction was unhandled (i.e. not
+implemented).
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_INTERACTION_HANDLED">
+<parameter_description> The interaction completed, and resulting data
+is available.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_INTERACTION_FAILED">
+<parameter_description> The interaction has failed, or was cancelled.
+and the operation should be aborted.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsPasswordFlags">
+<description>
+Various flags for the password.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="G_TLS_PASSWORD_NONE">
+<parameter_description> No flags
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_PASSWORD_RETRY">
+<parameter_description> The password was wrong, and the user should retry.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_PASSWORD_MANY_TRIES">
+<parameter_description> Hint to the user that the password has been
+wrong many times, and the user may not have many chances left.
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_PASSWORD_FINAL_TRY">
+<parameter_description> Hint to the user that this is the last try to get
+this password right.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTlsRehandshakeMode">
+<description>
+When to allow rehandshaking. See
+g_tls_connection_set_rehandshake_mode().
+
+Since: 2.28
+
+</description>
+<parameters>
+<parameter name="G_TLS_REHANDSHAKE_NEVER">
+<parameter_description> Never allow rehandshaking
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_REHANDSHAKE_SAFELY">
+<parameter_description> Allow safe rehandshaking only
+</parameter_description>
+</parameter>
+<parameter name="G_TLS_REHANDSHAKE_UNSAFELY">
+<parameter_description> Allow unsafe rehandshaking
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GUnixMountMonitor::mountpoints-changed">
<description>
Emitted when the unix mount points have changed.
<return></return>
</signal>
+<enum name="GUnixSocketAddressType">
+<description>
+The type of name used by a #GUnixSocketAddress.
+%G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
+socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
+indicates a socket not bound to any name (eg, a client-side socket,
+or a socket created with socketpair()).
+
+For abstract sockets, there are two incompatible ways of naming
+them; the man pages suggest using the entire <literal>struct
+sockaddr_un</literal> as the name, padding the unused parts of the
+%sun_path field with zeroes; this corresponds to
+%G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED. However, many programs
+instead just use a portion of %sun_path, and pass an appropriate
+smaller length to bind() or connect(). This is
+%G_UNIX_SOCKET_ADDRESS_ABSTRACT.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_UNIX_SOCKET_ADDRESS_INVALID">
+<parameter_description> invalid
+</parameter_description>
+</parameter>
+<parameter name="G_UNIX_SOCKET_ADDRESS_ANONYMOUS">
+<parameter_description> anonymous
+</parameter_description>
+</parameter>
+<parameter name="G_UNIX_SOCKET_ADDRESS_PATH">
+<parameter_description> a filesystem path
+</parameter_description>
+</parameter>
+<parameter name="G_UNIX_SOCKET_ADDRESS_ABSTRACT">
+<parameter_description> an abstract name
+</parameter_description>
+</parameter>
+<parameter name="G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED">
+<parameter_description> an abstract name, 0-padded
+to the full length of a unix socket name
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GVolume::changed">
<description>
Emitted when the volume has been changed.
<return></return>
</signal>
+<enum name="GZlibCompressorFormat">
+<description>
+Used to select the type of data format to use for #GZlibDecompressor
+and #GZlibCompressor.
+
+Since: 2.24
+
+</description>
+<parameters>
+<parameter name="G_ZLIB_COMPRESSOR_FORMAT_ZLIB">
+<parameter_description> deflate compression with zlib header
+</parameter_description>
+</parameter>
+<parameter name="G_ZLIB_COMPRESSOR_FORMAT_GZIP">
+<parameter_description> gzip file format
+</parameter_description>
+</parameter>
+<parameter name="G_ZLIB_COMPRESSOR_FORMAT_RAW">
+<parameter_description> deflate compression with no header
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<function name="example_animal_call_poke">
<description>
Asynchronously invokes the <link linkend="gdbus-method-org-gtk-GDBus-Example-ObjectManager-Animal.Poke">Poke()</link> D-Bus method on @proxy.
<return></return>
</function>
+<function name="example_animal_dup_bar">
+<description>
+Gets a copy of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Bar">"Bar"</link> D-Bus property.
+
+Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The property value or %NULL if the property is not set. The returned value should be freed with g_free().
+
+</return>
+</function>
+
+<function name="example_animal_dup_foo">
+<description>
+Gets a copy of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Foo">"Foo"</link> D-Bus property.
+
+Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The property value or %NULL if the property is not set. The returned value should be freed with g_free().
+
+</return>
+</function>
+
<function name="example_animal_dup_mood">
<description>
Gets a copy of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Mood">"Mood"</link> D-Bus property.
<return></return>
</function>
+<function name="example_animal_get_bar">
+<description>
+Gets the value of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Bar">"Bar"</link> D-Bus property.
+
+Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
+
+<warning>The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use example_animal_dup_bar() if on another thread.</warning>
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
+
+</return>
+</function>
+
+<function name="example_animal_get_foo">
+<description>
+Gets the value of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Foo">"Foo"</link> D-Bus property.
+
+Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
+
+<warning>The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use example_animal_dup_foo() if on another thread.</warning>
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
+
+</return>
+</function>
+
<function name="example_animal_get_mood">
<description>
Gets the value of the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Mood">"Mood"</link> D-Bus property.
</return>
</function>
+<function name="example_animal_set_bar">
+<description>
+Sets the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Bar">"Bar"</link> D-Bus property to @value.
+
+Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+<parameter name="value">
+<parameter_description> The value to set.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="example_animal_set_foo">
+<description>
+Sets the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Foo">"Foo"</link> D-Bus property to @value.
+
+Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
+
+Since: 2.30
+
+</description>
+<parameters>
+<parameter name="object">
+<parameter_description> A #ExampleAnimal.
+</parameter_description>
+</parameter>
+<parameter name="value">
+<parameter_description> The value to set.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="example_animal_set_mood">
<description>
Sets the <link linkend="gdbus-property-org-gtk-GDBus-Example-ObjectManager-Animal.Mood">"Mood"</link> D-Bus property to @value.
<description>
Gets a machine-readable description of the <link linkend="gdbus-interface-ChangingInterfaceV10.top_of_page">ChangingInterfaceV10</link> D-Bus interface.
-Since: 10.0
</description>
<parameters>
</parameters>
<return> A #GDBusInterfaceInfo. Do not free.
-
</return>
</function>
Overrides all #GObject properties in the #FooiGenChangingInterfaceV10 interface for a concrete class.
The properties are overridden in the order they are defined.
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> The last property id.
-
</return>
</function>
See foo_igen_changing_interface_v10_proxy_new_sync() for the synchronous, blocking version of this constructor.
-Since: 10.0
-
</description>
<parameters>
<parameter name="connection">
<description>
Finishes an operation started with foo_igen_changing_interface_v10_proxy_new().
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v10_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
-Since: 10.0
-
</description>
<parameters>
<parameter name="bus_type">
<description>
Finishes an operation started with foo_igen_changing_interface_v10_proxy_new_for_bus().
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v10_proxy_new_for_bus() for the asynchronous version of this constructor.
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v10_proxy_new() for the asynchronous version of this constructor.
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
<description>
Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV10.top_of_page">ChangingInterfaceV10</link>.
-Since: 10.0
</description>
<parameters>
</parameters>
<return> The skeleton object.
-
</return>
</function>
<description>
Gets a machine-readable description of the <link linkend="gdbus-interface-ChangingInterfaceV2.top_of_page">ChangingInterfaceV2</link> D-Bus interface.
-Since: 2.0
</description>
<parameters>
</parameters>
<return> A #GDBusInterfaceInfo. Do not free.
-
</return>
</function>
Overrides all #GObject properties in the #FooiGenChangingInterfaceV2 interface for a concrete class.
The properties are overridden in the order they are defined.
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> The last property id.
-
</return>
</function>
See foo_igen_changing_interface_v2_proxy_new_sync() for the synchronous, blocking version of this constructor.
-Since: 2.0
-
</description>
<parameters>
<parameter name="connection">
<description>
Finishes an operation started with foo_igen_changing_interface_v2_proxy_new().
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v2_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
-Since: 2.0
-
</description>
<parameters>
<parameter name="bus_type">
<description>
Finishes an operation started with foo_igen_changing_interface_v2_proxy_new_for_bus().
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v2_proxy_new_for_bus() for the asynchronous version of this constructor.
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
See foo_igen_changing_interface_v2_proxy_new() for the asynchronous version of this constructor.
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> The constructed proxy object or %NULL if @error is set.
-
</return>
</function>
<description>
Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV2.top_of_page">ChangingInterfaceV2</link>.
-Since: 2.0
</description>
<parameters>
</parameters>
<return> The skeleton object.
-
</return>
</function>
<description>
Gets the #FooiGenChangingInterfaceV10 instance for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV10.top_of_page">ChangingInterfaceV10</link> on @object, if any.
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> A #FooiGenChangingInterfaceV10 that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
-
</return>
</function>
<description>
Gets the #FooiGenChangingInterfaceV2 instance for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV2.top_of_page">ChangingInterfaceV2</link> on @object, if any.
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> A #FooiGenChangingInterfaceV2 that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
-
</return>
</function>
<warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
-Since: 10.0
</description>
<parameters>
</parameter>
</parameters>
<return> A #FooiGenChangingInterfaceV10 or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
-
</return>
</function>
<warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
-Since: 2.0
</description>
<parameters>
</parameter>
</parameters>
<return> A #FooiGenChangingInterfaceV2 or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
-
</return>
</function>
<description>
Sets the #FooiGenChangingInterfaceV10 instance for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV10.top_of_page">ChangingInterfaceV10</link> on @object.
-Since: 10.0
-
</description>
<parameters>
<parameter name="object">
<description>
Sets the #FooiGenChangingInterfaceV2 instance for the D-Bus interface <link linkend="gdbus-interface-ChangingInterfaceV2.top_of_page">ChangingInterfaceV2</link> on @object.
-Since: 2.0
-
</description>
<parameters>
<parameter name="object">
<description>
Creates a new #GApplication instance.
-This function calls g_type_init() for you.
-
If non-%NULL, the application id must be valid. See
g_application_id_is_valid().
<description>
Looks up the value of an annotation.
-This cost of this function is O(n) in number of annotations.
+The cost of this function is O(n) in number of annotations.
Since: 2.26
<description>
Looks up information about a method.
-This cost of this function is O(n) in number of methods unless
+The cost of this function is O(n) in number of methods unless
g_dbus_interface_info_cache_build() has been used on @info.
Since: 2.26
<description>
Looks up information about a property.
-This cost of this function is O(n) in number of properties unless
+The cost of this function is O(n) in number of properties unless
g_dbus_interface_info_cache_build() has been used on @info.
Since: 2.26
<description>
Looks up information about a signal.
-This cost of this function is O(n) in number of signals unless
+The cost of this function is O(n) in number of signals unless
g_dbus_interface_info_cache_build() has been used on @info.
Since: 2.26
<function name="g_dbus_interface_skeleton_has_connection">
<description>
-Checks if @interface_ is export on @connection.
+Checks if @interface_ is exported on @connection.
Since: 2.32
<description>
Looks up information about an interface.
-This cost of this function is O(n) in number of interfaces.
+The cost of this function is O(n) in number of interfaces.
Since: 2.26
<function name="g_dbus_object_manager_client_get_name">
<description>
-Gets the name that @manager is for.
+Gets the name that @manager is for, or %NULL if not a message bus
+connection.
Since: 2.30
</parameter_description>
</parameter>
<parameter name="name">
-<parameter_description> The owner of the control object (unique or well-known name).
+<parameter_description> The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
</parameter_description>
</parameter>
<parameter name="object_path">
</parameter_description>
</parameter>
<parameter name="io_priority">
-<parameter_description> the <link linkend="gioscheduler">io priority</link>
+<parameter_description> the <link linkend="io-priority">io priority</link>
of the request.
</parameter_description>
</parameter>
</return>
</function>
+<function name="g_io_module_load">
+<description>
+Required API for GIO modules to implement.
+This function is ran after the module has been loaded into GIO,
+to initialize the module.
+
+</description>
+<parameters>
+<parameter name="module">
+<parameter_description> a #GIOModule.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_io_module_new">
<description>
Creates a new GIOModule that will load the specific
</return>
</function>
+<function name="g_io_module_query">
+<description>
+Optional API for GIO modules to implement.
+
+Should return a list of all the extension points that may be
+implemented in this module.
+
+This method will not be called in normal use, however it may be
+called when probing existing modules and recording which extension
+points that this model is used for. This means we won't have to
+load and initialze this module unless its needed.
+
+If this function is not implemented by the module the module will
+always be loaded, initialized and then unloaded on application startup
+so that it can register its extension points during init.
+
+Note that a module need not actually implement all the extension points
+that g_io_module_query returns, since the exact list of extension may
+depend on runtime issues. However all extension points actually implemented
+must be returned by g_io_module_query() (if defined).
+
+When installing a module that implements g_io_module_query you must
+run gio-querymodules in order to build the cache files required for
+lazy loading.
+
+Since: 2.24
+
+</description>
+<parameters>
+</parameters>
+<return> A %NULL-terminated array of strings, listing the supported
+extension points of the module. The array must be suitable for
+freeing with g_strfreev().
+
+</return>
+</function>
+
<function name="g_io_module_scope_block">
<description>
Block modules with the given @basename from being loaded when
</return>
</function>
+<function name="g_io_module_unload">
+<description>
+Required API for GIO modules to implement.
+This function is ran when the module is being unloaded from GIO,
+to finalize the module.
+
+</description>
+<parameters>
+<parameter name="module">
+<parameter_description> a #GIOModule.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_io_modules_load_all_in_directory">
<description>
Loads all the modules in the specified directory.
A job is cancellable if a #GCancellable was passed into
g_io_scheduler_push_job().
+Deprecated: You should never call this function, since you don't
+know how other libraries in your program might be making use of
+gioscheduler.
+
</description>
<parameters>
</parameters>
that the job was started from, waiting for the result (and thus
blocking the I/O job).
+Deprecated: Use g_main_context_invoke().
</description>
<parameters>
</parameter>
</parameters>
<return> The return value of @func
+
</return>
</function>
@func is called, either by passing %NULL as @notify to
g_io_scheduler_push_job() or by using refcounting for @user_data.
+Deprecated: Use g_main_context_invoke().
+
</description>
<parameters>
<parameter name="job">
by calling g_cancellable_cancel() or by calling
g_io_scheduler_cancel_all_jobs().
+Deprecated: use #GThreadPool or g_task_run_in_thread()
+
</description>
<parameters>
<parameter name="job_func">
</parameter_description>
</parameter>
<parameter name="io_priority">
-<parameter_description> the <link linkend="gioscheduler">I/O priority</link>
+<parameter_description> the <link linkend="io-priority">I/O priority</link>
of the request.
</parameter_description>
</parameter>
<return></return>
</function>
+<function name="g_task_attach_source">
+<description>
+A utility function for dealing with async operations where you need
+to wait for a #GSource to trigger. Attaches @source to @task's
+#GMainContext with @task's <link
+linkend="io-priority">priority</link>, and sets @source's callback
+to @callback, with @task as the callback's
+<literal>user_data</literal>.
+
+This takes a reference on @task until @source is destroyed.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+<parameter name="source">
+<parameter_description> the source to attach
+</parameter_description>
+</parameter>
+<parameter name="callback">
+<parameter_description> the callback to invoke when @source triggers
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_get_cancellable">
+<description>
+Gets @task's #GCancellable
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's #GCancellable
+
+</return>
+</function>
+
+<function name="g_task_get_check_cancellable">
+<description>
+Gets @task's check-cancellable flag. See
+g_task_set_check_cancellable() for more details.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_get_context">
+<description>
+Gets the #GMainContext that @task will return its result in (that
+is, the context that was the <link
+linkend="g-main-context-push-thread-default">thread-default main
+context</link> at the point when @task was created).
+
+This will always return a non-%NULL value, even if the task's
+context is the default #GMainContext.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's #GMainContext
+
+</return>
+</function>
+
+<function name="g_task_get_priority">
+<description>
+Gets @task's priority
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's priority
+
+</return>
+</function>
+
+<function name="g_task_get_return_on_cancel">
+<description>
+Gets @task's return-on-cancel flag. See
+g_task_set_return_on_cancel() for more details.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_get_source_object">
+<description>
+Gets the source object from @task. Like
+g_async_result_get_source_object(), but does not ref the object.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's source object, or %NULL
+
+</return>
+</function>
+
+<function name="g_task_get_source_tag">
+<description>
+Gets @task's source tag. See g_task_set_source_tag().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's source tag
+
+</return>
+</function>
+
+<function name="g_task_get_task_data">
+<description>
+Gets @task's <literal>task_data</literal>.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> @task's <literal>task_data</literal>.
+
+</return>
+</function>
+
+<function name="g_task_had_error">
+<description>
+Tests if @task resulted in an error.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if the task resulted in an error, %FALSE otherwise.
+
+</return>
+</function>
+
+<function name="g_task_is_valid">
+<description>
+Checks that @result is a #GTask, and that @source_object is its
+source object (or that @source_object is %NULL and @result has no
+source object). This can be used in g_return_if_fail() checks.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="result">
+<parameter_description> A #GAsyncResult
+</parameter_description>
+</parameter>
+<parameter name="source_object">
+<parameter_description> the source object expected to be
+associated with the task
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if @result and @source_object are valid, %FALSE
+if not
+
+</return>
+</function>
+
+<function name="g_task_new">
+<description>
+Creates a #GTask acting on @source_object, which will eventually be
+used to invoke @callback in the current <link
+linkend="g-main-context-push-thread-default">thread-default main
+context</link>.
+
+Call this in the "start" method of your asynchronous method, and
+pass the #GTask around throughout the asynchronous operation. You
+can use g_task_set_task_data() to attach task-specific data to the
+object, which you can retrieve later via g_task_get_task_data().
+
+By default, if @cancellable is cancelled, then the return value of
+the task will always be %G_IO_ERROR_CANCELLED, even if the task had
+already completed before the cancellation. This allows for
+simplified handling in cases where cancellation may imply that
+other objects that the task depends on have been destroyed. If you
+do not want this behavior, you can use
+g_task_set_check_cancellable() to change it.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="source_object">
+<parameter_description> the #GObject that owns this task, or %NULL.
+</parameter_description>
+</parameter>
+<parameter name="cancellable">
+<parameter_description> optional #GCancellable object, %NULL to ignore.
+</parameter_description>
+</parameter>
+<parameter name="callback">
+<parameter_description> a #GAsyncReadyCallback.
+</parameter_description>
+</parameter>
+<parameter name="callback_data">
+<parameter_description> user data passed to @callback.
+</parameter_description>
+</parameter>
+</parameters>
+<return> a #GTask.
+
+</return>
+</function>
+
+<function name="g_task_propagate_boolean">
+<description>
+Gets the result of @task as a #gboolean.
+
+If the task resulted in an error, or was cancelled, then this will
+instead return %FALSE and set @error.
+
+Since this method transfers ownership of the return value (or
+error) to the caller, you may only call it once.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="error">
+<parameter_description> return location for a #GError
+</parameter_description>
+</parameter>
+</parameters>
+<return> the task result, or %FALSE on error
+
+</return>
+</function>
+
+<function name="g_task_propagate_int">
+<description>
+Gets the result of @task as an integer (#gssize).
+
+If the task resulted in an error, or was cancelled, then this will
+instead return -1 and set @error.
+
+Since this method transfers ownership of the return value (or
+error) to the caller, you may only call it once.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="error">
+<parameter_description> return location for a #GError
+</parameter_description>
+</parameter>
+</parameters>
+<return> the task result, or -1 on error
+
+</return>
+</function>
+
+<function name="g_task_propagate_pointer">
+<description>
+Gets the result of @task as a pointer, and transfers ownership
+of that value to the caller.
+
+If the task resulted in an error, or was cancelled, then this will
+instead return %NULL and set @error.
+
+Since this method transfers ownership of the return value (or
+error) to the caller, you may only call it once.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+<parameter name="error">
+<parameter_description> return location for a #GError
+</parameter_description>
+</parameter>
+</parameters>
+<return> the task result, or %NULL on error
+
+</return>
+</function>
+
+<function name="g_task_report_error">
+<description>
+Creates a #GTask and then immediately calls g_task_return_error()
+on it. Use this in the wrapper function of an asynchronous method
+when you want to avoid even calling the virtual method. You can
+then use g_async_result_is_tagged() in the finish method wrapper to
+check if the result there is tagged as having been created by the
+wrapper method, and deal with it appropriately if so.
+
+See also g_task_report_new_error().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="source_object">
+<parameter_description> the #GObject that owns this task, or %NULL.
+</parameter_description>
+</parameter>
+<parameter name="callback">
+<parameter_description> a #GAsyncReadyCallback.
+</parameter_description>
+</parameter>
+<parameter name="callback_data">
+<parameter_description> user data passed to @callback.
+</parameter_description>
+</parameter>
+<parameter name="source_tag">
+<parameter_description> an opaque pointer indicating the source of this task
+</parameter_description>
+</parameter>
+<parameter name="error">
+<parameter_description> error to report
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_report_new_error">
+<description>
+Creates a #GTask and then immediately calls
+g_task_return_new_error() on it. Use this in the wrapper function
+of an asynchronous method when you want to avoid even calling the
+virtual method. You can then use g_async_result_is_tagged() in the
+finish method wrapper to check if the result there is tagged as
+having been created by the wrapper method, and deal with it
+appropriately if so.
+
+See also g_task_report_error().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="source_object">
+<parameter_description> the #GObject that owns this task, or %NULL.
+</parameter_description>
+</parameter>
+<parameter name="callback">
+<parameter_description> a #GAsyncReadyCallback.
+</parameter_description>
+</parameter>
+<parameter name="callback_data">
+<parameter_description> user data passed to @callback.
+</parameter_description>
+</parameter>
+<parameter name="source_tag">
+<parameter_description> an opaque pointer indicating the source of this task
+</parameter_description>
+</parameter>
+<parameter name="domain">
+<parameter_description> a #GQuark.
+</parameter_description>
+</parameter>
+<parameter name="code">
+<parameter_description> an error code.
+</parameter_description>
+</parameter>
+<parameter name="format">
+<parameter_description> a string with format characters.
+</parameter_description>
+</parameter>
+<parameter name="Varargs">
+<parameter_description> a list of values to insert into @format.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_return_boolean">
+<description>
+Sets @task's result to @result and completes the task (see
+g_task_return_pointer() for more discussion of exactly what this
+means).
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="result">
+<parameter_description> the #gboolean result of a task function.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_return_error">
+<description>
+Sets @task's result to @error (which @task assumes ownership of)
+and completes the task (see g_task_return_pointer() for more
+discussion of exactly what this means).
+
+Note that since the task takes ownership of @error, and since the
+task may be completed before returning from g_task_return_error(),
+you cannot assume that @error is still valid after calling this.
+Call g_error_copy() on the error if you need to keep a local copy
+as well.
+
+See also g_task_return_new_error().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="error">
+<parameter_description> the #GError result of a task function.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_return_error_if_cancelled">
+<description>
+Checks if @task's #GCancellable has been cancelled, and if so, sets
+@task's error accordingly and completes the task (see
+g_task_return_pointer() for more discussion of exactly what this
+means).
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if @task has been cancelled, %FALSE if not
+
+</return>
+</function>
+
+<function name="g_task_return_int">
+<description>
+Sets @task's result to @result and completes the task (see
+g_task_return_pointer() for more discussion of exactly what this
+means).
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="result">
+<parameter_description> the integer (#gssize) result of a task function.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_return_new_error">
+<description>
+Sets @task's result to a new #GError created from @domain, @code,
+@format, and the remaining arguments, and completes the task (see
+g_task_return_pointer() for more discussion of exactly what this
+means).
+
+See also g_task_return_error().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask.
+</parameter_description>
+</parameter>
+<parameter name="domain">
+<parameter_description> a #GQuark.
+</parameter_description>
+</parameter>
+<parameter name="code">
+<parameter_description> an error code.
+</parameter_description>
+</parameter>
+<parameter name="format">
+<parameter_description> a string with format characters.
+</parameter_description>
+</parameter>
+<parameter name="Varargs">
+<parameter_description> a list of values to insert into @format.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_return_pointer">
+<description>
+Sets @task's result to @result and completes the task. If @result
+is not %NULL, then @result_destroy will be used to free @result if
+the caller does not take ownership of it with
+g_task_propagate_pointer().
+
+"Completes the task" means that for an ordinary asynchronous task
+it will either invoke the task's callback, or else queue that
+callback to be invoked in the proper #GMainContext, or in the next
+iteration of the current #GMainContext. For a task run via
+g_task_run_in_thread() or g_task_run_in_thread_sync(), calling this
+method will save @result to be returned to the caller later, but
+the task will not actually be completed until the #GTaskThreadFunc
+exits.
+
+Note that since the task may be completed before returning from
+g_task_return_pointer(), you cannot assume that @result is still
+valid after calling this, unless you are still holding another
+reference on it.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+<parameter name="result">
+<parameter_description> the pointer result of a task
+function
+</parameter_description>
+</parameter>
+<parameter name="result_destroy">
+<parameter_description> a #GDestroyNotify function.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_run_in_thread">
+<description>
+Runs @task_func in another thread. When @task_func returns, @task's
+#GAsyncReadyCallback will be invoked in @task's #GMainContext.
+
+This takes a ref on @task until the task completes.
+
+See #GTaskThreadFunc for more details about how @task_func is handled.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+<parameter name="task_func">
+<parameter_description> a #GTaskThreadFunc
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_run_in_thread_sync">
+<description>
+Runs @task_func in another thread, and waits for it to return or be
+cancelled. You can use g_task_propagate_pointer(), etc, afterward
+to get the result of @task_func.
+
+See #GTaskThreadFunc for more details about how @task_func is handled.
+
+Normally this is used with tasks created with a %NULL
+<literal>callback</literal>, but note that even if the task does
+have a callback, it will not be invoked when @task_func returns.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> a #GTask
+</parameter_description>
+</parameter>
+<parameter name="task_func">
+<parameter_description> a #GTaskThreadFunc
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_set_check_cancellable">
+<description>
+Sets or clears @task's check-cancellable flag. If this is %TRUE
+(the default), then g_task_propagate_pointer(), etc, and
+g_task_had_error() will check the task's #GCancellable first, and
+if it has been cancelled, then they will consider the task to have
+returned an "Operation was cancelled" error
+(%G_IO_ERROR_CANCELLED), regardless of any other error or return
+value the task may have had.
+
+If @check_cancellable is %FALSE, then the #GTask will not check the
+cancellable itself, and it is up to @task's owner to do this (eg,
+via g_task_return_error_if_cancelled()).
+
+If you are using g_task_set_return_on_cancel() as well, then
+you must leave check-cancellable set %TRUE.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+<parameter name="check_cancellable">
+<parameter_description> whether #GTask will check the state of
+its #GCancellable for you.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_set_priority">
+<description>
+Sets @task's priority. If you do not call this, it will default to
+%G_PRIORITY_DEFAULT.
+
+This will affect the priority of #GSources created with
+g_task_attach_source() and the scheduling of tasks run in threads,
+and can also be explicitly retrieved later via
+g_task_get_priority().
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+<parameter name="priority">
+<parameter_description> the <link linkend="io-priority">priority</link>
+of the request.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_set_return_on_cancel">
+<description>
+Sets or clears @task's return-on-cancel flag. This is only
+meaningful for tasks run via g_task_run_in_thread() or
+g_task_run_in_thread_sync().
+
+If @return_on_cancel is %TRUE, then cancelling @task's
+#GCancellable will immediately cause it to return, as though the
+task's #GTaskThreadFunc had called
+g_task_return_error_if_cancelled() and then returned.
+
+This allows you to create a cancellable wrapper around an
+uninterruptable function. The #GTaskThreadFunc just needs to be
+careful that it does not modify any externally-visible state after
+it has been cancelled. To do that, the thread should call
+g_task_set_return_on_cancel() again to (atomically) set
+return-on-cancel %FALSE before making externally-visible changes;
+if the task gets cancelled before the return-on-cancel flag could
+be changed, g_task_set_return_on_cancel() will indicate this by
+returning %FALSE.
+
+You can disable and re-enable this flag multiple times if you wish.
+If the task's #GCancellable is cancelled while return-on-cancel is
+%FALSE, then calling g_task_set_return_on_cancel() to set it %TRUE
+again will cause the task to be cancelled at that point.
+
+If the task's #GCancellable is already cancelled before you call
+g_task_run_in_thread()/g_task_run_in_thread_sync(), then the
+#GTaskThreadFunc will still be run (for consistency), but the task
+will also be completed right away.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+<parameter name="return_on_cancel">
+<parameter_description> whether the task returns automatically when
+it is cancelled.
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if @task's return-on-cancel flag was changed to
+match @return_on_cancel. %FALSE if @task has already been
+cancelled.
+
+</return>
+</function>
+
+<function name="g_task_set_source_tag">
+<description>
+Sets @task's source tag. You can use this to tag a task return
+value with a particular pointer (usually a pointer to the function
+doing the tagging) and then later check it using
+g_task_get_source_tag() (or g_async_result_is_tagged()) in the
+task's "finish" function, to figure out if the response came from a
+particular place.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+<parameter name="source_tag">
+<parameter_description> an opaque pointer indicating the source of this task
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_task_set_task_data">
+<description>
+Sets @task's task data (freeing the existing task data, if any).
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="task">
+<parameter_description> the #GTask
+</parameter_description>
+</parameter>
+<parameter name="task_data">
+<parameter_description> task-specific data
+</parameter_description>
+</parameter>
+<parameter name="task_data_destroy">
+<parameter_description> #GDestroyNotify for @task_data
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_tcp_connection_get_graceful_disconnect">
<description>
Checks if graceful disconnects are used. See
<function name="g_test_dbus_up">
<description>
Start a dbus-daemon instance and set DBUS_SESSION_BUS_ADDRESS. After this
-call, it is safe for unit tests to start sending messages on the session bug.
+call, it is safe for unit tests to start sending messages on the session bus.
If this function is called from setup callback of g_test_add(),
g_test_dbus_down() must be called in its teardown callback.
This call is equivalent to gvdb_table_get_value() except that it
never byteswaps the value.
+
</description>
<parameters>
<parameter name="table">
You should call gvdb_table_unref() on the return result when you no
longer require it.
+
</description>
<parameters>
<parameter name="file">
You should call g_variant_unref() on the return result when you no
longer require it.
+
</description>
<parameters>
<parameter name="file">
Note: this function does not consider non-value nodes (other hash
tables, for example).
+
</description>
<parameters>
<parameter name="file">
has been replaced. The appropriate action is typically to reopen the
file.
+
</description>
<parameters>
<parameter name="table">
You should call g_strfreev() on the return result when you no longer
require it.
+
</description>
<parameters>
<parameter name="file">
You should call gvdb_table_unref() on the return result when you no
longer require it.
+
</description>
<parameters>
<parameter name="filename">
You should call gvdb_table_unref() on the return result when you no
longer require it.
+
</description>
<parameters>
<parameter name="data">
<description>
Increases the reference count on @file.
+
</description>
<parameters>
<parameter name="file">
implementations to find the underlying mount to shadow, see
g_mount_is_shadowed() for more details.
-
+Since: 2.18
</description>
<parameters>
<parameter name="volume">
</parameters>
<return> the activation root of @volume or %NULL. Use
g_object_unref() to free.
-
-Since: 2.18
</return>
</function>
(c-name "GSimpleAction")
(gtype-id "G_TYPE_SIMPLE_ACTION")
)
+
+(define-object TlsClientConnection
+ (in-module "Gio")
+ (c-name "GTlsClientConnection")
+ (gtype-id "G_TYPE_TLS_CLIENT_CONNECTION")
+)
(construct-only #f)
)
+;; From GTlsBackend
+
+;; From GTlsCertificate
+
+(define-property certificate
+ (of-object "GTlsCertificate")
+ (prop-type "GParamBoxed")
+ (docs "The DER representation of the certificate")
+ (readable #t)
+ (writable #t)
+ (construct-only #t)
+)
+
+(define-property certificate-pem
+ (of-object "GTlsCertificate")
+ (prop-type "GParamString")
+ (docs "The PEM representation of the certificate")
+ (readable #t)
+ (writable #t)
+ (construct-only #t)
+)
+
+(define-property private-key
+ (of-object "GTlsCertificate")
+ (prop-type "GParamBoxed")
+ (docs "The DER representation of the certificate's private key")
+ (readable #f)
+ (writable #t)
+ (construct-only #t)
+)
+
+(define-property private-key-pem
+ (of-object "GTlsCertificate")
+ (prop-type "GParamString")
+ (docs "The PEM representation of the certificate's private key")
+ (readable #f)
+ (writable #t)
+ (construct-only #t)
+)
+
+(define-property issuer
+ (of-object "GTlsCertificate")
+ (prop-type "GParamObject")
+ (docs "The certificate for the issuing entity")
+ (readable #t)
+ (writable #t)
+ (construct-only #t)
+)
+
+;; From GTlsClientConnection
+
+(define-property accepted-cas
+ (of-object "GTlsClientConnection")
+ (prop-type "GParamPointer")
+ (docs "Distinguished names of the CAs the server accepts certificates from")
+ (readable #t)
+ (writable #f)
+ (construct-only #f)
+)
+
+(define-property server-identity
+ (of-object "GTlsClientConnection")
+ (prop-type "GParamObject")
+ (docs "GSocketConnectable identifying the server")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property use-ssl3
+ (of-object "GTlsClientConnection")
+ (prop-type "GParamBoolean")
+ (docs "Use SSL 3.0 rather than trying to use TLS 1.x")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property validation-flags
+ (of-object "GTlsClientConnection")
+ (prop-type "GParamFlags")
+ (docs "What certificate validation to perform")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+;; From GTlsConnection
+
+(define-signal accept-certificate
+ (of-object "GTlsConnection")
+ (return-type "gboolean")
+ (when "last")
+ (parameters
+ '("GTlsCertificate*" "p0")
+ '("GTlsCertificateFlags" "p1")
+ )
+)
+
+(define-property base-io-stream
+ (of-object "GTlsConnection")
+ (prop-type "GParamObject")
+ (docs "The GIOStream that the connection wraps")
+ (readable #t)
+ (writable #t)
+ (construct-only #t)
+)
+
+(define-property require-close-notify
+ (of-object "GTlsConnection")
+ (prop-type "GParamBoolean")
+ (docs "Whether to require proper TLS close notification")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property rehandshake-mode
+ (of-object "GTlsConnection")
+ (prop-type "GParamEnum")
+ (docs "When to allow rehandshaking")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property use-system-certdb
+ (of-object "GTlsConnection")
+ (prop-type "GParamBoolean")
+ (docs "Whether to verify peer certificates against the system certificate database")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property database
+ (of-object "GTlsConnection")
+ (prop-type "GParamObject")
+ (docs "Certificate database to use for looking up or verifying certificates")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property interaction
+ (of-object "GTlsConnection")
+ (prop-type "GParamObject")
+ (docs "Optional object for user interaction")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property certificate
+ (of-object "GTlsConnection")
+ (prop-type "GParamObject")
+ (docs "The connection's certificate")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property peer-certificate
+ (of-object "GTlsConnection")
+ (prop-type "GParamObject")
+ (docs "The connection's peer's certificate")
+ (readable #t)
+ (writable #f)
+ (construct-only #f)
+)
+
+(define-property peer-certificate-errors
+ (of-object "GTlsConnection")
+ (prop-type "GParamFlags")
+ (docs "Errors found with the peer's certificate")
+ (readable #t)
+ (writable #f)
+ (construct-only #f)
+)
+
+;; From GTlsDatabase
+
+;; From GTlsFileDatabase
+
+(define-property anchors
+ (of-object "GTlsFileDatabase")
+ (prop-type "GParamString")
+ (docs "The certificate authority anchor file")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+;; From GTlsInteraction
+
+;; From GTlsPassword
+
+(define-property flags
+ (of-object "GTlsPassword")
+ (prop-type "GParamFlags")
+ (docs "Flags about the password")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property description
+ (of-object "GTlsPassword")
+ (prop-type "GParamString")
+ (docs "Description of what the password is for")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+(define-property warning
+ (of-object "GTlsPassword")
+ (prop-type "GParamString")
+ (docs "Warning about the password")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
+;; From GTlsServerConnection
+
+(define-property authentication-mode
+ (of-object "GTlsServerConnection")
+ (prop-type "GParamEnum")
+ (docs "The client authentication mode")
+ (readable #t)
+ (writable #t)
+ (construct-only #f)
+)
+
;; From GUnixConnection
;; From GSocketListener
)
)
+; GTlsConnection
+
+(define-vfunc handshake
+ (of-object "GTlsConnection")
+ (return-type "gboolean")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc handshake_async
+ (of-object "GTlsConnection")
+ (return-type "void")
+ (parameters
+ '("int" "io_priority")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc handshake_finish
+ (of-object "GTlsConnection")
+ (return-type "gboolean")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+; GTlsDatabase
+
+(define-vfunc verify_chain
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificateFlags")
+ (parameters
+ '("GTlsCertificate*" "chain")
+ '("const-gchar*" "purpose")
+ '("GSocketConnectable*" "identity")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseVerifyFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc verify_chain_async
+ (of-object "GTlsDatabase")
+ (return-type "void")
+ (parameters
+ '("GTlsCertificate*" "chain")
+ '("const-gchar*" "purpose")
+ '("GSocketConnectable*" "identity")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseVerifyFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc verify_chain_finish
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificateFlags")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc create_certificate_handle
+ (of-object "GTlsDatabase")
+ (return-type "gchar*")
+ (parameters
+ '("GTlsCertificate*" "certificate")
+ )
+)
+
+(define-vfunc lookup_certificate_for_handle
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificate*")
+ (parameters
+ '("const-gchar*" "handle")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc lookup_certificate_for_handle_async
+ (of-object "GTlsDatabase")
+ (return-type "void")
+ (parameters
+ '("const-gchar*" "handle")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc lookup_certificate_for_handle_finish
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificate*")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc lookup_certificate_issuer
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificate*")
+ (parameters
+ '("GTlsCertificate*" "certificate")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc lookup_certificate_issuer_async
+ (of-object "GTlsDatabase")
+ (return-type "void")
+ (parameters
+ '("GTlsCertificate*" "certificate")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc lookup_certificate_issuer_finish
+ (of-object "GTlsDatabase")
+ (return-type "GTlsCertificate*")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc lookup_certificates_issued_by
+ (of-object "GTlsDatabase")
+ (return-type "GList*")
+ (parameters
+ '("GByteArray*" "issuer_raw_dn")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc lookup_certificates_issued_by_async
+ (of-object "GTlsDatabase")
+ (return-type "void")
+ (parameters
+ '("GByteArray*" "issuer_raw_dn")
+ '("GTlsInteraction*" "interaction")
+ '("GTlsDatabaseLookupFlags" "flags")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc lookup_certificates_issued_by_finish
+ (of-object "GTlsDatabase")
+ (return-type "GList*")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+; GTlsInteraction
+
+(define-vfunc ask_password
+ (of-object "GTlsInteraction")
+ (return-type "GTlsInteractionResult")
+ (parameters
+ '("GTlsPassword*" "password")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-vfunc ask_password_async
+ (of-object "GTlsInteraction")
+ (return-type "void")
+ (parameters
+ '("GTlsPassword*" "password")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-vfunc ask_password_finish
+ (of-object "GTlsInteraction")
+ (return-type "GTlsInteractionResult")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+; GTlsPassword
+
+(define-vfunc get_value
+ (of-object "GTlsPassword")
+ (return-type "const-guchar*")
+ (parameters
+ '("gsize*" "length")
+ )
+)
+
+(define-vfunc set_value
+ (of-object "GTlsPassword")
+ (return-type "void")
+ (parameters
+ '("guchar*" "value")
+ '("gssize" "length")
+ '("GDestroyNotify" "destroy")
+ )
+)
+
+(define-vfunc get_default_warning
+ (of-object "GTlsPassword")
+ (return-type "const-gchar*")
+)
+
; GVolume
(define-vfunc get_name
'("GMount*" "mount")
)
)
-
-
{
/** This is a very minimal interface for icons. It provides functions for checking the equality of two icons and hashing of icons.
- * Glib::Icon does not provide the actual pixmap for the icon as this is out of GIO's scope. However implementations of Icon may contain the name of an
+ * Glib::Icon does not provide the actual pixmap for the icon as this is out of GIO's scope. However implementations of Icon may contain the name of an
* icon (see ThemedIcon), or the path to an icon (see LoadableIcon).
*
* To obtain a hash of an Icon instance, see hash().
//TODO: Why not use _WRAP_METHOD() for this?
/** Request an asynchronous read of @a count bytes from the stream into a
- * new Glib::Bytes. When the operation is finished @a slot will be called.
- * You can then call read_bytes_finish() to get the result of the
+ * new Glib::Bytes. When the operation is finished @a slot will be called.
+ * You can then call read_bytes_finish() to get the result of the
* operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in Gio::Error with PENDING being thrown.
+ * result in Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
void read_bytes_async(gsize count, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
/** Request an asynchronous read of @a count bytes from the stream into a
- * new Glib::Bytes. When the operation is finished @a slot will be called.
- * You can then call read_bytes_finish() to get the result of the
+ * new Glib::Bytes. When the operation is finished @a slot will be called.
+ * You can then call read_bytes_finish() to get the result of the
* operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in Gio::Error with PENDING being thrown.
+ * result in Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
/** Request an asynchronous read of @a count bytes from the stream into the buffer
- * starting at @a buffer. When the operation is finished @a slot will be called.
- * You can then call read_finish() to get the result of the
+ * starting at @a buffer. When the operation is finished @a slot will be called.
+ * You can then call read_finish() to get the result of the
* operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in Gio::Error with PENDING being thrown.
+ * result in Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
void read_async(void* buffer, gsize count, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
/** Request an asynchronous read of @a count bytes from the stream into the buffer
- * starting at @a buffer. When the operation is finished @a slot will be called.
- * You can then call read_finish() to get the result of the
+ * starting at @a buffer. When the operation is finished @a slot will be called.
+ * You can then call read_finish() to get the result of the
* operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in a Gio::Error with PENDING being thrown.
+ * result in a Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
* @param buffer A buffer to read data into (which should be at least count bytes long).
* @param count The number of bytes that will be read from the stream.
* @param slot Callback to call when the request is satisfied.
- * @param io_priority The I/O priority of the request.
+ * @param io_priority The I/O priority of the request.
*/
void read_async(void* buffer, gsize count, const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_input_stream_read_async)
//TODO: Use std::size_type instead of gsize?
/** Request an asynchronous skip of @a count bytes from the stream into the buffer
- * starting at @a buffer. When the operation is finished @a slot will be called.
+ * starting at @a buffer. When the operation is finished @a slot will be called.
* You can then call skip_finish() to get the result of the operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in Gio::Error with PENDING being thrown.
+ * result in Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
* @param count The number of bytes that will be skipped from the stream.
* @param slot Callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
- * @param io_priority The I/O priority of the request.
+ * @param io_priority The I/O priority of the request.
*/
void skip_async(gsize count, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
/** Request an asynchronous skip of @a count bytes from the stream into the buffer
- * starting at @a buffer. When the operation is finished @a slot will be called.
+ * starting at @a buffer. When the operation is finished @a slot will be called.
* You can then call skip_finish() to get the result of the operation.
*
* During an async request no other sync and async calls are allowed, and will
- * result in Gio::Error with PENDING being thrown.
+ * result in Gio::Error with PENDING being thrown.
*
* A value of @a count larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
*
*
* @param count The number of bytes that will be skipped from the stream.
* @param slot Callback to call when the request is satisfied.
- * @param io_priority The I/O priority of the request.
+ * @param io_priority The I/O priority of the request.
*/
void skip_async(gsize count, const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_input_stream_skip_async)
errthrow)
/** Requests an asynchronous closes of the stream, releasing resources related to it.
- * When the operation is finished @a slot will be called.
- * You can then call close_finish() to get the result of the
+ * When the operation is finished @a slot will be called.
+ * You can then call close_finish() to get the result of the
* operation.
*
* For behaviour details see close().
*
* @param slot Callback to call when the request is satisfied.
* @param cancellable A Cancellable object.
- * @param io_priority The I/O priority of the request.
+ * @param io_priority The I/O priority of the request.
*/
void close_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
/** Requests an asynchronous closes of the stream, releasing resources related to it.
- * When the operation is finished @a slot will be called.
- * You can then call close_finish() to get the result of the
+ * When the operation is finished @a slot will be called.
+ * You can then call close_finish() to get the result of the
* operation.
*
* For behaviour details see close().
* override one you must override all.
*
* @param slot Callback to call when the request is satisfied.
- * @param io_priority The I/O priority of the request.
+ * @param io_priority The I/O priority of the request.
*/
void close_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
_IGNORE(g_input_stream_close_async)
/// A non-cancellable version of splice_async().
void splice_async(const Glib::RefPtr<IOStream>& stream2,
- const SlotAsyncReady& slot,
+ const SlotAsyncReady& slot,
IOStreamSpliceFlags flags = Gio::IO_STREAM_SPLICE_NONE,
int io_priority = Glib::PRIORITY_DEFAULT);
*/
#include <gio/gio.h>
+#include <glibmm/bytes.h>
_DEFS(giomm,gio)
_PINCLUDE(giomm/private/outputstream_p.h)
+namespace Glib
+{
+
+// Forward declaration.
+class Bytes;
+
+}
+
namespace Gio
{
/** Streaming output operations on memory chunks
*
- * This class uses arbitrary memory chunks as output for GIO streaming output operations.
+ * This class uses arbitrary memory chunks as output for GIO streaming output operations.
*
* @ingroup Streams
*
_WRAP_METHOD(gsize get_size() const, g_memory_output_stream_get_size)
_WRAP_METHOD(gsize get_data_size() const, g_memory_output_stream_get_data_size)
-
+
+ _WRAP_METHOD(Glib::RefPtr<Glib::Bytes> steal_as_bytes(), g_memory_output_stream_steal_as_bytes)
+
_WRAP_PROPERTY("data", void*)
_WRAP_PROPERTY("data-size", gulong)
//Too C-like: _WRAP_PROPERTY("destroy-function", void*)
//Too C-like: _WRAP_PROPERTY("realloc-function" gpointer : Read / Write / Construct Only
_WRAP_PROPERTY("size", gulong)
-
+
};
} // namespace Gio
void MenuItem::set_action_and_target(const Glib::ustring& action)
{
- g_menu_item_set_action_and_target_value(gobj(), action.c_str(), 0);
+ g_menu_item_set_action_and_target_value(gobj(), action.c_str(), 0);
}
} // namespace Gio
_WRAP_CREATE(const Glib::ustring& label{?}, const Glib::RefPtr<MenuModel>& submenu)
-
+
//TODO: GMenuItem * g_menu_item_new_section (const Glib::ustring& label,
// const Glib::RefPtr<MenuModel>& section);
+ //TODO: Add a set_attribute() templated method to get values directly instead
+ //of requiring a Glib::VariantBase?
+
_WRAP_METHOD(void set_attribute_value(const Glib::ustring& attribute, const Glib::VariantBase& value), g_menu_item_set_attribute_value, deprecated "Use set_attribute() instead.")
_WRAP_METHOD(void set_attribute(const Glib::ustring& attribute, const Glib::VariantBase& value), g_menu_item_set_attribute_value)
_IGNORE(g_menu_item_set_attribute)
_WRAP_METHOD(void set_submenu(const Glib::RefPtr<MenuModel>& submenu), g_menu_item_set_submenu)
_WRAP_METHOD(void set_section(const Glib::RefPtr<MenuModel>& section), g_menu_item_set_section)
+ //TODO: Add a get_attribute() templated method to get values directly instead
+ //of returning a Glib::VariantBase?
+
_WRAP_METHOD(Glib::VariantBase get_attribute(const Glib::ustring& attribute, const Glib::VariantType& expected_type{?}) const, g_menu_item_get_attribute_value)
// Ignore varargs function.
_IGNORE(g_menu_item_get_attribute)
-
+
//TODO: Rename this to unset_action_target() and deprecate this one.
/** Unsets the target for the specified @a action.
*/
//It makes no sense to return const by value.
_CONVERSION(`MenuAttribute',`const gchar*',`giomm_get_menu_attribute($3)')
#m4end
+
+ //TODO: Add a get_item_attribute() templated method to get values directly
+ //instead of returning a Glib::VariantBase?
+
_WRAP_METHOD(Glib::VariantBase get_item_attribute(int item_index, MenuAttribute attribute, const Glib::VariantType& expected_type), g_menu_model_get_item_attribute_value)
_WRAP_METHOD(const Glib::VariantBase get_item_attribute(int item_index, MenuAttribute attribute, const Glib::VariantType& expected_type) const, g_menu_model_get_item_attribute_value, constversion)
_WRAP_METHOD(Glib::RefPtr<const MenuLinkIter> iterate_item_links(int item_index) const, g_menu_model_iterate_item_links, constversion)
_WRAP_METHOD(void items_changed(int position, int removed, int added), g_menu_model_items_changed)
+
+ //TODO: The "items-changed" signal cannot be wrapped because it is not
+ //included in the *Class declaration of GMenuModel.
};
} // namespace Gio
class Volume;
/** The Mount interface represents user-visible mounts.
- * Mount is a "mounted" filesystem that you can access. Mounted is in quotes because it's not the same as a unix mount:
+ * Mount is a "mounted" filesystem that you can access. Mounted is in quotes because it's not the same as a unix mount:
* it might be a gvfs mount, but you can still access the files on it if you use GIO. It might or might not be related to a volume object.
*
- * Unmounting a Mount instance is an asynchronous operation. For more information about asynchronous operations, see AsyncReady.
- * To unmount a Mount instance, first call unmount(). The callback slot will be called when the operation has resolved (either with success or failure),
- * and a AsyncReady structure will be passed to the callback. That callback should then call unmount_finish() with the AsyncReady data to see if the operation was completed successfully.
+ * Unmounting a Mount instance is an asynchronous operation. For more information about asynchronous operations, see AsyncReady.
+ * To unmount a Mount instance, first call unmount(). The callback slot will be called when the operation has resolved (either with success or failure),
+ * and a AsyncReady structure will be passed to the callback. That callback should then call unmount_finish() with the AsyncReady data to see if the operation was completed successfully.
*
* @ingroup Streams
*
/** Remounts a mount.
* This is an asynchronous operation, and is finished by calling mount_finish() with the AsyncResult data returned in the callback slot.
*
- * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
- * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
+ * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
+ * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
* actually be unmounted.
*
* @param operation A mount operation.
/** Remounts a mount.
* This is an asynchronous operation, and is finished by calling mount_finish() with the AsyncResult data returned in the callback slot.
*
- * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
- * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
+ * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
+ * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
* actually be unmounted.
*
* @param operation A mount operation.
* @param slot A callback which will be called when the operation is completed or canceled.
+ * @param flags Flags affecting the operation.
*/
void remount(const Glib::RefPtr<MountOperation>& operation, const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Remounts a mount.
- *
- * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
- * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
+ *
+ * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
+ * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
* actually be unmounted.
*
* @param operation A mount operation.
+ * @param flags Flags affecting the operation.
*/
void remount(const Glib::RefPtr<MountOperation>& operation, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Remounts a mount, without user interaction.
- *
- * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
- * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
+ *
+ * Remounting is useful when some setting affecting the operation of the volume has been changed, as this may need a remount
+ * to take affect. While this is semantically equivalent with unmounting and then remounting, not all backends might need to
* actually be unmounted.
+ *
+ * @param flags Flags affecting the operation.
*/
void remount(MountMountFlags flags = MOUNT_MOUNT_NONE);
_IGNORE(g_mount_remount)
/** Tries to guess the type of content stored on the mount.
* Returns one or more textual identifiers of well-known content types (typically
- * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
- * memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink> specification for more on x-content types.
+ * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+ * memory cards. See the <a href="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</a> specification for more on x-content types.
*
- * This is an asynchronous operation, and is finished by calling
+ * This is an asynchronous operation, and is finished by calling
* guess_content_type_finish().
*
* @param slot A callback which will be called when the operation is completed or canceled.
/** Tries to guess the type of content stored on the mount.
* Returns one or more textual identifiers of well-known content types (typically
- * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
- * memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink> specification for more on x-content types.
+ * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+ * memory cards. See the <a href="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</a> specification for more on x-content types.
*
- * This is an asynchronous operation, and is finished by calling
+ * This is an asynchronous operation, and is finished by calling
* guess_content_type_finish().
*
* @param slot A callback which will be called when the operation is completed or canceled.
/** Tries to guess the type of content stored on the mount.
* Returns one or more textual identifiers of well-known content types (typically
- * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
- * memory cards. See the <ulink url="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</ulink> specification for more on x-content types.
+ * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+ * memory cards. See the <a href="http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec">shared-mime-info</a> specification for more on x-content types.
*
* @param force_rescan Whether to force a rescan of the content. Otherwise a cached result will be used if available.
*
namespace Container_Helpers
{
-/** This specialization of TypeTraits exists
- * because the default use of Glib::wrap(GObject*),
+/** This specialization of TypeTraits exists
+ * because the default use of Glib::wrap(GObject*),
* instead of a specific Glib::wrap(GSomeInterface*),
* would not return a wrapper for an interface.
- */
+ */
template <>
struct TypeTraits< Glib::RefPtr<Gio::Mount> >
{
static CppType to_cpp_type (const CType& item)
{
- //Use a specific Glib::wrap() function,
+ //Use a specific Glib::wrap() function,
//because CType has the specific type (not just GObject):
return Glib::wrap(item, true /* take_copy */);
}
/** Authentication methods for mountable locations.
*
* MountOperation provides a mechanism for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations.
- *
- * Mounting operations are handed a MountOperation that they can use if they require any privileges or authentication for their volumes to be mounted (e.g.
- * a hard disk partition or an encrypted filesystem), or if they are implementing a remote server protocol which requires user credentials such as FTP or
+ *
+ * Mounting operations are handed a MountOperation that they can use if they require any privileges or authentication for their volumes to be mounted (e.g.
+ * a hard disk partition or an encrypted filesystem), or if they are implementing a remote server protocol which requires user credentials such as FTP or
* WebDAV.
*
* Developers should instantiate a subclass of this that implements all the various callbacks to show the required dialogs.
g_mount_operation_set_domain)
_WRAP_METHOD(PasswordSave get_password_save() const,
g_mount_operation_get_password_save)
- _WRAP_METHOD(void set_password_save(PasswordSave password_save),
+ _WRAP_METHOD(void set_password_save(PasswordSave save),
g_mount_operation_set_password_save)
_WRAP_METHOD(int get_choice() const, g_mount_operation_get_choice)
_WRAP_METHOD(void set_choice(int choice), g_mount_operation_set_choice)
//TODO: The array of char* is not very pleasant to wrap:
//_WRAP_SIGNAL( void show_processes(const Glib::ustring& message, GArray* processes, const gchar *choices[]);
- _WRAP_SIGNAL(void show_unmount_progress(const Glib::ustring& message, gint64 time_left, gint64 bytes_left), "show_unmount_progress")
+ _WRAP_SIGNAL(void show_unmount_progress(const Glib::ustring& message, gint64 time_left, gint64 bytes_left), "show_unmount_progress", no_default_handler)
_WRAP_PROPERTY("username", Glib::ustring)
_WRAP_PROPERTY("password", Glib::ustring)
/** Tries to write @a count bytes from @a buffer into the stream. Will block
* during the operation.
- *
- * If count is zero returns zero and does nothing. A value of @a count
+ *
+ * If count is zero returns zero and does nothing. A value of @a count
* larger than MAXSSIZE will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
- *
+ *
* On success, the number of bytes written to the stream is returned.
* It is not an error if this is not the same as the requested size, as it
* can happen e.g. on a partial i/o error, or if the there is not enough
* storage in the stream. All writes either block until at least one byte
* is written, so zero is never returned (unless @a count is zero).
- *
+ *
* On error -1 is returned.
* @param buffer The buffer containing the data to write.
* @param cancellable Cancellable object.
/** Tries to write @a count bytes from @a buffer into the stream. Will block
* during the operation.
- *
+ *
* If string that is larger than MAXSSIZE bytes will cause a Gio::Error with INVALID_ARGUMENT to be thrown.
- *
+ *
* On success, the number of bytes written to the stream is returned.
* It is not an error if this is not the same as the requested size, as it
* can happen e.g. on a partial i/o error, or if the there is not enough
* storage in the stream. All writes either block until at least one byte
* is written, so zero is never returned (unless @a count is zero).
- *
+ *
* On error -1 is returned.
* @param buffer The buffer containing the data to write.
* @return Number of bytes written, or -1 on error.
/** Tries to write @a count bytes from @a buffer into the stream. Will block
* during the operation.
- *
+ *
* This function is similar to write(), except it tries to
* write as many bytes as requested, only stopping on an error.
- *
- * On a successful write of @a count bytes, <tt>true</tt> is returned, and @a bytes_written
+ *
+ * On a successful write of @a count bytes, <tt>true</tt> is returned, and @a bytes_written
* is set to @a count .
- *
- * If there is an error during the operation <tt>false</tt> is returned and @a error
+ *
+ * If there is an error during the operation <tt>false</tt> is returned and @a error
* is set to indicate the error status, @a bytes_written is updated to contain
* the number of bytes written into the stream before the error occured.
* @param buffer The buffer containing the data to write.
- * @param bytes_written Location to store the number of bytes that was
+ * @param bytes_written Location to store the number of bytes that was
* written to the stream.
* @param cancellable Cancellable object.
* @return <tt>true</tt> on success, <tt>false</tt> if there was an error.
/** Tries to write @a count bytes from @a buffer into the stream. Will block
* during the operation.
- *
+ *
* This function is similar to write(), except it tries to
* write as many bytes as requested, only stopping on an error.
- *
- * On a successful write of @a count bytes, <tt>true</tt> is returned, and @a bytes_written
+ *
+ * On a successful write of @a count bytes, <tt>true</tt> is returned, and @a bytes_written
* is set to @a count .
- *
- * If there is an error during the operation <tt>false</tt> is returned and @a error
+ *
+ * If there is an error during the operation <tt>false</tt> is returned and @a error
* is set to indicate the error status, @a bytes_written is updated to contain
* the number of bytes written into the stream before the error occured.
* @param buffer The buffer containing the data to write.
- * @param bytes_written Location to store the number of bytes that was
+ * @param bytes_written Location to store the number of bytes that was
* written to the stream.
* @return <tt>true</tt> on success, <tt>false</tt> if there was an error.
*/
* then call write_bytes_finish() to get the result of
* the operation.
*
- * During an async request no other sync and async calls are allowed,
- * and will result in Gio::Error with PENDING being thrown.
+ * During an async request no other sync and async calls are allowed,
+ * and will result in Gio::Error with PENDING being thrown.
*
- * A Glib:Bytes larger than MAXSSIZE will cause a Gio::Error with
+ * A Glib:Bytes larger than MAXSSIZE will cause a Gio::Error with
* INVALID_ARGUMENT to be thrown.
- *
+ *
* On success, the number of bytes written will be passed to the
* callback @a slot. It is not an error if this is not the same as the
* requested size, as it can happen e.g. on a partial I/O error,
* IO_ERROR_WOULD_BLOCK - if the stream can't accept more data, the
* method will just wait until this changes.
*
- * Any outstanding I/O request with higher priority (lower numerical
- * value) will be executed before an outstanding request with lower
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
* priority. Default priority is Glib::PRIORITY_DEFAULT.
- *
+ *
* For the synchronous, blocking version of this function, see write_bytes().
*
- * @param bytes The bytes to
+ * @param bytes The bytes to
* @param slot Callback slot to call when the request is satisfied.
* @param cancellable Cancellable object.
* @param io_priority The io priority of the request.
* then call write_bytes_finish() to get the result of
* the operation.
*
- * During an async request no other sync and async calls are allowed,
- * and will result in Gio::Error with PENDING being thrown.
+ * During an async request no other sync and async calls are allowed,
+ * and will result in Gio::Error with PENDING being thrown.
*
- * A Glib:Bytes larger than MAXSSIZE will cause a Gio::Error with
+ * A Glib:Bytes larger than MAXSSIZE will cause a Gio::Error with
* INVALID_ARGUMENT to be thrown.
- *
+ *
* On success, the number of bytes written will be passed to the
* callback @a slot. It is not an error if this is not the same as the
* requested size, as it can happen e.g. on a partial I/O error,
* IO_ERROR_WOULD_BLOCK - if the stream can't accept more data, the
* method will just wait until this changes.
*
- * Any outstanding I/O request with higher priority (lower numerical
- * value) will be executed before an outstanding request with lower
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
* priority. Default priority is Glib::PRIORITY_DEFAULT.
- *
+ *
* For the synchronous, blocking version of this function, see write_bytes().
*
- * @param bytes The bytes to
+ * @param bytes The bytes to
* @param slot Callback slot to call when the request is satisfied.
* @param io_priority The io priority of the request.
*
g_output_stream_close,
errthrow)
- /** Request an asynchronous write of @a count bytes from @a buffer into
- * the stream. When the operation is finished @a slot will be called.
- * You can then call write_finish() to get the result of the
+ /** Request an asynchronous write of @a count bytes from @a buffer into
+ * the stream. When the operation is finished @a slot will be called.
+ * You can then call write_finish() to get the result of the
* operation.
*
- * During an async request no other sync and async calls are allowed,
- * and will result in Gio::Error with PENDING being thrown.
+ * During an async request no other sync and async calls are allowed,
+ * and will result in Gio::Error with PENDING being thrown.
*
- * A value of @a count larger than MAXSSIZE will cause a Gio::Error with
+ * A value of @a count larger than MAXSSIZE will cause a Gio::Error with
* INVALID_ARGUMENT to be thrown.
*
* On success, the number of bytes written will be passed to the
- * callback @a slot. It is not an error if this is not the same as the
- * requested size, as it can happen e.g. on a partial I/O error,
- * but generally we try to write as many bytes as requested.
+ * callback @a slot. It is not an error if this is not the same as the
+ * requested size, as it can happen e.g. on a partial I/O error,
+ * but generally we try to write as many bytes as requested.
*
- * Any outstanding I/O request with higher priority (lower numerical
- * value) will be executed before an outstanding request with lower
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
* priority. Default priority is Glib::PRIORITY_DEFAULT.
*
- * The asyncronous methods have a default fallback that uses threads
- * to implement asynchronicity, so they are optional for inheriting
+ * The asyncronous methods have a default fallback that uses threads
+ * to implement asynchronicity, so they are optional for inheriting
* classes. However, if you override one you must override all.
*
- * For the synchronous, blocking version of this function, see
+ * For the synchronous, blocking version of this function, see
* write().
*
- * @param buffer The buffer containing the data to write.
+ * @param buffer The buffer containing the data to write.
* @param count The number of bytes to write
* @param slot Callback slot to call when the request is satisfied.
* @param cancellable Cancellable object.
*/
void write_async(const void* buffer, gsize count, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
- /** Request an asynchronous write of @a count bytes from @a buffer into
- * the stream. When the operation is finished @a slot will be called.
- * You can then call write_finish() to get the result of the
+ /** Request an asynchronous write of @a count bytes from @a buffer into
+ * the stream. When the operation is finished @a slot will be called.
+ * You can then call write_finish() to get the result of the
* operation.
*
- * During an async request no other sync and async calls are allowed,
- * and will result in Gio::Error with PENDING being thrown.
+ * During an async request no other sync and async calls are allowed,
+ * and will result in Gio::Error with PENDING being thrown.
*
- * A value of @a count larger than MAXSSIZE will cause a Gio::Error with
+ * A value of @a count larger than MAXSSIZE will cause a Gio::Error with
* INVALID_ARGUMENT to be thrown.
*
* On success, the number of bytes written will be passed to the
- * callback @a slot. It is not an error if this is not the same as the
- * requested size, as it can happen e.g. on a partial I/O error,
- * but generally we try to write as many bytes as requested.
+ * callback @a slot. It is not an error if this is not the same as the
+ * requested size, as it can happen e.g. on a partial I/O error,
+ * but generally we try to write as many bytes as requested.
*
- * Any outstanding I/O request with higher priority (lower numerical
- * value) will be executed before an outstanding request with lower
+ * Any outstanding I/O request with higher priority (lower numerical
+ * value) will be executed before an outstanding request with lower
* priority. Default priority is Glib::PRIORITY_DEFAULT.
*
- * The asyncronous methods have a default fallback that uses threads
- * to implement asynchronicity, so they are optional for inheriting
+ * The asyncronous methods have a default fallback that uses threads
+ * to implement asynchronicity, so they are optional for inheriting
* classes. However, if you override one you must override all.
*
- * For the synchronous, blocking version of this function, see
+ * For the synchronous, blocking version of this function, see
* write().
*
- * @param buffer The buffer containing the data to write.
+ * @param buffer The buffer containing the data to write.
* @param count The number of bytes to write
* @param slot Callback slot to call when the request is satisfied.
* @param io_priority The io priority of the request.
errthrow)
/** Splices a stream asynchronously.
- * When the operation is finished @a slot will be called.
- * You can then call splice_finish() to get the result of the
+ * When the operation is finished @a slot will be called.
+ * You can then call splice_finish() to get the result of the
* operation.
*
- * For the synchronous, blocking version of this function, see
+ * For the synchronous, blocking version of this function, see
* splice().
*
* @param source An InputStream.
* @param slot Callback slot to call when the request is satisfied.
* @param cancellable Cancellable object.
+ * @param flags A set of OutputStreamSpliceFlags.
* @param io_priority The io priority of the request.
*/
void splice_async(const Glib::RefPtr<InputStream>& source, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, OutputStreamSpliceFlags flags = OUTPUT_STREAM_SPLICE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
/** Splices a stream asynchronously.
- * When the operation is finished @a slot will be called.
- * You can then call splice_finish() to get the result of the
+ * When the operation is finished @a slot will be called.
+ * You can then call splice_finish() to get the result of the
* operation.
*
- * For the synchronous, blocking version of this function, see
+ * For the synchronous, blocking version of this function, see
* splice().
*
* @param source An InputStream.
* @param slot Callback slot to call when the request is satisfied.
+ * @param flags A set of OutputStreamSpliceFlags.
* @param io_priority The io priority of the request.
*/
void splice_async(const Glib::RefPtr<InputStream>& source, const SlotAsyncReady& slot, OutputStreamSpliceFlags flags = OUTPUT_STREAM_SPLICE_NONE, int io_priority = Glib::PRIORITY_DEFAULT);
g_output_stream_flush_finish,
errthrow)
- /** Requests an asynchronous close of the stream, releasing resources related to it.
+ /** Requests an asynchronous close of the stream, releasing resources related to it.
* When the operation is finished the @a slot will be called, giving the results.
* You can then call close_finish() to get the result of the operation.
* For behaviour details see close().
*
- * The asyncronous methods have a default fallback that uses threads to implement asynchronicity,
+ * The asyncronous methods have a default fallback that uses threads to implement asynchronicity,
* so they are optional for inheriting classes. However, if you override one you must override all.
*
* @param slot Callback slot to call when the request is satisfied.
*/
void close_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);
- /** Requests an asynchronous close of the stream, releasing resources related to it.
- * When the operation is finished the @a slot will be called, giving the results.
+ /** Requests an asynchronous close of the stream, releasing resources related to it.
+ * When the operation is finished the @a slot will be called, giving the results.
* You can then call close_finish() to get the result of the operation.
* For behaviour details see close().
*
- * The asyncronous methods have a default fallback that uses threads to implement asynchronicity,
+ * The asyncronous methods have a default fallback that uses threads to implement asynchronicity,
* so they are optional for inheriting classes. However, if you override one you must override all.
*
* @param slot Callback slot to call when the request is satisfied.
&SignalProxy_async_callback,
slot_copy);
}
-
+
void Proxy::connect_async(const Glib::RefPtr<IOStream>& connection, const Glib::RefPtr<const ProxyAddress>& proxy_address, const SlotAsyncReady& slot)
{
// Create a copy of the slot.
_WRAP_METHOD(static Glib::RefPtr<Proxy> get_default_for_protocol(const Glib::ustring& protocol), g_proxy_get_default_for_protocol)
_WRAP_METHOD(Glib::RefPtr<IOStream> connect(const Glib::RefPtr<IOStream>& connection,
- const Glib::RefPtr<const ProxyAddress>& proxy_adress, const Glib::RefPtr<Cancellable>& cancellable), g_proxy_connect, errthrow)
+ const Glib::RefPtr<const ProxyAddress>& proxy_address, const Glib::RefPtr<Cancellable>& cancellable), g_proxy_connect, errthrow)
/** An Asynchronous version of connect().
*/
&SignalProxy_async_callback,
slot_copy);
}
-
+
void ProxyResolver::lookup_async(const Glib::ustring& uri, const SlotAsyncReady& slot)
{
// Create a copy of the slot.
const Glib::RefPtr<Cancellable>& cancellable), g_proxy_resolver_lookup, errthrow)
/** Looks into the system proxy configuration to determine what proxy, if any, to use to connect to uri.
- * The returned proxy URIs are of the form <protocol>://[user[:password]@]host:port or direct://, where <protocol> could be http, rtsp, socks or other proxying protocol.
+ * The returned proxy URIs are of the form \<protocol\>://[user[:password]\@]host:port or direct://, where \<protocol\> could be http, rtsp, socks or other proxying protocol.
*
* If you don't know what network protocol is being used on the socket, you should use none as the URI protocol.
* In this case, the resolver might still return a generic proxy type (such as SOCKS), but would not return protocol-specific proxy types (such as http).
slot_copy);
}
+void
+Resolver::lookup_records_async(const Glib::ustring& rrname,
+ ResolverRecordType record_type,
+ const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_resolver_lookup_records_async(gobj(),
+ (rrname.empty() ? 0 : rrname.c_str()),
+ static_cast<GResolverRecordType>(record_type),
+ Glib::unwrap(cancellable),
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
+void
+Resolver::lookup_records_async(const Glib::ustring& rrname,
+ ResolverRecordType record_type,
+ const SlotAsyncReady& slot)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_resolver_lookup_records_async(gobj(),
+ (rrname.empty() ? 0 : rrname.c_str()),
+ static_cast<GResolverRecordType>(record_type),
+ 0,
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
std::string
hostname_to_ascii (const Glib::ustring& hostname)
{
_DEFS(giomm,gio)
_PINCLUDE(glibmm/private/object_p.h)
+
+// Forward declarations for classes in the Glib namespace.
+namespace Glib
+{
+
+class VariantContainerBase;
+
+}
+
namespace Gio
{
+_WRAP_ENUM(ResolverRecordType, GResolverRecordType)
+
/** Asynchronous and cancellable DNS resolver
*
* Resolver provides cancellable synchronous and asynchronous DNS resolution,
#m4 _CONVERSION(`GList*',`Glib::ListHandle< Glib::RefPtr<InetAddress> >',`$2($3, Glib::OWNERSHIP_DEEP)')
_WRAP_METHOD(Glib::ListHandle< Glib::RefPtr<InetAddress> > lookup_by_name(const Glib::ustring& hostname, const Glib::RefPtr<Cancellable>& cancellable{?}), g_resolver_lookup_by_name, errthrow)
-
- /** Begins asynchronously resolving hostname to determine its associated IP address(es), and eventually calls @a slot, which must call
+
+ /** Begins asynchronously resolving hostname to determine its associated IP address(es), and eventually calls @a slot, which must call
* lookup_by_name_finish() to get the result. See lookup_by_name() for more details.
*
- * @param hostname hostname The hostname to look up.
+ * @param hostname The hostname to look up.
* @param slot A callback slot to call after the resolution completes.
* @param cancellable A Cancellable object which can be used to cancel the operation.
*/
void lookup_by_name_async(const Glib::ustring& hostname, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
-
- /** Begins asynchronously resolving hostname to determine its associated IP address(es), and eventually calls @a slot, which must call
+
+ /** Begins asynchronously resolving hostname to determine its associated IP address(es), and eventually calls @a slot, which must call
* lookup_by_name_finish() to get the result. See lookup_by_name() for more details.
*
- * @param hostname hostname The hostname to look up.
+ * @param hostname The hostname to look up.
* @param slot A callback slot to call after the resolution completes.
*/
void lookup_by_name_async(const Glib::ustring& hostname, const SlotAsyncReady& slot);
_IGNORE(g_resolver_lookup_by_name_async)
-
+
_WRAP_METHOD(Glib::ListHandle< Glib::RefPtr<InetAddress> > lookup_by_name_finish(const Glib::RefPtr<AsyncResult>& result), g_resolver_lookup_by_name_finish, errthrow)
_WRAP_METHOD(Glib::ustring lookup_by_address(const Glib::RefPtr<InetAddress>& address, const Glib::RefPtr<Cancellable>& cancellable{?}), g_resolver_lookup_by_address, errthrow)
- /** Begins asynchronously reverse-resolving an address to determine its associated hostname, and eventually calls callback, which must call
+ /** Begins asynchronously reverse-resolving an address to determine its associated hostname, and eventually calls callback, which must call
* lookup_by_address_finish() to get the final result.
*
* @param address The address to reverse-resolve.
- * @param hostname hostname The hostname to look up.
* @param slot A callback slot to call after the resolution completes.
* @param cancellable A Cancellable object which can be used to cancel the operation.
*/
void lookup_by_address_async(const Glib::RefPtr<InetAddress>& address, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
-
- /** Begins asynchronously reverse-resolving an address to determine its associated hostname, and eventually calls callback, which must call
+
+ /** Begins asynchronously reverse-resolving an address to determine its associated hostname, and eventually calls callback, which must call
* lookup_by_address_finish() to get the final result.
*
* @param address The address to reverse-resolve.
- * @param hostname hostname The hostname to look up.
* @param slot A callback slot to call after the resolution completes.
*/
void lookup_by_address_async(const Glib::RefPtr<InetAddress>& address, const SlotAsyncReady& slot);
_IGNORE(g_resolver_lookup_by_address_async)
-
+
_WRAP_METHOD(Glib::ustring lookup_by_address_finish(const Glib::RefPtr<AsyncResult>& result), g_resolver_lookup_by_address_finish, errthrow)
#m4 _CONVERSION(`GList*',`ListHandle_SrvTarget',`$2($3, Glib::OWNERSHIP_DEEP)')
_WRAP_METHOD(ListHandle_SrvTarget lookup_service(const Glib::ustring& service, const Glib::ustring& protocol, const Glib::ustring& domain, const Glib::RefPtr<Cancellable>& cancellable{?}), g_resolver_lookup_service, errthrow)
- /** Begins asynchronously performing a DNS SRV lookup for the given service and protocol in the given domain, and eventually calls callback,
+ /** Begins asynchronously performing a DNS SRV lookup for the given service and protocol in the given domain, and eventually calls callback,
* which must call lookup_service_finish() to get the final result. See glookup_service() for more details.
*
* @param service The service type to look up (eg, "ldap").
- * @param protocol The networking protocol to use for service (eg, "tcp")
+ * @param protocol The networking protocol to use for service (eg, "tcp")
* @param domain The DNS domain to look up the service in.
* @param slot A callback slot to call after the resolution completes.
* @param cancellable A Cancellable object which can be used to cancel the operation.
*/
void lookup_service_async(const Glib::ustring& service, const Glib::ustring& protocol, const Glib::ustring& domain, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
-
- /** Begins asynchronously performing a DNS SRV lookup for the given service and protocol in the given domain, and eventually calls callback,
+
+ /** Begins asynchronously performing a DNS SRV lookup for the given service and protocol in the given domain, and eventually calls callback,
* which must call lookup_service_finish() to get the final result. See glookup_service() for more details.
*
* @param service The service type to look up (eg, "ldap").
- * @param protocol The networking protocol to use for service (eg, "tcp")
+ * @param protocol The networking protocol to use for service (eg, "tcp")
* @param domain The DNS domain to look up the service in.
* @param slot A callback slot to call after the resolution completes.
*/
_WRAP_METHOD(ListHandle_SrvTarget lookup_service_finish(const Glib::RefPtr<AsyncResult>& result), g_resolver_lookup_service_finish, errthrow)
+#m4 _CONVERSION(`GList*',`std::vector<Glib::VariantContainerBase>',`Glib::ListHandler<Glib::VariantContainerBase>::list_to_vector($3, Glib::OWNERSHIP_DEEP)')
+
+ _WRAP_METHOD(std::vector<Glib::VariantContainerBase> lookup_records(const Glib::ustring& rrname, ResolverRecordType record_type, const Glib::RefPtr<Cancellable>& cancellable{?}), g_resolver_lookup_records, errthrow)
+
+ /** Begins asynchronously performing a DNS lookup for the given @a rrname,
+ * and eventually calls @a slot, which must call lookup_records_finish() to
+ * get the final result. See lookup_records() for more details.
+ *
+ * @param rrname The DNS name to lookup the record for.
+ * @param record_type The type of DNS record to lookup.
+ * @param cancellable A Cancellable.
+ * @param slot The slot to call after the resolution completes.
+ * @newin{2,36}
+ */
+ void lookup_records_async(const Glib::ustring& rrname,
+ ResolverRecordType record_type, const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable);
+ _IGNORE(g_resolver_lookup_records_async)
+
+ /// A non-cancellable version of lookup_records_async().
+ void lookup_records_async(const Glib::ustring& rrname,
+ ResolverRecordType record_type, const SlotAsyncReady& slot);
+
+ _WRAP_METHOD(std::vector<Glib::VariantContainerBase> lookup_records_finish(const Glib::RefPtr<AsyncResult>& result), g_resolver_lookup_records_finish, errthrow)
//TODO: Remove no_default_handler when we can break ABI:
_WRAP_SIGNAL(void reload(), reload, no_default_handler)
/** Stream seeking interface.
* Seekable is implemented by streams (implementations of InputStream or OutputStream) that support seeking.
- * To find the position of a stream, use tell(). To find
- * out if a stream supports seeking, use can_seek(). To position a
- * stream, use seek(). To find out if a stream supports
- * truncating, use can_truncate(). To truncate a stream, use
+ * To find the position of a stream, use tell(). To find
+ * out if a stream supports seeking, use can_seek(). To position a
+ * stream, use seek(). To find out if a stream supports
+ * truncating, use can_truncate(). To truncate a stream, use
* truncate().
*
* @ingroup Streams
_WRAP_METHOD(bool set_value(const Glib::ustring& key, const Glib::VariantBase& value), g_settings_set_value)
- /** Gets the value that is stored in the settings for a @key.
+ /** Gets the value that is stored in the settings for a @a key.
*
* It is a programmer error to give a @a key that isn't contained in the
* schema for the settings.
*
- * @param key The key to get the value for.
- * @param A Variant of the expected type.
+ * @param key The key to get the value for.
+ * @param value A Variant of the expected type.
*
* @newin{2,28}
*/
#m4 _CONVERSION(`const Glib::VariantType&',`const GVariantType*',`$3.gobj()')
_WRAP_CTOR(SimpleAction(const Glib::ustring& name, const Glib::VariantType& parameter_type), g_simple_action_new)
- _WRAP_CTOR(SimpleAction(const Glib::ustring& name, const Glib::VariantType& parameter_type, const Glib::VariantBase& sate), g_simple_action_new_stateful)
+ _WRAP_CTOR(SimpleAction(const Glib::ustring& name, const Glib::VariantType& parameter_type, const Glib::VariantBase& state), g_simple_action_new_stateful)
public:
_WRAP_CREATE(const Glib::ustring& name, const Glib::VariantType& parameter_type)
_WRAP_METHOD_DOCS_ONLY(g_simple_action_new_stateful)
- _WRAP_CREATE(const Glib::ustring& name, const Glib::VariantType& parameter_type, const Glib::VariantBase& sate)
+ _WRAP_CREATE(const Glib::ustring& name, const Glib::VariantType& parameter_type, const Glib::VariantBase& state)
_WRAP_METHOD(void set_enabled(bool enabled), g_simple_action_set_enabled)
_WRAP_METHOD(void set_state(const Glib::VariantBase& value), g_simple_action_set_state)
public:
_WRAP_METHOD_DOCS_ONLY(g_socket_new)
- /** @throw Glib::Error
+ /** @param cancellable A Cancellable, or <tt>0</tt>.
+ * @throw Glib::Error
*/
static Glib::RefPtr<Socket>
create(SocketFamily family, SocketType type, SocketProtocol protocol,
_IGNORE(g_socket_connection_factory_create_connection)
_WRAP_METHOD_DOCS_ONLY(g_socket_new_from_fd)
- /** @throw Glib::Error
+ /** @param cancellable A Cancellable, or <tt>0</tt>.
+ * @throw Glib::Error
*/
static Glib::RefPtr<Socket> create_from_fd(int fd, const Glib::RefPtr<Cancellable>&
cancellable = Glib::RefPtr<Cancellable>());
_WRAP_METHOD(SocketProtocol get_protocol() const, g_socket_get_protocol)
_WRAP_METHOD(SocketType get_socket_type() const, g_socket_get_socket_type)
_WRAP_METHOD(bool speaks_ipv4() const, g_socket_speaks_ipv4)
-
+
_WRAP_METHOD(Glib::RefPtr<Credentials> get_credentials(), g_socket_get_credentials, errthrow)
_WRAP_METHOD(Glib::RefPtr<const Credentials> get_credentials() const, g_socket_get_credentials, errthrow)
_WRAP_METHOD(void set_multicast_ttl(guint ttl), g_socket_set_multicast_ttl)
_WRAP_METHOD(bool join_multicast_group(const Glib::RefPtr<InetAddress>& group, bool source_specific, const std::string& iface{?}), g_socket_join_multicast_group, errthrow)
- _WRAP_METHOD(bool leave_multicast_group(const Glib::RefPtr<InetAddress>& ggroup, bool source_specific, const std::string& iface{?}), g_socket_leave_multicast_group, errthrow)
+ _WRAP_METHOD(bool leave_multicast_group(const Glib::RefPtr<InetAddress>& group, bool source_specific, const std::string& iface{?}), g_socket_leave_multicast_group, errthrow)
+
-
_WRAP_PROPERTY("blocking", bool)
_WRAP_PROPERTY("family", SocketFamily)
_WRAP_PROPERTY("fd", int)
public:
_WRAP_METHOD(Glib::RefPtr<SocketAddress> next(const Glib::RefPtr<Cancellable>& cancellable{?}), g_socket_address_enumerator_next, errthrow)
- /** Asynchronously retrieves the next SocketAddress from the enumerator and then calls @a slot,
+ /** Asynchronously retrieves the next SocketAddress from the enumerator and then calls @a slot,
* which must call next_finish() to get the result.
*
* @param cancellable A Cancellable object which can be used to cancel the operation.
*/
void next_async(const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot);
- /** Asynchronously retrieves the next SocketAddress from the enumerator and then calls @a slot,
+ /** Asynchronously retrieves the next SocketAddress from the enumerator and then calls @a slot,
* which must call next_finish() to get the result.
*
* @param slot A callback slot to call after the resolution completes.
_WRAP_METHOD(void set_enable_proxy(bool enable), g_socket_client_set_enable_proxy)
_WRAP_METHOD(guint get_timeout() const, g_socket_client_get_timeout)
- _WRAP_METHOD(void set_timeout(guint enable), g_socket_client_set_timeout)
+ _WRAP_METHOD(void set_timeout(guint timeout), g_socket_client_set_timeout)
_WRAP_METHOD(void add_application_proxy(const Glib::ustring& protocol), g_socket_client_add_application_proxy)
*/
#include <gio/gio.h>
+#include "slot_async.h"
namespace Gio
{
+
+void
+SocketConnection::connect_async(const Glib::RefPtr<SocketAddress>& address,
+ const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_socket_connection_connect_async(gobj(),
+ Glib::unwrap(address),
+ Glib::unwrap(cancellable),
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
+void
+SocketConnection::connect_async(const Glib::RefPtr<SocketAddress>& address,
+ const SlotAsyncReady& slot)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_socket_connection_connect_async(gobj(),
+ Glib::unwrap(address),
+ 0,
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
} // namespace Gio
_CLASS_GOBJECT(SocketConnection, GSocketConnection, G_SOCKET_CONNECTION, Gio::IOStream, GIOStream)
public:
-_WRAP_METHOD(Glib::RefPtr<Socket> get_socket(), g_socket_connection_get_socket, refreturn)
-_WRAP_METHOD(Glib::RefPtr<const Socket> get_socket() const, g_socket_connection_get_socket, constversion, refreturn)
-_WRAP_METHOD(Glib::RefPtr<SocketAddress> get_local_address(), g_socket_connection_get_local_address, errthrow)
-_WRAP_METHOD(Glib::RefPtr<const SocketAddress> get_local_address() const, g_socket_connection_get_local_address, constversion, errthrow)
-_WRAP_METHOD(Glib::RefPtr<SocketAddress> get_remote_address(), g_socket_connection_get_remote_address, errthrow)
-_WRAP_METHOD(Glib::RefPtr<const SocketAddress> get_remote_address() const, g_socket_connection_get_remote_address, constversion, errthrow)
+ _WRAP_METHOD(bool connect(const Glib::RefPtr<SocketAddress>& address, const Glib::RefPtr<Cancellable>& cancellable{?}), g_socket_connection_connect, errthrow)
-// Not sure that registering new GTypes with the factory is useful for the C++ binding
-//_WRAP_METHOD(void factory_register_type(GType g_type, GSocketFamily family, GSocketType type, gint protocol);
-//_WRAP_METHOD(GType factory_lookup_type(GSocketFamily family, GSocketType type, gint protocol_id);
+ /** Asynchronously connect this connection to the specified remote address.
+ * This clears the "blocking" flag on this connection's underlying socket if
+ * it is currently set.
+ *
+ * Use connect_finish() to retrieve the result.
+ *
+ * @param address A SocketAddress specifying the remote address.
+ * @param slot A SlotAsyncReady slot.
+ * @param cancellable A Cancellable.
+ * @newin{2,36}
+ */
+ void connect_async(const Glib::RefPtr<SocketAddress>& address,
+ const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
+ _IGNORE(g_socket_connection_connect_async)
-_WRAP_METHOD(static Glib::RefPtr<SocketConnection> create(const Glib::RefPtr<Socket>& socket), g_socket_connection_factory_create_connection)
+ /// A non-cancellable version of connect_async().
+ void connect_async(const Glib::RefPtr<SocketAddress>& address,
+ const SlotAsyncReady& slot);
-_WRAP_PROPERTY("socket", Glib::RefPtr<Socket>)
+ _WRAP_METHOD(bool connect_finish(const Glib::RefPtr<AsyncResult>& result), g_socket_connection_connect_finish, errthrow)
+
+ _WRAP_METHOD(bool is_connected() const, g_socket_connection_is_connected)
+
+ _WRAP_METHOD(Glib::RefPtr<Socket> get_socket(), g_socket_connection_get_socket, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<const Socket> get_socket() const, g_socket_connection_get_socket, constversion, refreturn)
+ _WRAP_METHOD(Glib::RefPtr<SocketAddress> get_local_address(), g_socket_connection_get_local_address, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<const SocketAddress> get_local_address() const, g_socket_connection_get_local_address, constversion, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<SocketAddress> get_remote_address(), g_socket_connection_get_remote_address, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<const SocketAddress> get_remote_address() const, g_socket_connection_get_remote_address, constversion, errthrow)
+
+ // Not sure that registering new GTypes with the factory is useful for the C++ binding
+ //_WRAP_METHOD(void factory_register_type(GType g_type, GSocketFamily family, GSocketType type, gint protocol);
+ //_WRAP_METHOD(GType factory_lookup_type(GSocketFamily family, GSocketType type, gint protocol_id);
+
+ _WRAP_METHOD(static Glib::RefPtr<SocketConnection> create(const Glib::RefPtr<Socket>& socket), g_socket_connection_factory_create_connection)
+
+ _WRAP_PROPERTY("socket", Glib::RefPtr<Socket>)
};
} // namespace Gio
Glib::unwrap(socket),
0,
&gerror);
-
+
if(gerror)
::Glib::Error::throw_exception(gerror);
-
+
return retval;
}
&gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
-
+
if(retobj)
source_object = Glib::wrap(retobj);
_WRAP_METHOD(bool add_socket(const Glib::RefPtr<Socket>& socket, const Glib::RefPtr<Glib::Object>& source_object), g_socket_listener_add_socket, errthrow)
- //TODO: The use of WRAP_METHOD_DOCS_ONLY here is almost certainly not good enough.
+ //TODO: The use of WRAP_METHOD_DOCS_ONLY here is almost certainly not good enough.
//Check the HTML actually outputed and probably hand-code them as for Gio::File.
_WRAP_METHOD_DOCS_ONLY(g_socket_listener_add_socket)
_WRAP_METHOD_DOCS_ONLY(g_socket_listener_accept_socket_finish)
Glib::RefPtr<Socket> accept_socket_finish(const Glib::RefPtr<AsyncResult>& result, Glib::RefPtr<Glib::Object>& source_object);
_IGNORE(g_socket_listener_accept_socket_finish)
-
+
_WRAP_METHOD_DOCS_ONLY(g_socket_listener_accept_socket_finish)
Glib::RefPtr<Socket> accept_socket_finish(const Glib::RefPtr<AsyncResult>& result);
/** Creates a new themed icon for @ iconname, and optionally all the names that can be created by shortening @a iconname at '-' characters.
*
* @param iconname A string containing an icon name.
- * use_default_callbacks Whether to use all the names that can be created by shortening @a iconname at '-' characters.
+ * @param use_default_callbacks Whether to use all the names that can be created by shortening @a iconname at '-' characters.
*/
explicit ThemedIcon(const std::string& iconname, bool use_default_callbacks = false);
_IGNORE(g_themed_icon_new, g_themed_icon_new_with_default_fallbacks)
/** Creates a new themed icon for @ iconname, and optionally all the names that can be created by shortening @a iconname at '-' characters.
*
* @param iconname A string containing an icon name.
- * use_default_callbacks Whether to use all the names that can be created by shortening @a iconname at '-' characters.
+ * @param use_default_callbacks Whether to use all the names that can be created by shortening @a iconname at '-' characters.
*/
_WRAP_CREATE(const std::string& iconname, bool use_default_callbacks = false)
//There are no signals.
//The "name" property is write-only and construct-only so it should not be wrapped.
- //An array: This is awkward to wrap_WRAP_PROPERTY("names", )
+ _WRAP_PROPERTY("names", std::vector<Glib::ustring>)
_WRAP_PROPERTY("use-default-fallbacks", bool)
};
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+#include <giomm/socketconnectable.h>
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <giomm/enums.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gio
+{
+
+class SocketConnectable;
+
+/** TlsCertificate - TLS certificate.
+ * A certificate used for TLS authentication and encryption. This can represent
+ * either a certificate only (eg, the certificate received by a client from a
+ * server), or the combination of a certificate and a private key (which is
+ * needed when acting as a TlsServerConnection).
+ * @newin{2,36}
+ */
+class TlsCertificate : public Glib::Object
+{
+ _CLASS_GOBJECT(TlsCertificate, GTlsCertificate, G_TLS_CERTIFICATE, Glib::Object, GObject)
+
+protected:
+ _WRAP_CTOR(TlsCertificate(const char* data, gssize length), g_tls_certificate_new_from_pem, errthrow)
+ _WRAP_CTOR(TlsCertificate(const std::string& file), g_tls_certificate_new_from_file, errthrow)
+ _WRAP_CTOR(TlsCertificate(const std::string& cert_file, const std::string& key_file), g_tls_certificate_new_from_files, errthrow)
+
+public:
+ _WRAP_METHOD_DOCS_ONLY(g_tls_certificate_new_from_pem)
+ _WRAP_CREATE(const char* data, gssize length = -1)
+
+ _WRAP_METHOD_DOCS_ONLY(g_tls_certificate_new_from_file)
+ _WRAP_CREATE(const std::string& file)
+
+ _WRAP_METHOD_DOCS_ONLY(g_tls_certificate_new_from_files)
+ _WRAP_CREATE(const std::string& cert_file, const std::string& key_file)
+
+#m4 _CONVERSION(`GList*', `std::vector< Glib::RefPtr<TlsCertificate> >', `Glib::ListHandler< Glib::RefPtr<TlsCertificate> >::list_to_vector($3, Glib::OWNERSHIP_DEEP)')
+ _WRAP_METHOD(static std::vector< Glib::RefPtr<TlsCertificate> > create_list_from_file(const std::string& file), g_tls_certificate_list_new_from_file, errthrow)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> get_issuer(), g_tls_certificate_get_issuer)
+ _WRAP_METHOD(Glib::RefPtr<const TlsCertificate> get_issuer() const, g_tls_certificate_get_issuer, constversion)
+
+ _WRAP_METHOD(TlsCertificateFlags verify(const Glib::RefPtr<const SocketConnectable>& identity{?}, const Glib::RefPtr<const TlsCertificate>& trusted_ca{?}) const, g_tls_certificate_verify)
+ _WRAP_METHOD(bool is_same(const Glib::RefPtr<const TlsCertificate>& cert_two) const, g_tls_certificate_is_same)
+
+ //TODO: _WRAP_PROPERTY("certificate", GByteArray*)
+
+ _WRAP_PROPERTY("certificate-pem", char*)
+ _WRAP_PROPERTY("issuer", Glib::RefPtr<TlsCertificate>)
+
+ //TODO: _WRAP_PROPERTY("private-key", GByteArray*)
+
+ // Write-only and construct-only
+ //_WRAP_PROPERTY("private-key-pem", char*)
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+#include <giomm/socketconnectable.h>
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <giomm/enums.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/interface_p.h)
+_PINCLUDE(gio/gio.h)
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GTlsClientConnectionInterface GTlsClientConnectionInterface;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gio
+{
+
+class SocketConnectable;
+
+/** TlsClientConnection - TLS client-side connection.
+ * TlsClientConnection is the client-side subclass of TlsConnection,
+ * representing a client-side TLS connection.
+ * @newin{2,36}
+ */
+class TlsClientConnection : public Glib::Interface
+{
+ _CLASS_INTERFACE(TlsClientConnection, GTlsClientConnection, G_TLS_CLIENT_CONNECTION, GTlsClientConnectionInterface)
+
+public:
+ //TODO: This new function creates an IOStream, not a TlsClientConnection:
+ // GIOStream* g_tls_client_connection_new(GIOStream *base_io_stream, GSocketConnectable *server_identity, GError **error);
+
+ _WRAP_METHOD(void set_server_identity(const Glib::RefPtr<SocketConnectable>& identity), g_tls_client_connection_set_server_identity)
+
+ _WRAP_METHOD(Glib::RefPtr<SocketConnectable> get_server_identity(), g_tls_client_connection_get_server_identity)
+ _WRAP_METHOD(Glib::RefPtr<const SocketConnectable> get_server_identity() const, g_tls_client_connection_get_server_identity, constversion)
+
+ _WRAP_METHOD(void set_validation_flags(TlsCertificateFlags flags), g_tls_client_connection_set_validation_flags)
+ _WRAP_METHOD(TlsCertificateFlags get_validation_flags() const, g_tls_client_connection_get_validation_flags)
+
+ _WRAP_METHOD(void set_use_ssl3(bool use_ssl3), g_tls_client_connection_set_use_ssl3)
+ _WRAP_METHOD(bool get_use_ssl3() const, g_tls_client_connection_get_use_ssl3)
+
+ //TODO: _WRAP_METHOD(GList* get_accepted_cas(), g_tls_client_connection_get_accepted_cas)
+
+ //TODO: _WRAP_PROPERTY("accepted-cas", gpointer)
+
+ _WRAP_PROPERTY("server-identity", Glib::RefPtr<SocketConnectable>)
+ _WRAP_PROPERTY("use-ssl3", bool)
+ _WRAP_PROPERTY("validation-flags", TlsCertificateFlags)
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+#include <giomm/cancellable.h>
+#include <giomm/iostream.h>
+#include <giomm/tlsdatabase.h>
+#include <giomm/tlsinteraction.h>
+#include "slot_async.h"
+
+namespace Gio
+{
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <giomm/tlscertificate.h>
+#include <giomm/asyncresult.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gio
+{
+
+_WRAP_ENUM(TlsRehandshakeMode,GTlsRehandshakeMode)
+
+class Cancellable;
+class IOStream;
+class TlsDatabase;
+class TlsInteraction;
+
+/** TlsConnection - TLS connection type.
+ * TlsConnection is the base TLS connection class type, which wraps an IOStream
+ * and provides TLS encryption on top of it. Its subclasses,
+ * TlsClientConnection and TlsServerConnection, implement client-side and
+ * server-side TLS, respectively.
+ * @newin{2,36}
+ */
+class TlsConnection : public Glib::Object
+{
+ _CLASS_GOBJECT(TlsConnection, GTlsConnection, G_TLS_CONNECTION, Glib::Object, GObject)
+
+protected:
+ _CTOR_DEFAULT
+
+public:
+ _WRAP_METHOD(void set_certificate(const Glib::RefPtr<TlsCertificate>& certificate), g_tls_connection_set_certificate)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> get_certificate(), g_tls_connection_get_certificate)
+ _WRAP_METHOD(Glib::RefPtr<const TlsCertificate> get_certificate() const, g_tls_connection_get_certificate, constversion)
+
+ _WRAP_METHOD(TlsCertificateFlags get_peer_certificate_errors() const, g_tls_connection_get_peer_certificate_errors)
+
+ _WRAP_METHOD(void set_require_close_notify(bool require_close_notify), g_tls_connection_set_require_close_notify)
+ _WRAP_METHOD(bool get_require_close_notify() const, g_tls_connection_get_require_close_notify)
+
+ _WRAP_METHOD(void set_rehandshake_mode(TlsRehandshakeMode mode), g_tls_connection_set_rehandshake_mode)
+ _WRAP_METHOD(TlsRehandshakeMode get_rehandshake_mode() const, g_tls_connection_get_rehandshake_mode)
+
+ _WRAP_METHOD(void set_use_system_certdb(bool use_system_certdb), g_tls_connection_set_use_system_certdb)
+ _WRAP_METHOD(bool get_use_system_certdb() const, g_tls_connection_get_use_system_certdb)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsDatabase> get_database(), g_tls_connection_get_database)
+ _WRAP_METHOD(Glib::RefPtr<const TlsDatabase> get_database() const, g_tls_connection_get_database, constversion)
+
+ _WRAP_METHOD(void set_database(const Glib::RefPtr<TlsDatabase>& database), g_tls_connection_set_database)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsInteraction> get_interaction(), g_tls_connection_get_interaction)
+ _WRAP_METHOD(Glib::RefPtr<const TlsInteraction> get_interaction() const, g_tls_connection_get_interaction, constversion)
+
+ _WRAP_METHOD(void set_interaction(const Glib::RefPtr<TlsInteraction>& interaction), g_tls_connection_set_interaction)
+
+ _WRAP_METHOD(bool handshake(const Glib::RefPtr<Cancellable>& cancellable{?}), g_tls_connection_handshake, errthrow)
+
+ _WRAP_METHOD(void handshake_async(const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.?}, int io_priority{.} = Glib::PRIORITY_DEFAULT), g_tls_connection_handshake_async, slot_name slot, slot_callback SignalProxy_async_callback)
+ _WRAP_METHOD(bool handshake_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_connection_handshake_finish, errthrow)
+
+ _WRAP_METHOD(bool emit_accept_certificate(const Glib::RefPtr<const TlsCertificate>& peer_cert, TlsCertificateFlags errors), g_tls_connection_emit_accept_certificate)
+
+ _WRAP_PROPERTY("base-io-stream", Glib::RefPtr<IOStream>)
+ _WRAP_PROPERTY("certificate", Glib::RefPtr<TlsCertificate>)
+ _WRAP_PROPERTY("database", Glib::RefPtr<TlsDatabase>)
+ _WRAP_PROPERTY("interaction", Glib::RefPtr<TlsInteraction>)
+ _WRAP_PROPERTY("peer-certificate", Glib::RefPtr<TlsCertificate>)
+ _WRAP_PROPERTY("peer-certificate-errors", TlsCertificateFlags)
+ _WRAP_PROPERTY("rehandshake-mode", TlsRehandshakeMode)
+ _WRAP_PROPERTY("require-close-notify", bool)
+ _WRAP_PROPERTY("use-system-certdb", bool)
+
+#m4 _CONVERSION(`GTlsCertificate*',`const Glib::RefPtr<const TlsCertificate>&',`Glib::wrap($3, true)')
+ _WRAP_SIGNAL(bool accept_certificate(const Glib::RefPtr<const TlsCertificate>& peer_cert, TlsCertificateFlags errors), "accept_certificate")
+
+ _WRAP_VFUNC(bool handshake(const Glib::RefPtr<Cancellable>& cancellable), "handshake", errthrow)
+ _WRAP_VFUNC(void handshake_async(const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.}, int io_priority{.} = Glib::PRIORITY_DEFAULT), "handshake_async", slot_name slot, slot_callback SignalProxy_async_callback)
+
+#m4 _CONVERSION(`GAsyncResult*',`const Glib::RefPtr<AsyncResult>&',`Glib::wrap($3, true)')
+ _WRAP_VFUNC(bool handshake_finish(const Glib::RefPtr<AsyncResult>& result), "handshake_finish", errthrow)
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+#include <giomm/cancellable.h>
+#include <giomm/socketconnectable.h>
+#include <giomm/tlscertificate.h>
+#include <giomm/tlsinteraction.h>
+#include "slot_async.h"
+
+namespace Gio
+{
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <giomm/asyncresult.h>
+#include <giomm/enums.h>
+#include <giomm/tlsfiledatabase.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gio
+{
+
+_WRAP_ENUM(TlsDatabaseVerifyFlags, GTlsDatabaseVerifyFlags)
+_WRAP_ENUM(TlsDatabaseLookupFlags, GTlsDatabaseLookupFlags)
+
+class Cancellable;
+class SocketConnectable;
+class TlsCertificate;
+class TlsInteraction;
+
+/** TlsDatabase - TLS database type.
+ * TlsDatabase is used to lookup certificates and other information from a
+ * certificate or key store. It is an abstract base class which TLS library
+ * specific subtypes override.
+ *
+ * Most common client applications will not directly interact with TlsDatabase.
+ * It is used internally by TlsConnection.
+ * @newin{2,36}
+ */
+class TlsDatabase : public Glib::Object, public TlsFileDatabase
+{
+ _CLASS_GOBJECT(TlsDatabase, GTlsDatabase, G_TLS_DATABASE, Glib::Object, GObject)
+ _IMPLEMENTS_INTERFACE(TlsFileDatabase)
+
+protected:
+ _CTOR_DEFAULT
+
+public:
+ //TODO?: Have a constant for the C macro G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER (which is a string)?
+ //TODO?: Have a constant for the C macro G_TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT (which is a string)?
+
+ _WRAP_METHOD(TlsCertificateFlags verify_chain(const Glib::RefPtr<TlsCertificate>& chain, const Glib::ustring& purpose, const Glib::RefPtr<const SocketConnectable>& identity{?}, const Glib::RefPtr<TlsInteraction>& interaction{?}, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseVerifyFlags flags{.} = TLS_DATABASE_VERIFY_NONE), g_tls_database_verify_chain, errthrow)
+ _WRAP_METHOD(void verify_chain_async(const Glib::RefPtr<TlsCertificate>& chain, const Glib::ustring& purpose, const Glib::RefPtr<const SocketConnectable>& identity{?}, const Glib::RefPtr<TlsInteraction>& interaction{?}, const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseVerifyFlags flags{.} = TLS_DATABASE_VERIFY_NONE), g_tls_database_verify_chain_async, slot_name slot, slot_callback SignalProxy_async_callback)
+ _WRAP_METHOD(TlsCertificateFlags verify_chain_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_database_verify_chain_finish, errthrow)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> lookup_certificate_issuer(const Glib::RefPtr<const TlsCertificate>& certificate, const Glib::RefPtr<TlsInteraction>& interaction, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE), g_tls_database_lookup_certificate_issuer, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<const TlsCertificate> lookup_certificate_issuer(const Glib::RefPtr<const TlsCertificate>& certificate, const Glib::RefPtr<TlsInteraction>& interaction, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE) const, g_tls_database_lookup_certificate_issuer, errthrow, constversion)
+
+ _WRAP_METHOD(void lookup_certificate_issuer_async(const Glib::RefPtr<const TlsCertificate>& certificate, const Glib::RefPtr<TlsInteraction>& interaction, const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE), g_tls_database_lookup_certificate_issuer_async, slot_name slot, slot_callback SignalProxy_async_callback)
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> lookup_certificate_issuer_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_database_lookup_certificate_issuer_finish, errthrow)
+
+ //TODO: _WRAP_METHOD(GList* lookup_certificates_issued_by(GByteArray* issuer_raw_dn, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable), g_tls_database_lookup_certificates_issued_by, errthrow)
+ //TODO: _WRAP_METHOD(void lookup_certificates_issued_by_async(GByteArray* issuer_raw_dn, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot, gpointer user_data), g_tls_database_lookup_certificates_issued_by_async)
+ //TODO: _WRAP_METHOD(GList* lookup_certificates_issued_by_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_database_lookup_certificates_issued_by_finish, errthrow)
+
+ _WRAP_METHOD(Glib::ustring create_certificate_handle(const Glib::RefPtr<const TlsCertificate>& certificate) const, g_tls_database_create_certificate_handle)
+
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> lookup_certificate_for_handle(const Glib::ustring& handle, const Glib::RefPtr<TlsInteraction>& interaction, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE), g_tls_database_lookup_certificate_for_handle, errthrow)
+ _WRAP_METHOD(Glib::RefPtr<const TlsCertificate> lookup_certificate_for_handle(const Glib::ustring& handle, const Glib::RefPtr<TlsInteraction>& interaction, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE) const, g_tls_database_lookup_certificate_for_handle, errthrow, constversion)
+
+ _WRAP_METHOD(void lookup_certificate_for_handle_async(const Glib::ustring& handle, const Glib::RefPtr<TlsInteraction>& interaction, const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.?}, TlsDatabaseLookupFlags flags{.} = TLS_DATABASE_LOOKUP_NONE), g_tls_database_lookup_certificate_for_handle_async, slot_name slot, slot_callback SignalProxy_async_callback)
+ _WRAP_METHOD(Glib::RefPtr<TlsCertificate> lookup_certificate_for_handle_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_database_lookup_certificate_for_handle_finish, errthrow)
+
+/* TODO:
+ _WRAP_VFUNC(TlsCertificateFlags verify_chain(const Glib::RefPtr<TlsCertificate>& chain, const Glib::ustring& purpose, const Glib::RefPtr<const SocketConnectable>& identity, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseVerifyFlags flags, const Glib::RefPtr<Cancellable>& cancellable), "verify_chain", errthrow)
+ _WRAP_VFUNC(void verify_chain_async(const Glib::RefPtr<TlsCertificate>& chain, const Glib::ustring& purpose, const Glib::RefPtr<const SocketConnectable>& identity, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseVerifyFlags flags, const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot, gpointer user_data), "verify_chain_async")
+ _WRAP_VFUNC(TlsCertificateFlags verify_chain_finish(const Glib::RefPtr<AsyncResult>& result), "verify_chain_finish", errthrow)
+ _WRAP_VFUNC(Glib::ustring create_certificate_handle(const Glib::RefPtr<TlsCertificate>& certificate), "create_certificate_handle")
+ _WRAP_VFUNC(Glib::RefPtr<TlsCertificate> lookup_certificate_for_handle(const Glib::ustring& handle, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable), "lookup_certificate_for_handle", errthrow)
+ _WRAP_VFUNC(void lookup_certificate_for_handle_async(const Glib::ustring& handle, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot, gpointer user_data), "lookup_certificate_for_handle_async")
+ _WRAP_VFUNC(Glib::RefPtr<TlsCertificate> lookup_certificate_for_handle_finish(const Glib::RefPtr<AsyncResult>& result), "lookup_certificate_for_handle_finish", errthrow)
+ _WRAP_VFUNC(Glib::RefPtr<TlsCertificate> lookup_certificate_issuer(const Glib::RefPtr<TlsCertificate>& certificate, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable), "lookup_certificate_issuer", errthrow)
+ _WRAP_VFUNC(void lookup_certificate_issuer_async(const Glib::RefPtr<TlsCertificate>& certificate, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot, gpointer user_data), "lookup_certificate_issuer_async")
+ _WRAP_VFUNC(Glib::RefPtr<TlsCertificate> lookup_certificate_issuer_finish(const Glib::RefPtr<AsyncResult>& result), "lookup_certificate_issuer_finish", errthrow)
+ _WRAP_VFUNC(GList* lookup_certificates_issued_by(GByteArray* issuer_raw_dn, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable), "lookup_certificates_issued_by", errthrow)
+ _WRAP_VFUNC(void lookup_certificates_issued_by_async(GByteArray* issuer_raw_dn, const Glib::RefPtr<TlsInteraction>& interaction, TlsDatabaseLookupFlags flags, const Glib::RefPtr<Cancellable>& cancellable, const SlotAsyncReady& slot, gpointer user_data), "lookup_certificates_issued_by_async")
+ _WRAP_VFUNC(GList* lookup_certificates_issued_by_finish(const Glib::RefPtr<AsyncResult>& result), "lookup_certificates_issued_by_finish", errthrow)
+*/
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+
+namespace Gio
+{
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/interface_p.h)
+_PINCLUDE(gio/gio.h)
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GTlsFileDatabaseInterface GTlsFileDatabaseInterface;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gio
+{
+
+/** TlsFileDatabase - TLS file based database type.
+ * TlsFileDatabase is implemented by TlsDatabase objects which load their
+ * certificate information from a file. It is in interface which TLS library
+ * specific subtypes implement.
+ * @newin{2,36}
+ */
+class TlsFileDatabase : public Glib::Interface
+{
+ _CLASS_INTERFACE(TlsFileDatabase, GTlsFileDatabase, G_TLS_FILE_DATABASE, GTlsFileDatabaseInterface)
+
+public:
+ //TODO: Wrap the the g_tls_file_database_new() C function which returns a
+ //GTlsDatabase* and does more than calling g_initable_new().
+
+ _WRAP_PROPERTY("anchors", Glib::ustring)
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
+#include <giomm/cancellable.h>
+#include <giomm/tlspassword.h>
+#include "slot_async.h"
+
+namespace Gio
+{
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+#include <giomm/asyncresult.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gio
+{
+
+_WRAP_ENUM(TlsInteractionResult, GTlsInteractionResult)
+
+class Cancellable;
+class TlsPassword;
+
+/** TlsInteraction - Interaction with the user during TLS operations.
+ * TlsInteraction provides a mechanism for the TLS connection and database code
+ * to interact with the user. It can be used to ask the user for passwords.
+ *
+ * To use a TlsInteraction with a TLS connection use
+ * Gio::TlsConnection::set_interaction().
+ *
+ * Callers should instantiate a derived class that implements the various
+ * interaction methods to show the required dialogs.
+ *
+ * Callers should use the 'invoke' functions like invoke_ask_password() to run
+ * interaction methods. These functions make sure that the interaction is
+ * invoked in the main loop and not in the current thread, if the current
+ * thread is not running the main loop.
+ *
+ * Derived classes can choose to implement whichever interactions methods
+ * they'd like to support by overriding those virtual methods. Any interactions
+ * not implemented will return Gio::TLS_INTERACTION_UNHANDLED. If a derived
+ * class implements an async method, it must also implement the corresponding
+ * finish method.
+ * @newin{2,36}
+ */
+class TlsInteraction : public Glib::Object
+{
+ _CLASS_GOBJECT(TlsInteraction, GTlsInteraction, G_TLS_INTERACTION, Glib::Object, GObject)
+
+protected:
+ _CTOR_DEFAULT
+
+public:
+ _WRAP_METHOD(TlsInteractionResult ask_password(const Glib::RefPtr<TlsPassword>& password, const Glib::RefPtr<Cancellable>& cancellable{?}), g_tls_interaction_ask_password, errthrow)
+ _WRAP_METHOD(void ask_password_async(const Glib::RefPtr<TlsPassword>& password, const SlotAsyncReady& slot{callback?}, const Glib::RefPtr<Cancellable>& cancellable{.?}), g_tls_interaction_ask_password_async, slot_name slot, slot_callback SignalProxy_async_callback)
+ _WRAP_METHOD(TlsInteractionResult ask_password_finish(const Glib::RefPtr<AsyncResult>& result), g_tls_interaction_ask_password_finish, errthrow)
+ _WRAP_METHOD(TlsInteractionResult invoke_ask_password(const Glib::RefPtr<TlsPassword>& password, const Glib::RefPtr<Cancellable>& cancellable{?}), g_tls_interaction_invoke_ask_password, errthrow)
+
+/* TODO:
+ _WRAP_VFUNC(TlsInteractionResult ask_password(const Glib::RefPtr<TlsPassword>& password, const Glib::RefPtr<Cancellable>& cancellable), "ask_password", errthrow)
+ _WRAP_VFUNC(void ask_password_async(const Glib::RefPtr<TlsPassword>& password, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable), "ask_password_async")
+ _WRAP_VFUNC(TlsInteractionResult ask_password_finish(const Glib::RefPtr<AsyncResult>& result), "ask_password_finish", errthrow)
+*/
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
--- /dev/null
+/* Copyright (C) 2012 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/object.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gio
+{
+
+_WRAP_ENUM(TlsPasswordFlags, GTlsPasswordFlags)
+
+/** TlsPassword - TLS Passwords for prompting.
+ * Holds a password used in TLS.
+ * @newin{2,36}
+ */
+class TlsPassword : public Glib::Object
+{
+ _CLASS_GOBJECT(TlsPassword, GTlsPassword, G_TLS_PASSWORD, Glib::Object, GObject)
+
+protected:
+ _WRAP_CTOR(TlsPassword(TlsPasswordFlags flags, const Glib::ustring& description), g_tls_password_new)
+
+public:
+ _WRAP_METHOD_DOCS_ONLY(g_tls_password_new)
+ _WRAP_CREATE(TlsPasswordFlags flags, const Glib::ustring& description)
+
+ _WRAP_METHOD(const guchar* get_value(gsize& length{?}) const, g_tls_password_get_value)
+ _WRAP_METHOD(void set_value(const guchar* value, gssize length = -1), g_tls_password_set_value)
+ // This function does not copy the value as g_tls_password_set_value() does.
+ // It keeps a reference to the original value and expects it to be freed
+ // later in a specified GDestroyNotify callback. Ignore it for now.
+ _IGNORE(g_tls_password_set_value_full)
+
+ _WRAP_METHOD(Glib::ustring get_description() const, g_tls_password_get_description)
+ _WRAP_METHOD(void set_description(const Glib::ustring& description), g_tls_password_set_description)
+
+ _WRAP_METHOD(TlsPasswordFlags get_flags() const, g_tls_password_get_flags)
+ _WRAP_METHOD(void set_flags(TlsPasswordFlags flags), g_tls_password_set_flags)
+
+ _WRAP_METHOD(Glib::ustring get_warning() const, g_tls_password_get_warning)
+ _WRAP_METHOD(void set_warning(const Glib::ustring& warning), g_tls_password_set_warning)
+
+ _WRAP_PROPERTY("description", Glib::ustring)
+ _WRAP_PROPERTY("flags", TlsPasswordFlags)
+ _WRAP_PROPERTY("warning", Glib::ustring)
+
+#m4 _CONVERSION(`gsize*', `gsize&', `*($3)')
+ _WRAP_VFUNC(const guchar* get_value(gsize& length) const, "get_value")
+
+ //TODO: _WRAP_VFUNC(void set_value(guchar* value, gssize length, GDestroyNotify destroy), "set_value")
+
+#m4 _CONVERSION(`Glib::ustring', `const gchar*', `g_strdup($3.c_str())')
+ _WRAP_VFUNC(Glib::ustring get_default_warning() const, "get_default_warning")
+};
+
+} // namespace Gio
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gio/gio.h>
--- /dev/null
+/* Copyright (C) 2013 The giomm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <glibmm/interface.h>
+#include <giomm/enums.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/interface_p.h)
+_PINCLUDE(gio/gio.h)
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GTlsServerConnectionInterface GTlsServerConnectionInterface;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gio
+{
+
+/** TlsServerConnection - TLS server-side connection.
+ * TlsServerConnection is the server-side subclass of TlsConnection,
+ * representing a server-side TLS connection.
+ * @newin{2,36}
+ */
+class TlsServerConnection : public Glib::Interface
+{
+ _CLASS_INTERFACE(TlsServerConnection, GTlsServerConnection, G_TLS_SERVER_CONNECTION, GTlsServerConnectionInterface)
+
+public:
+ //TODO: This new function creates an IOStream, not a TlsServerConnection:
+ //GIOStream* g_tls_server_connection_new(GIOStream *base_io_stream, GTlsCertificate *certificate, GError **error);
+
+ _WRAP_PROPERTY("authentication-mode", TlsAuthenticationMode)
+};
+
+} // namespace Gio
#include <gio/gio.h>
#include <gio/gunixconnection.h>
+#include "slot_async.h"
namespace Gio
{
+
+void UnixConnection::receive_credentials_async(const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_unix_connection_receive_credentials_async(gobj(),
+ Glib::unwrap(cancellable),
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
+void UnixConnection::receive_credentials_async(const SlotAsyncReady& slot)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_unix_connection_receive_credentials_async(gobj(),
+ 0,
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
+void
+UnixConnection::send_credentials_async(const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable)
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_unix_connection_send_credentials_async(gobj(),
+ Glib::unwrap(cancellable),
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
+void
+UnixConnection::send_credentials_async(const SlotAsyncReady& slot)
+
+{
+ SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+ g_unix_connection_send_credentials_async(gobj(),
+ 0,
+ &SignalProxy_async_callback,
+ slot_copy);
+}
+
} // namespace Gio
_WRAP_METHOD(Glib::RefPtr<Credentials> receive_credentials(const Glib::RefPtr<Cancellable>& cancellable{?}), g_unix_connection_receive_credentials, errthrow)
_WRAP_METHOD(Glib::RefPtr<const Credentials> receive_credentials(const Glib::RefPtr<Cancellable>& cancellable{?}) const, g_unix_connection_receive_credentials, errthrow, constversion)
+
+ /** Asynchronously receive credentials.
+ * For more details, see receive_credentials() which is the synchronous
+ * version of this call.
+ *
+ * When the operation is finished, @a slot will be called. You can then call
+ * receive_credentials_finish() to get the result of the operation.
+ *
+ * @param slot A SlotAsyncReady to call when the request is satisfied.
+ * @param cancellable A Cancellable object.
+ * @newin{2,36}
+ */
+ void receive_credentials_async(const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable);
+ _IGNORE(g_unix_connection_receive_credentials_async)
+
+ /// A non-cancellable version of receive_credentials_async().
+ void receive_credentials_async(const SlotAsyncReady& slot);
+
+ _WRAP_METHOD(Glib::RefPtr<Credentials> receive_credentials_finish(const Glib::RefPtr<AsyncResult>& result), g_unix_connection_receive_credentials_finish, errthrow)
+
_WRAP_METHOD(bool send_credentials(const Glib::RefPtr<Cancellable>& cancellable{?}), g_unix_connection_send_credentials, errthrow)
+
+ /** Asynchronously send credentials.
+ * For more details, see send_credentials() which is the synchronous version
+ * of this call.
+ *
+ * When the operation is finished, @a slot will be called. You can then call
+ * send_credentials_finish() to get the result of the operation.
+ *
+ * @param slot A SlotAsyncReady to call when the request is satisfied.
+ * @param cancellable A Cancellable object.
+ * @newin{2,36}
+ */
+ void send_credentials_async(const SlotAsyncReady& slot,
+ const Glib::RefPtr<Cancellable>& cancellable);
+ _IGNORE(g_unix_connection_send_credentials_async)
+
+ /// A non-cancellable version of send_credentials_async().
+ void send_credentials_async(const SlotAsyncReady& slot);
+
+ _WRAP_METHOD(bool send_credentials_finish(const Glib::RefPtr<AsyncResult>& result), g_unix_connection_send_credentials_finish, errthrow)
};
} // namespace Gio
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0, // mount_operation
Glib::unwrap(cancellable),
&SignalProxy_async_callback,
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0, // mount_operation
0, // cancellable
&SignalProxy_async_callback,
void Volume::eject(MountUnmountFlags flags)
{
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
0, // mount_operation
0, // cancellable
0, // callback
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
Glib::unwrap(mount_operation),
Glib::unwrap(cancellable),
&SignalProxy_async_callback,
SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
Glib::unwrap(mount_operation),
0, // cancellable
&SignalProxy_async_callback,
void Volume::eject(const Glib::RefPtr<MountOperation>& mount_operation, MountUnmountFlags flags)
{
g_volume_eject_with_operation(gobj(),
- static_cast<GMountUnmountFlags>(flags),
+ static_cast<GMountUnmountFlags>(flags),
Glib::unwrap(mount_operation),
0, // cancellable
0, // callback
class Drive;
/** The Volume interface represents user-visible objects that can be mounted.
- *
- * Mounting a Volume instance is an asynchronous operation. For more information about asynchronous operations, see AsyncReady and SimpleAsyncReady. To
+ *
+ * Mounting a Volume instance is an asynchronous operation. For more information about asynchronous operations, see AsyncReady and SimpleAsyncReady. To
* mount a GVolume, first call mount(), optionally providing a MountOperation object and a SlotAsyncReady callback.
- *
- * Typically, you will not want to provide a MountOperation if automounting all volumes when a desktop session starts since it's not desirable to
+ *
+ * Typically, you will not want to provide a MountOperation if automounting all volumes when a desktop session starts since it's not desirable to
* put up a lot of dialogs asking for credentials.
- *
- * The callback will be fired when the operation has resolved (either with success or failure), and a AsyncReady structure will be passed to the callback.
- * That callback should then call g_volume_mount_finish() with the GVolume instance and the GAsyncReady data to see if the operation was completed
+ *
+ * The callback will be fired when the operation has resolved (either with success or failure), and a AsyncReady structure will be passed to the callback.
+ * That callback should then call g_volume_mount_finish() with the GVolume instance and the GAsyncReady data to see if the operation was completed
* successfully. If an error is present when finish() is called, then it will be filled with any error information.
*
* @newin{2,16}
/** Mounts a volume.
* This is an asynchronous operation, and is finished by calling mount_finish() with the AsyncResult data returned in the callback slot.
*
+ * @param mount_operation A mount operation.
* @param slot A callback which will be called when the operation is completed or canceled.
* @param cancellable A cancellable object which can be used to cancel the operation.
- * @param mount_operation A mount operation.
+ * @param flags Flags affecting the operation.
*/
void mount(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Mounts a volume.
* This is an asynchronous operation, and is finished by calling mount_finish() with the AsyncResult data returned in the callback slot.
*
- * @param slot A callback which will be called when the operation is completed or canceled.
* @param mount_operation A mount operation.
+ * @param slot A callback which will be called when the operation is completed or canceled.
+ * @param flags Flags affecting the operation.
*/
void mount(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Mounts a volume.
- *
+ *
* @param mount_operation A mount operation.
+ * @param flags Flags affecting the operation.
*/
void mount(const Glib::RefPtr<MountOperation>& mount_operation, MountMountFlags flags = MOUNT_MOUNT_NONE);
/** Mounts a volume.
+ *
+ * @param flags Flags affecting the operation.
*/
void mount(MountMountFlags flags = MOUNT_MOUNT_NONE);
//_WRAP_VFUNC(bool can_mount(), can_mount)
//_WRAP_VFUNC(bool can_eject(), can_eject)
- //_WRAP_VFUNC(void mount_fn(GMountMountFlags flags, GMountOperation* mount_operation, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer user_data), mount_fn) //TODO: Rename to mount()?
+ //_WRAP_VFUNC(void mount_fn(GMountMountFlags flags, GMountOperation* mount_operation, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer user_data), mount_fn) //TODO: Rename to mount()?
//_WRAP_VFUNC(bool mount_finish(GAsyncResult* result, GError** error), mount_finish)
//_WRAP_VFUNC(void eject(GMountUnmountFlags flags, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer user_data), eject)
//_WRAP_VFUNC(bool eject_finish(GAsyncResult* result, GError** error), eject_finish)
-
+
//_WRAP_VFUNC(std::string get_identifier(const std::string& kind), get_identifier)
//TODO: Use an ArrayHandle.
namespace Container_Helpers
{
-/** This specialization of TypeTraits exists
- * because the default use of Glib::wrap(GObject*),
+/** This specialization of TypeTraits exists
+ * because the default use of Glib::wrap(GObject*),
* instead of a specific Glib::wrap(GSomeInterface*),
* would not return a wrapper for an interface.
- */
+ */
template <>
struct TypeTraits< Glib::RefPtr<Gio::Volume> >
{
static CppType to_cpp_type (const CType& item)
{
- //Use a specific Glib::wrap() function,
+ //Use a specific Glib::wrap() function,
//because CType has the specific type (not just GObject):
return Glib::wrap(item, true /* take_copy */);
}
{
/** Monitors a file or directory for changes.
- * VolumeMonitor is for listing the user-interesting devices and volumes on the
- * computer. In other words, what a file selector or file manager would show in
+ * VolumeMonitor is for listing the user-interesting devices and volumes on the
+ * computer. In other words, what a file selector or file manager would show in
* a sidebar.
*
* @newin{2,16}
//GTypeQuery::instance_size is guint but GTypeInfo::instance_size is guint16.
const guint16 instance_size =
(guint16)base_query.instance_size;
-
+
const GTypeInfo derived_info =
{
class_size,
}
gchar* derived_name = g_strconcat("gtkmm__", base_query.type_name, (void*)0);
-
+
if(module)
gtype_ = g_type_module_register_type(module, base_type, derived_name, &derived_info, GTypeFlags(0));
else
#include <glibmmconfig.h>
#include <glibmm/refptr.h>
#include <glibmm/ustring.h>
+#include <glibmm/variant.h>
#include <glibmm/wrap.h>
#include <glibmm/debug.h>
#include <glib-object.h>
/**
* @ingroup ContHandles
*/
-
+
//! Ownership of the container
-/*! Defines how and if the container will release the list and
- * its elemens when it is destroyed
+/*! Defines how and if the container will release the list and
+ * its elemens when it is destroyed
*/
enum OwnershipType
{
GObject* cobj = (GObject*)ptr;
return dynamic_cast<CppType>(Glib::wrap_auto(cobj, false /* take_copy */));
}
-
+
static void release_c_type (CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
};
//This confuse the SUN Forte compiler, so we ifdef it out:
-#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for pointers to const GtkObject instances.
* @ingroup ContHelpers
GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
return dynamic_cast<CppType>(Glib::wrap_auto(cobj, false /* take_copy */));
}
-
+
static void release_c_type (CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
return Glib::RefPtr<T>( dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
//We use dynamic_cast<> in case of multiple inheritance.
}
-
+
static void release_c_type (CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
return Glib::RefPtr<const T>( dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
//We use dynamic_cast<> in case of multiple inheritance.
}
-
+
static void release_c_type (CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
static void release_c_type (CType) {}
};
+/** Specialization for Glib::VariantBase.
+ * @ingroup ContHelpers
+ */
+template <>
+struct TypeTraits<Glib::VariantBase>
+{
+ typedef Glib::VariantBase CppType;
+ typedef GVariant * CType;
+ typedef GVariant * CTypeNonConst;
+
+ static CType to_c_type (const Glib::VariantBase& v)
+ { return const_cast<CTypeNonConst>(v.gobj()); }
+
+ static CType to_c_type (CType v) { return v; }
+
+ static CppType to_cpp_type(CType v)
+ { return Glib::VariantBase(v, true); }
+
+ static void release_c_type(CType v)
+ { g_variant_unref(const_cast<CTypeNonConst>(v)); }
+};
+
+/** Specialization for Glib::VariantContainerBase.
+ * @ingroup ContHelpers
+ */
+template <>
+struct TypeTraits<Glib::VariantContainerBase>
+{
+ typedef Glib::VariantContainerBase CppType;
+ typedef GVariant * CType;
+ typedef GVariant * CTypeNonConst;
+
+ static CType to_c_type (const Glib::VariantContainerBase& v)
+ { return const_cast<CTypeNonConst>(v.gobj()); }
+
+ static CType to_c_type (CType v) { return v; }
+
+ static CppType to_cpp_type(CType v)
+ { return Glib::VariantContainerBase(v, true); }
+
+ static void release_c_type(CType v)
+ { g_variant_unref(const_cast<CTypeNonConst>(v)); }
+};
+
+
#ifndef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
/* The STL containers in Sun's libCstd don't support templated sequence
typedef std::bidirectional_iterator_tag iterator_category;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
-
+
typedef typename List_Iterator_Base<T>::pointer pointer;
typedef typename List_Iterator_Base<T>::reference reference;
void init()
{
Glib::wrap_register_init();
- Glib::Error::register_init(); //also calls Glib::wrap_init();
+ Glib::Error::register_init(); //also calls Glib::wrap_init();
}
} // namespace Glib
typedef GTypeInterface BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
- /** Called by constructors of derived classes. Provide the result of
- * the Class object's init() function to ensure that it is properly
+ /** Called by constructors of derived classes. Provide the result of
+ * the Class object's init() function to ensure that it is properly
* initialized.
- *
+ *
* @param interface_class The Class object for the derived type.
*/
explicit Interface(const Glib::Interface_Class& interface_class);
/** Called by constructors of derived classes.
- *
- * @param cast_item A C instance that will be wrapped by the new
- * C++ instance. This does not take a reference, so call reference()
+ *
+ * @param castitem A C instance that will be wrapped by the new
+ * C++ instance. This does not take a reference, so call reference()
* if necessary.
*/
explicit Interface(GObject* castitem);
//TODO: Remove this when we can break glibmm API.
/** This is an intermediate type. When a method takes this, or returns this, you
- * should use a standard C++ container of your choice, such as std::list or
+ * should use a standard C++ container of your choice, such as std::list or
* std::vector.
*
- * However, this is not used in new API. We now prefer to just use std::vector,
+ * However, this is not used in new API. We now prefer to just use std::vector,
* which is less flexibile, but makes the API clearer.
*
* @ingroup ContHandles
return 0;
}
-/* Only used by SignalTimeout::connect_once() and SignalIdle::connect_once().
- * These don't use Glib::Source, to avoid the unnecessary overhead
- * of a completely unused wrapper object.
+/* Only used by SignalTimeout::connect_once(), SignalTimeout::connect_seconds_once()
+ * and SignalIdle::connect_once(). These don't use Glib::Source, to avoid the
+ * unnecessary overhead of a completely unused wrapper object.
*/
static gboolean glibmm_source_callback_once(void* data)
{
conn_node->install(source);
g_source_attach(source, context);
- g_source_unref(source);
+ g_source_unref(source); // GMainContext holds a reference
}
} // anonymous namespace
source, &glibmm_source_callback, conn_node,
&SourceConnectionNode::destroy_notify_callback);
+ conn_node->install(source);
g_source_attach(source, context_);
g_source_unref(source); // GMainContext holds a reference
- conn_node->install(source);
return connection;
}
source, &glibmm_source_callback, conn_node,
&SourceConnectionNode::destroy_notify_callback);
+ conn_node->install(source);
g_source_attach(source, context_);
g_source_unref(source); // GMainContext holds a reference
- conn_node->install(source);
return connection;
}
source, &glibmm_source_callback, conn_node,
&SourceConnectionNode::destroy_notify_callback);
+ conn_node->install(source);
g_source_attach(source, context_);
g_source_unref(source); // GMainContext holds a reference
- conn_node->install(source);
return connection;
}
source, (GSourceFunc)&glibmm_child_watch_callback, conn_node,
&SourceConnectionNode::destroy_notify_callback);
+ conn_node->install(source);
g_source_attach(source, context_);
g_source_unref(source); // GMainContext holds a reference
- conn_node->install(source);
return connection;
}
GPollFD gobject_;
};
+// Concerning SignalTimeout::connect_once(), SignalTimeout::connect_seconds_once()
+// and SignalIdle::connect_once():
+// See https://bugzilla.gnome.org/show_bug.cgi?id=396963 and
+// http://bugzilla.gnome.org/show_bug.cgi?id=512348 about the sigc::trackable issue.
+// It's recommended to replace sigc::slot<void>& by std::function<void()>& in
+// Threads::Thread::create() and ThreadPool::push() at the next ABI break.
+// Such a replacement would be a mixed blessing in SignalTimeout and SignalIdle.
+// In a single-threaded program auto-disconnection of trackable slots is safe
+// and can be useful.
class SignalTimeout
{
* timeout_source->connect(sigc::ptr_fun(&timeout_handler));
* timeout_source->attach(Glib::MainContext::get_default());
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalTimeout
+ * object's MainContext runs.
+ *
* @param slot A slot to call when @a interval has elapsed.
* If <tt>timeout_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* @param interval The timeout in milliseconds.
sigc::connection connect(const sigc::slot<bool>& slot, unsigned int interval,
int priority = PRIORITY_DEFAULT);
- /** Connects a timeout handler that runs only once.
- * This method takes a function pointer to a function with a void return
- * and no parameters. After running once it is not called again.
- *
- * @see connect()
- * @param slot A slot to call when @a interval has elapsed. For example:
- * @code
- * void on_timeout_once()
- * @endcode
- * @param interval The timeout in milliseconds.
- * @param priority The priority of the new event source.
- */
+ /** Connects a timeout handler that runs only once.
+ * This method takes a function pointer to a function with a void return
+ * and no parameters. After running once it is not called again.
+ *
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static method of a class deriving from sigc::trackable, and the slot is
+ * created by sigc::mem_fun(), connect_once() should only be called from
+ * the thread where the SignalTimeout object's MainContext runs. You can use,
+ * say, boost::bind() or, in C++11, std::bind() or a C++11 lambda expression
+ * instead of sigc::mem_fun().
+ *
+ * @see connect()
+ * @param slot A slot to call when @a interval has elapsed. For example:
+ * @code
+ * void on_timeout_once()
+ * @endcode
+ * @param interval The timeout in milliseconds.
+ * @param priority The priority of the new event source.
+ */
void connect_once(const sigc::slot<void>& slot, unsigned int interval,
int priority = PRIORITY_DEFAULT);
* timeout_source->connect(sigc::ptr_fun(&timeout_handler));
* timeout_source->attach(Glib::MainContext::get_default());
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalTimeout
+ * object's MainContext runs.
+ *
* @param slot A slot to call when @a interval has elapsed.
* If <tt>timeout_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* @param interval The timeout in seconds.
sigc::connection connect_seconds(const sigc::slot<bool>& slot, unsigned int interval,
int priority = PRIORITY_DEFAULT);
- /** Connects a timeout handler that runs only once with whole second
- * granularity.
- *
- * This method takes a function pointer to a function with a void return
- * and no parameters. After running once it is not called again.
- *
- * @see connect_seconds()
- * @param slot A slot to call when @a interval has elapsed. For example:
- * @code
- * void on_timeout_once()
- * @endcode
- * @param interval The timeout in seconds.
- * @param priority The priority of the new event source.
- */
+ /** Connects a timeout handler that runs only once with whole second
+ * granularity.
+ *
+ * This method takes a function pointer to a function with a void return
+ * and no parameters. After running once it is not called again.
+ *
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static method of a class deriving from sigc::trackable, and the slot is
+ * created by sigc::mem_fun(), connect_seconds_once() should only be called from
+ * the thread where the SignalTimeout object's MainContext runs. You can use,
+ * say, boost::bind() or, in C++11, std::bind() or a C++11 lambda expression
+ * instead of sigc::mem_fun().
+ *
+ * @see connect_seconds()
+ * @param slot A slot to call when @a interval has elapsed. For example:
+ * @code
+ * void on_timeout_once()
+ * @endcode
+ * @param interval The timeout in seconds.
+ * @param priority The priority of the new event source.
+ */
void connect_seconds_once(const sigc::slot<void>& slot, unsigned int interval,
int priority = PRIORITY_DEFAULT);
* idle_source->connect(sigc::ptr_fun(&idle_handler));
* idle_source->attach(Glib::MainContext::get_default());
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalIdle
+ * object's MainContext runs.
+ *
* @param slot A slot to call when the main loop is idle.
* If <tt>idle_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* @param priority The priority of the new event source.
*/
sigc::connection connect(const sigc::slot<bool>& slot, int priority = PRIORITY_DEFAULT_IDLE);
- /** Connects an idle handler that runs only once.
- * This method takes a function pointer to a function with a void return
- * and no parameters. After running once it is not called again.
- *
- * @see connect()
- * @param slot A slot to call when the main loop is idle. For example:
- * @code
- * void on_idle_once()
- * @endcode
- * @param priority The priority of the new event source.
- */
+ /** Connects an idle handler that runs only once.
+ * This method takes a function pointer to a function with a void return
+ * and no parameters. After running once it is not called again.
+ *
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static method of a class deriving from sigc::trackable, and the slot is
+ * created by sigc::mem_fun(), connect_once() should only be called from
+ * the thread where the SignalIdle object's MainContext runs. You can use,
+ * say, boost::bind() or, in C++11, std::bind() or a C++11 lambda expression
+ * instead of sigc::mem_fun().
+ *
+ * @see connect()
+ * @param slot A slot to call when the main loop is idle. For example:
+ * @code
+ * void on_idle_once()
+ * @endcode
+ * @param priority The priority of the new event source.
+ */
void connect_once(const sigc::slot<void>& slot, int priority = PRIORITY_DEFAULT_IDLE);
private:
* io_source->connect(sigc::ptr_fun(&io_handler));
* io_source->attach(Glib::MainContext::get_default());
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalIO
+ * object's MainContext runs.
+ *
* @param slot A slot to call when polling @a fd results in an event that matches @a condition.
* The event will be passed as a parameter to @a slot.
* If <tt>io_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* io_source->connect(sigc::ptr_fun(&io_handler));
* io_source->attach(Glib::MainContext::get_default());
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalIO
+ * object's MainContext runs.
+ *
* @param slot A slot to call when polling @a channel results in an event that matches @a condition.
* The event will be passed as a parameter to @a slot.
* If <tt>io_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* void child_watch_handler(GPid pid, int child_status) { ... }
* Glib::signal_child_watch().connect(sigc::ptr_fun(&child_watch_handler), pid);
* @endcode
+ *
+ * This method is not thread-safe. You should call it, or manipulate the
+ * returned sigc::connection object, only from the thread where the SignalChildWatch
+ * object's MainContext runs.
+ *
* @param slot A slot to call when child process @a pid exited.
* @param pid The child process to watch for.
* @param priority The priority of the new event source.
return Glib::RefPtr<T>( dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
//We use dynamic_cast<> in case of multiple inheritance.
}
-
+
static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
return Glib::RefPtr<const T>( dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
//We use dynamic_cast<> in case of multiple inheritance.
}
-
+
static void release_c_type (CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(0, ptr);
CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-//The SUN Forte Compiler has a problem with this:
+//The SUN Forte Compiler has a problem with this:
# ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for RefPtr<> to const Glib::Object.
// which will contain a switch/case statement which will examine the property name.
const Glib::ustring notify_signal_name = "notify::" + property_name;
pConnectionNode->connection_id_ = g_signal_connect_data(gobj(),
- notify_signal_name.c_str(), (GCallback)(&PropertyProxyConnectionNode::callback), pConnectionNode,
+ notify_signal_name.c_str(), (GCallback)(&PropertyProxyConnectionNode::callback), pConnectionNode,
&PropertyProxyConnectionNode::destroy_notify_handler,
G_CONNECT_AFTER);
/** This default constructor is called implicitly from the constructor of user-derived
* classes, even if, for instance, Gtk::Button calls a different ObjectBase constructor.
* This is normal behaviour for C++ virtual inheritance.
- *
+ *
* The GType name will be gtkmm__anonymous_custom_type.
*/
ObjectBase();
/** A derived constructor always overrides this choice.
* The C++ language itself ensures that the constructor
* is only invoked once.
- *
+ *
* All classes generated by gtkmmproc use this constructor, with custom_type_name = 0,
* which essentially means it's not a custom type. This is used to optimize
* vfunc and signal handler callbacks -- since the C++ virtual methods are
template <class PropertyType>
void get_property(const Glib::ustring& property_name, PropertyType& value) const;
- /** You can use the signal_changed() signal of the property proxy instead,
+ /** You can use the signal_changed() signal of the property proxy instead,
* but this is necessary when using the reduced API.
*
* See also connect_property_changed_with_return().
*/
void connect_property_changed(const Glib::ustring& property_name, const sigc::slot<void>& slot);
- /** You can use the signal_changed() signal of the property proxy instead,
+ /** You can use the signal_changed() signal of the property proxy instead,
* but this is necessary when using the reduced API.
*
- * This method was added because connect_property_changed() does not return a sigc::connection,
+ * This method was added because connect_property_changed() does not return a sigc::connection,
* and we could not break the ABI by changing that function.
*/
sigc::connection connect_property_changed_with_return(const Glib::ustring& property_name, const sigc::slot<void>& slot);
*/
void freeze_notify();
- /**
+ /**
* Reverts the effect of a previous call to freeze_notify(). The freeze count
* is decreased on object and when it reaches zero, all queued "notify"
* signals are emitted.
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
/** This is the base class for Glib::Object properties.
- *
+ *
* This class manages the generic parts of the object properties.
- * Derived (templated) classes handle the specific value types.
+ * Derived (templated) classes handle the specific value types.
*/
class PropertyBase
{
/** Returns the name of the property.
*/
Glib::ustring get_name() const;
-
+
/** Notifies the object containing the property that the property has changed.
* This emits the "notify" signal, passing the property name.
*/
GParamSpec* param_spec_;
/** This constructs a property of type @a value_type for the @a object.
- * The property is not registered in the GObject object system
+ * The property is not registered in the GObject object system
* until install_property() has been called. Derived classes do this in
* their constructors.
*
* Checks if the property has already been installed.
*/
bool lookup_property(const Glib::ustring& name);
-
+
/**
* Installs the property specified by the given @a param_spec.
*/
};
/** A Glib::Object property.
- *
+ *
* This class wraps a GObject property, providing a C++ API to the GObject property
* system, for use with classes derived from Glib::Object or Glib::Interface.
*
* * A short description.
* * The default value and the minimum and maximum bounds (depending on the type of the property).
* * Flags, defining, among other things, whether the property can be read or written.
- *
+ *
* This Property class currently supports only the name and default value. The
* minimum and maximum bounds are set to the full range of the value. The nick
* and the explanation are set to empty. The flags are set to indicate that the
* property can be both read from and written to.
- *
- * The class information must be installed into the GObject system once per
+ *
+ * The class information must be installed into the GObject system once per
* property, but this is handled automatically.
- *
+ *
* A property can be used only as direct data member of a type, inheriting from
* Glib::Object. A reference to the object must be passed to the constructor of
* the property.
* For each instance of the object, the same property must be constructed with the same name
*/
Property(Glib::Object& object, const Glib::ustring& name);
-
+
/** Constructs a property of the @a object with the specified @a name and @a default_value.
* For each instance of the object, the same property must be constructed with the same name.
*/
* The object containing the property will be notified about the change.
*/
inline void set_value(const PropertyType& data);
-
+
/** Returns the value of the property.
*/
inline PropertyType get_value() const;
* The object containing the property will be notified about the change.
*/
inline Property<T>& operator=(const PropertyType& data);
-
+
/** Returns the value of the property.
*/
inline operator PropertyType() const;
*
* You may also receive notification when a property's value changes, by connecting to signal_changed().
*
- * You may register new properties for your class (actually for the underlying GType)
+ * You may register new properties for your class (actually for the underlying GType)
* simply by adding a PropertyProxy instance as a class member.
- * However, your constructor must call the Glib::ObjectBase constructor with a new GType name,
+ * However, your constructor must call the Glib::ObjectBase constructor with a new GType name,
* in order to register a new GType.
*/
template <class T>
return value.get();
}
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
+//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
//to avoid code duplication.
//But the AIX compiler does not like that hack.
template <class T>
set_property_(value);
}
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
+//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
//to avoid code duplication.
//But the AIX compiler does not like that hack.
template <class T>
{
QueryQuark::QueryQuark(const GQuark& q)
- : quark_(q)
+ : quark_(q)
{}
QueryQuark::QueryQuark(const ustring& s)
namespace Glib
{
-/** Quarks are unique IDs in Glib for strings for use in
+/** Quarks are unique IDs in Glib for strings for use in
* hash table lookups. Each Quark is unique but may change
* between runs.
*
- * QueryQuark is a converter class for looking up but not
+ * QueryQuark is a converter class for looking up but not
* allocating an ID. An id means the quark lookup failed.
*
* Quark is used for actions for which the id should live on
* Afterwards it will be null and use of -> will cause a segmentation fault.
*/
inline RefPtr();
-
+
/// Destructor - decrements reference count.
inline ~RefPtr();
/// Tests whether the RefPtr<> point to the same underlying instance.
inline bool operator==(const RefPtr<T_CppObject>& src) const;
-
+
/// See operator==().
inline bool operator!=(const RefPtr<T_CppObject>& src) const;
/** Static cast to derived class.
*
- * Like the dynamic cast; the notation is
+ * Like the dynamic cast; the notation is
* @code
* ptr_derived = RefPtr<Derived>::cast_static(ptr_base);
* @endcode
template <class T_CastFrom>
static inline RefPtr<T_CppObject> cast_const(const RefPtr<T_CastFrom>& src);
- //TODO: Maybe remove these if we replace operator bool() with operator const void* after
+ //TODO: Maybe remove these if we replace operator bool() with operator const void* after
//an API/ABI break, as suggested by Daniel Elstner? murrayc.
//See bug https://bugzilla.gnome.org/show_bug.cgi?id=626858
{
GObject* o = conn->object_;
conn->object_ = 0;
-
+
if(g_signal_handler_is_connected(o, conn->connection_id_)) //We check first, because during destruction, GTK+ sometimes seems to disconnect them for us, before we expect it to. See bug #87912
{
// Disconnecting triggers execution of destroy_notify_handler(), eiter immediately or later:
// In that case, destroy_notify_handler() will be called after this whole function has returned.
// Anyway. destroy_notify_handler() will always be called, so we leave that to do the deletion.
-
+
//Forget the connection:
gulong connection_id = conn->connection_id_;
conn->connection_id_ = 0;
-
+
g_signal_handler_disconnect(o, connection_id);
}
}
{
//glib calls this when it has finished with a glib signal connection,
//either when the emitting object dies, or when the connection has been disconnected.
-
+
// notification from gtk+.
SignalProxyConnectionNode* conn = static_cast<SignalProxyConnectionNode*>(data);
//TODO: Remove this when we can break glibmm API.
/** This is an intermediate type. When a method takes this, or returns this, you
- * should use a standard C++ container of your choice, such as std::list or
+ * should use a standard C++ container of your choice, such as std::list or
* std::vector.
*
- * However, this is not used in new API. We now prefer to just use std::vector,
+ * However, this is not used in new API. We now prefer to just use std::vector,
* which is less flexibile, but makes the API clearer.
* @ingroup ContHandles
*/
std::string::size_type& end_index,
std::string::size_type start_index = 0);
-/** Converts a <tt>double</tt> to a string, using the <tt>'.'</tt> as decimal point.
+/** Converts a <tt>double</tt> to a string, using the @c '.' as decimal point.
* @ingroup StringUtils
* This functions generates enough precision that converting the string back
* using Glib::Ascii::strtod() gives the same machine-number (on machines with
explicit ThreadPool(int max_threads = -1, bool exclusive = false);
virtual ~ThreadPool();
+ //See http://bugzilla.gnome.org/show_bug.cgi?id=512348 about the sigc::trackable issue.
+ // TODO: At the next ABI break, consider changing const sigc::slot<void>& slot
+ // to const std::function<void()>& func, if it can be assumed that all supported
+ // compilers understand the C++11 template class std::function<>.
/** Inserts @a slot into the list of tasks to be executed by the pool.
* When the number of currently running threads is lower than the maximal
* allowed number of threads, a new thread is started (or reused). Otherwise
* @a slot stays in the queue until a thread in this pool finishes its
* previous task and processes @a slot.
+ *
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static class method and is created by sigc::mem_fun(), the class concerned
+ * should not derive from sigc::trackable. You can use, say, boost::bind() or,
+ * in C++11, std::bind() or a C++11 lambda expression instead of sigc::mem_fun().
+ *
* @param slot A new task for the thread pool.
* @throw Glib::ThreadError An error can only occur when a new thread
* couldn't be created. In that case @a slot is simply appended to the
{
g_get_current_time(this);
}
-
+
bool TimeVal::assign_from_iso8601(const Glib::ustring& iso_date)
{
return g_time_val_from_iso8601(iso_date.c_str(), this);
}
void TimeVal::add_microseconds(long microseconds)
-{
+{
g_time_val_add(this, microseconds);
}
inline TimeVal& operator=(const GTimeVal& gtimeval);
/** Assigns the current time to the TimeVal instance.
- * Equivalent to the UNIX gettimeofday() function, but is portable and
- * works also on Win32.
+ * Equivalent to the UNIX gettimeofday() function, but is portable and
+ * works also on Win32.
*/
void assign_current_time();
-
+
/** Converts a string containing an ISO 8601 encoded date and time
* to a Glib::TimeVal and puts it in TimeVal instance.
* @param iso_date ISO 8601 encoded string.
{ return TimeVal(lhs) += rhs; }
/** @relates Glib::TimeVal */
-inline
+inline
TimeVal operator+(const TimeVal& lhs, long seconds)
{ return TimeVal(lhs) += seconds; }
/** @relates Glib::TimeVal */
-inline
+inline
TimeVal operator-(const TimeVal& lhs, const TimeVal& rhs)
{ return TimeVal(lhs) -= rhs; }
/** @relates Glib::TimeVal */
-inline
+inline
TimeVal operator-(const TimeVal& lhs, long seconds)
{ return TimeVal(lhs) -= seconds; }
{
#ifndef GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS
-// Initialize static member here,
+// Initialize static member here,
// because the compiler did not allow us do it inline.
const ustring::size_type ustring::npos = std::string::npos;
#endif
* @par
* The stream I/O operators, that is operator<<() and operator>>(), perform
* implicit charset conversion to/from the current locale. If that's not
- * what you intented (e.g. when writing to a configuration file that should
+ * what you intended (e.g. when writing to a configuration file that should
* always be UTF-8 encoded) use ustring::raw() to override this behaviour.
* @par
* If you're using std::ostringstream to build strings for display in the
* user interface, you must convert the result back to UTF-8 as shown below:
* @code
+ * std::locale::global(std::locale("")); // set the global locale to the user's preferred locale
* std::ostringstream output;
- * output.imbue(std::locale("")); // use the user's locale for this stream
* output << percentage << " % done";
* label->set_text(Glib::locale_to_utf8(output.str()));
* @endcode
protected:
void set_boxed(const void* data);
- void* get_boxed() const; // doesn't copy
+ void* get_boxed() const; // doesn't copy
};
CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-//The SUN Forte Compiler has a problem with this:
+//The SUN Forte Compiler has a problem with this:
#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for RefPtr<> to const Glib::Object.
inline CppType get_(void*) const;
};
-
+
/** Generic value implementation for custom types.
* @ingroup glibmmValue
* Any type to be used with this template must implement:
typedef typename Tr::CppType CppType;
typedef typename Tr::CType CType;
- /** Constructs an ArrayKeeper holding @a array of size @array_size.
+ /** Constructs an ArrayKeeper holding @a array of size @a array_size.
* @a ownership tells what should be destroyed with keeper destruction:
* <ul>
* <li>Glib::OWNERSHIP_NONE - keeper won't destroy data it holds.</li>
void wrap_register_init()
{
- g_type_init();
+ // g_type_init() is deprecated as of 2.36.
+ // g_type_init();
if(!Glib::quark_)
{
{
found = (ifaces[n_ifaces] == interface_type);
}
-
+
g_free (ifaces);
return found;
{
// Look up the wrap table index stored in the type's static data.
// If a wrap_new() has been registered for the type then call it.
- // But only if the type implements the interface,
+ // But only if the type implements the interface,
// so that the C++ instance is likely to inherit from the appropriate class too.
//
const gpointer idx = g_type_get_qdata(type, Glib::quark_);
pCppObject = wrap_create_new_wrapper_for_interface(object, TInterface::get_base_type());
}
- //If no exact wrapper was created,
- //create an instance of the interface,
+ //If no exact wrapper was created,
+ //create an instance of the interface,
//so we at least get the expected type:
TInterface* result = 0;
if(pCppObject)
* - less than operator
* - greater than operator
*
- * @newin2p24
+ * @newin{2,24}
*/
template <typename K, typename V>
class BalancedTree
* that have a larger key.
*
* @param search_func A function used to search the BalancedTree.
- * @result the value corresponding to the found key, or %NULL if the key
+ * @param key The key to search for.
+ * @result The value corresponding to the found key, or <tt>0</tt> if the key
* was not found.
*/
V* search(const CompareFunc &search_func, const K& key)
* that have a larger key.
*
* @param search_func A function used to search the BalancedTree.
- * @result the value corresponding to the found key, or %NULL if the key
+ * @param key The key to search for.
+ * @result The value corresponding to the found key, or <tt>0</tt> if the key
* was not found.
*/
const V* search(const CompareFunc &search_func, const K& key) const
public:
static Glib::RefPtr<Glib::Bytes> create(gconstpointer data, gsize size);
-
+
_WRAP_METHOD(gconstpointer get_data(gsize& size) const, g_bytes_get_data)
_WRAP_METHOD(gsize get_size() const, g_bytes_get_size)
return g_checksum_type_get_length((GChecksumType)checksum_type);
}
-std::string Checksum::compute_checksum(ChecksumType type, const std::string& data)
+std::string Checksum::compute_checksum(ChecksumType checksum_type, const std::string& data)
{
- return Glib::convert_return_gchar_ptr_to_ustring(g_compute_checksum_for_string(((GChecksumType)type), data.c_str(), data.size()));
+ return Glib::convert_return_gchar_ptr_to_ustring(g_compute_checksum_for_string(((GChecksumType)checksum_type), data.c_str(), data.size()));
}
void Checksum::update(const std::string& data)
{
- g_checksum_update(gobj(), (const guchar*)data.c_str(), data.size());
+ g_checksum_update(gobj(), (const guchar*)data.c_str(), data.size());
}
} // Glib namespace
-
-
{
/** Computes the checksum for data.
- * This is a generic API for computing checksums (or "digests") for a sequence of arbitrary bytes,
+ * This is a generic API for computing checksums (or "digests") for a sequence of arbitrary bytes,
* using various hashing algorithms like MD5, SHA-1 and SHA-256. Checksums are commonly used in various environments and specifications.
*
- * glibmm supports incremental checksums by calling update() as long as there's data available and then using get_string()
- * or get_digest() to compute the checksum and return it either as a string in hexadecimal form, or as a raw sequence of bytes.
+ * glibmm supports incremental checksums by calling update() as long as there's data available and then using get_string()
+ * or get_digest() to compute the checksum and return it either as a string in hexadecimal form, or as a raw sequence of bytes.
* To compute the checksum for binary blobs and NULL-terminated strings in one go, use the static compute_checksum() convenience functions().
*
* @newin{2,16}
* The hashing algorithm to be used by Checksum when performing the
* digest of some data.
*
- * Note that the ChecksumType enumeration may be extended at a later
- * date to include new hashing algorithm types.
+ * Note that the ChecksumType enumeration may be extended at a later
+ * date to include new hashing algorithm types.
*
* @newin{2,16}
*/
#m4 _CONVERSION(`ChecksumType', `GChecksumType', `(($2)$3)')
- /** Creates a new Checksum, using the checksum algorithm @a checksum_type.
+ /** Creates a new Checksum, using the checksum algorithm @a checksum_type.
* If the checksum_type is not known, then operator bool() will return false.
*
- * @param type checksum type, one of defined above.
+ * @param checksum_type Checksum type, one of defined above.
*/
explicit Checksum(ChecksumType checksum_type);
operator bool() const;
_WRAP_METHOD(void reset(), g_checksum_reset)
-
+
//TODO: length should really be gssize, not gsize, when we can break ABI:
#m4 _CONVERSION(`gsize',`gssize',`(gssize)($3)')
_WRAP_METHOD(void update(const guchar* data, gsize length), g_checksum_update)
/** Feeds data into an existing Checksum.
* The checksum must still be open, that is get_string() or get_digest() must not have been called on the checksum.
- *
+ *
* @param data Buffer used to compute the checksum
*/
void update(const std::string& data);
_WRAP_METHOD(std::string get_string() const, g_checksum_get_string)
-
- _WRAP_METHOD(static std::string compute_checksum(ChecksumType type, const guchar* data, gsize length), g_compute_checksum_for_data)
+
+ _WRAP_METHOD(static std::string compute_checksum(ChecksumType checksum_type, const guchar* data, gsize length), g_compute_checksum_for_data)
/** Computes the checksum of a string.
- *
+ *
* @param checksum_type A ChecksumType
* @param str The string to compute the checksum of.
* @result The checksum as a hexadecimal string.
*/
- static std::string compute_checksum(ChecksumType type, const std::string& str);
+ static std::string compute_checksum(ChecksumType checksum_type, const std::string& str);
_IGNORE(g_compute_checksum_for_string)
Glib::ustring filename_display_basename(const std::string& filename)
{
char *const buf = g_filename_display_basename(filename.c_str());
-
+
return Glib::ustring(ScopedPtr<char>(buf).get());
}
Glib::ustring filename_display_name(const std::string& filename)
{
char *const buf = g_filename_display_name(filename.c_str());
-
+
return Glib::ustring(ScopedPtr<char>(buf).get());
}
} // namespace Glib
-
*/
Glib::ustring filename_display_basename(const std::string& filename);
-/** Converts a filename into a valid UTF-8 string. The
- * conversion is not necessarily reversible, so you
+/** Converts a filename into a valid UTF-8 string. The
+ * conversion is not necessarily reversible, so you
* should keep the original around and use the return
* value of this function only for display purposes.
- * Unlike g_filename_to_utf8(), the result is guaranteed
+ * Unlike g_filename_to_utf8(), the result is guaranteed
* to be non-empty even if the filename actually isn't in the GLib
* file name encoding.
*
_WRAP_METHOD(DateTime add_minutes(int minutes) const, g_date_time_add_minutes)
_WRAP_METHOD(DateTime add_seconds(double seconds) const, g_date_time_add_seconds)
_WRAP_METHOD(DateTime add_full(int years, int months, int days, int hours, int minutes, double seconds) const, g_date_time_add_full)
+
+ /** Calculates the difference in time between @a *this and @a other. The
+ * TimeSpan that is returned is effectively @a *this - @a other.
+ *
+ * @newin{2,26}
+ * @param other The other DateTime.
+ * @return The difference between the two DateTime, as a time
+ * span expressed in microseconds.
+ */
_WRAP_METHOD(TimeSpan difference(const DateTime& other) const, g_date_time_difference)
#m4 _CONVERSION(`const DateTime&',`gconstpointer',`static_cast<gconstpointer>(&($3))')
+ /** A comparison function for DateTimes that is suitable
+ * as a CompareFunc.
+ *
+ * @newin{2,26}
+ * @param other The DateTime to compare with.
+ * @return -1, 0 or 1 if @a *this is less than, equal to or greater
+ * than @a other.
+ */
_WRAP_METHOD(int compare(const DateTime& other) const, g_date_time_compare)
+
_WRAP_METHOD(guint hash() const, g_date_time_hash)
+
+ /** Checks to see if @a *this and @a other are equal.
+ *
+ * Equal here means that they represent the same moment after converting
+ * them to the same time zone.
+ *
+ * @newin{2,26}
+ * @param other The DateTime to compare with.
+ * @return <tt>true</tt> if @a *this and @a other are equal.
+ */
_WRAP_METHOD(bool equal(const DateTime& other) const, g_date_time_equal)
_WRAP_METHOD(void get_ymd(int& year, int& month, int& day) const, g_date_time_get_ymd)
* file which is then renamed to the final name. Notes:
* <ol>
* <li>
- * On Unix, if @a filename already exists hard links to @filename will break.
+ * On Unix, if @a filename already exists hard links to @a filename will break.
* Also since the file is recreated, existing permissions, access control
- * lists, metadata etc. may be lost. If @filename is a symbolic link,
+ * lists, metadata etc. may be lost. If @a filename is a symbolic link,
* the link itself will be replaced, not the linked file.
* </li>
* <li>
* <li>
* On Windows there is no way to remove a file that is open to some
* process, or mapped into memory. Thus, this function will fail if
- * @filename already exists and is open.
+ * @a filename already exists and is open.
* </li>
* </ol>
*
<root>
+<enum name="GBindingFlags">
+<description>
+Flags to be passed to g_object_bind_property() or
+g_object_bind_property_full().
+
+This enumeration can be extended at later date.
+
+Since: 2.26
+
+</description>
+<parameters>
+<parameter name="G_BINDING_DEFAULT">
+<parameter_description> The default binding; if the source property
+changes, the target property is updated with its value.
+</parameter_description>
+</parameter>
+<parameter name="G_BINDING_BIDIRECTIONAL">
+<parameter_description> Bidirectional binding; if either the
+property of the source or the property of the target changes,
+the other is updated.
+</parameter_description>
+</parameter>
+<parameter name="G_BINDING_SYNC_CREATE">
+<parameter_description> Synchronize the values of the source and
+target properties when creating the binding; the direction of
+the synchronization is always from the source to the target.
+</parameter_description>
+</parameter>
+<parameter name="G_BINDING_INVERT_BOOLEAN">
+<parameter_description> If the two properties being bound are
+booleans, setting one to %TRUE will result in the other being
+set to %FALSE and vice versa. This flag will only work for
+boolean properties, and cannot be used when passing custom
+transformation functions to g_object_bind_property_full().
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GBookmarkFileError">
+<description>
+Error codes returned by bookmark file parsing.
+
+</description>
+<parameters>
+<parameter name="G_BOOKMARK_FILE_ERROR_INVALID_URI">
+<parameter_description> URI was ill-formed
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_INVALID_VALUE">
+<parameter_description> a requested field was not found
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED">
+<parameter_description> a requested application did
+not register a bookmark
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND">
+<parameter_description> a requested URI was not found
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_READ">
+<parameter_description> document was ill formed
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING">
+<parameter_description> the text being parsed was
+in an unknown encoding
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_WRITE">
+<parameter_description> an error occurred while writing
+</parameter_description>
+</parameter>
+<parameter name="G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND">
+<parameter_description> requested file was not found
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GChecksumType">
+<description>
+The hashing algorithm to be used by #GChecksum when performing the
+digest of some data.
+
+Note that the #GChecksumType enumeration may be extended at a later
+date to include new hashing algorithm types.
+
+Since: 2.16
+
+</description>
+<parameters>
+<parameter name="G_CHECKSUM_MD5">
+<parameter_description> Use the MD5 hashing algorithm
+</parameter_description>
+</parameter>
+<parameter name="G_CHECKSUM_SHA1">
+<parameter_description> Use the SHA-1 hashing algorithm
+</parameter_description>
+</parameter>
+<parameter name="G_CHECKSUM_SHA256">
+<parameter_description> Use the SHA-256 hashing algorithm
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GConnectFlags">
+<description>
+The connection flags are used to specify the behaviour of a signal's
+connection.
+
+</description>
+<parameters>
+<parameter name="G_CONNECT_AFTER">
+<parameter_description> whether the handler should be called before or after the
+default handler of the signal.
+</parameter_description>
+</parameter>
+<parameter name="G_CONNECT_SWAPPED">
+<parameter_description> whether the instance and data should be swapped when
+calling the handler.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GConvertError">
+<description>
+Error codes returned by character set conversion routines.
+
+</description>
+<parameters>
+<parameter name="G_CONVERT_ERROR_NO_CONVERSION">
+<parameter_description> Conversion between the requested character
+sets is not supported.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERT_ERROR_ILLEGAL_SEQUENCE">
+<parameter_description> Invalid byte sequence in conversion input.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERT_ERROR_FAILED">
+<parameter_description> Conversion failed for some reason.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERT_ERROR_PARTIAL_INPUT">
+<parameter_description> Partial character sequence at end of input.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERT_ERROR_BAD_URI">
+<parameter_description> URI is invalid.
+</parameter_description>
+</parameter>
+<parameter name="G_CONVERT_ERROR_NOT_ABSOLUTE_PATH">
+<parameter_description> Pathname is not an absolute path.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDateDMY">
+<description>
+This enumeration isn't used in the API, but may be useful if you need
+to mark a number as a day, month, or year.
+
+</description>
+<parameters>
+<parameter name="G_DATE_DAY">
+<parameter_description> a day
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_MONTH">
+<parameter_description> a month
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_YEAR">
+<parameter_description> a year
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDateMonth">
+<description>
+Enumeration representing a month; values are #G_DATE_JANUARY,
+#G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value.
+
+</description>
+<parameters>
+<parameter name="G_DATE_BAD_MONTH">
+<parameter_description> invalid value
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_JANUARY">
+<parameter_description> January
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_FEBRUARY">
+<parameter_description> February
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_MARCH">
+<parameter_description> March
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_APRIL">
+<parameter_description> April
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_MAY">
+<parameter_description> May
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_JUNE">
+<parameter_description> June
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_JULY">
+<parameter_description> July
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_AUGUST">
+<parameter_description> August
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_SEPTEMBER">
+<parameter_description> September
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_OCTOBER">
+<parameter_description> October
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_NOVEMBER">
+<parameter_description> November
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_DECEMBER">
+<parameter_description> December
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GDateWeekday">
+<description>
+Enumeration representing a day of the week; #G_DATE_MONDAY,
+#G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday.
+
+</description>
+<parameters>
+<parameter name="G_DATE_BAD_WEEKDAY">
+<parameter_description> invalid value
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_MONDAY">
+<parameter_description> Monday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_TUESDAY">
+<parameter_description> Tuesday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_WEDNESDAY">
+<parameter_description> Wednesday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_THURSDAY">
+<parameter_description> Thursday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_FRIDAY">
+<parameter_description> Friday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_SATURDAY">
+<parameter_description> Saturday
+</parameter_description>
+</parameter>
+<parameter name="G_DATE_SUNDAY">
+<parameter_description> Sunday
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GErrorType">
+<description>
+The possible errors, used in the @v_error field
+of #GTokenValue, when the token is a %G_TOKEN_ERROR.
+
+</description>
+<parameters>
+<parameter name="G_ERR_UNKNOWN">
+<parameter_description> unknown error
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_UNEXP_EOF">
+<parameter_description> unexpected end of file
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_UNEXP_EOF_IN_STRING">
+<parameter_description> unterminated string constant
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_UNEXP_EOF_IN_COMMENT">
+<parameter_description> unterminated comment
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_NON_DIGIT_IN_CONST">
+<parameter_description> non-digit character in a number
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_DIGIT_RADIX">
+<parameter_description> digit beyond radix in a number
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_FLOAT_RADIX">
+<parameter_description> non-decimal floating point number
+</parameter_description>
+</parameter>
+<parameter name="G_ERR_FLOAT_MALFORMED">
+<parameter_description> malformed floating point number
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileError">
+<description>
+Values corresponding to @errno codes returned from file operations
+on UNIX. Unlike @errno codes, GFileError values are available on
+all systems, even Windows. The exact meaning of each code depends
+on what sort of file operation you were performing; the UNIX
+documentation gives more details. The following error code descriptions
+come from the GNU C Library manual, and are under the copyright
+of that manual.
+
+It's not very portable to make detailed assumptions about exactly
+which errors will be returned from a given operation. Some errors
+don't occur on some systems, etc., sometimes there are subtle
+differences in when a system will report a given error, etc.
+
+</description>
+<parameters>
+<parameter name="G_FILE_ERROR_EXIST">
+<parameter_description> Operation not permitted; only the owner of
+the file (or other resource) or processes with special privileges
+can perform the operation.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_ISDIR">
+<parameter_description> File is a directory; you cannot open a directory
+for writing, or create or remove hard links to it.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_ACCES">
+<parameter_description> Permission denied; the file permissions do not
+allow the attempted operation.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NAMETOOLONG">
+<parameter_description> Filename too long.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NOENT">
+<parameter_description> No such file or directory. This is a "file
+doesn't exist" error for ordinary files that are referenced in
+contexts where they are expected to already exist.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NOTDIR">
+<parameter_description> A file that isn't a directory was specified when
+a directory is required.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NXIO">
+<parameter_description> No such device or address. The system tried to
+use the device represented by a file you specified, and it
+couldn't find the device. This can mean that the device file was
+installed incorrectly, or that the physical device is missing or
+not correctly attached to the computer.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NODEV">
+<parameter_description> The underlying file system of the specified file
+does not support memory mapping.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_ROFS">
+<parameter_description> The directory containing the new link can't be
+modified because it's on a read-only file system.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_TXTBSY">
+<parameter_description> Text file busy.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_FAULT">
+<parameter_description> You passed in a pointer to bad memory.
+(GLib won't reliably return this, don't pass in pointers to bad
+memory.)
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_LOOP">
+<parameter_description> Too many levels of symbolic links were encountered
+in looking up a file name. This often indicates a cycle of symbolic
+links.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NOSPC">
+<parameter_description> No space left on device; write operation on a
+file failed because the disk is full.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NOMEM">
+<parameter_description> No memory available. The system cannot allocate
+more virtual memory because its capacity is full.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_MFILE">
+<parameter_description> The current process has too many files open and
+can't open any more. Duplicate descriptors do count toward this
+limit.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NFILE">
+<parameter_description> There are too many distinct file openings in the
+entire system.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_BADF">
+<parameter_description> Bad file descriptor; for example, I/O on a
+descriptor that has been closed or reading from a descriptor open
+only for writing (or vice versa).
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_INVAL">
+<parameter_description> Invalid argument. This is used to indicate
+various kinds of problems with passing the wrong argument to a
+library function.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_PIPE">
+<parameter_description> Broken pipe; there is no process reading from the
+other end of a pipe. Every library function that returns this
+error code also generates a `SIGPIPE' signal; this signal
+terminates the program if not handled or blocked. Thus, your
+program will never actually see this code unless it has handled
+or blocked `SIGPIPE'.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_AGAIN">
+<parameter_description> Resource temporarily unavailable; the call might
+work if you try again later.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_INTR">
+<parameter_description> Interrupted function call; an asynchronous signal
+occurred and prevented completion of the call. When this
+happens, you should try the call again.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_IO">
+<parameter_description> Input/output error; usually used for physical read
+or write errors. i.e. the disk or other physical device hardware
+is returning errors.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_PERM">
+<parameter_description> Operation not permitted; only the owner of the
+file (or other resource) or processes with special privileges can
+perform the operation.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_NOSYS">
+<parameter_description> Function not implemented; this indicates that
+the system is missing some functionality.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_ERROR_FAILED">
+<parameter_description> Does not correspond to a UNIX error code; this
+is the standard "failed for unspecified reason" error code present
+in all #GError error code enumerations. Returned if no specific
+code applies.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFileTest">
+<description>
+A test to perform on a file using g_file_test().
+
+</description>
+<parameters>
+<parameter name="G_FILE_TEST_IS_REGULAR">
+<parameter_description> %TRUE if the file is a regular file
+(not a directory). Note that this test will also return %TRUE
+if the tested file is a symlink to a regular file.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TEST_IS_SYMLINK">
+<parameter_description> %TRUE if the file is a symlink.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TEST_IS_DIR">
+<parameter_description> %TRUE if the file is a directory.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TEST_IS_EXECUTABLE">
+<parameter_description> %TRUE if the file is executable.
+</parameter_description>
+</parameter>
+<parameter name="G_FILE_TEST_EXISTS">
+<parameter_description> %TRUE if the file exists. It may or may not
+be a regular file.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GFormatSizeFlags">
+<description>
+Flags to modify the format of the string returned by g_format_size_full().
+
+</description>
+<parameters>
+<parameter name="G_FORMAT_SIZE_DEFAULT">
+<parameter_description> behave the same as g_format_size()
+</parameter_description>
+</parameter>
+<parameter name="G_FORMAT_SIZE_LONG_FORMAT">
+<parameter_description> include the exact number of bytes as part
+of the returned string. For example, "45.6 kB (45,612 bytes)".
+</parameter_description>
+</parameter>
+<parameter name="G_FORMAT_SIZE_IEC_UNITS">
+<parameter_description> use IEC (base 1024) units with "KiB"-style
+suffixes. IEC units should only be used for reporting things with
+a strong "power of 2" basis, like RAM sizes or RAID stripe sizes.
+Network and storage sizes should be reported in the normal SI units.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GHookFlagMask">
+<description>
+Flags used internally in the #GHook implementation.
+
+</description>
+<parameters>
+<parameter name="G_HOOK_FLAG_ACTIVE">
+<parameter_description> set if the hook has not been destroyed
+</parameter_description>
+</parameter>
+<parameter name="G_HOOK_FLAG_IN_CALL">
+<parameter_description> set if the hook is currently being run
+</parameter_description>
+</parameter>
+<parameter name="G_HOOK_FLAG_MASK">
+<parameter_description> A mask covering all bits reserved for
+hook flags; see %G_HOOK_FLAG_USER_SHIFT
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOChannelError">
+<description>
+Error codes returned by #GIOChannel operations.
+
+</description>
+<parameters>
+<parameter name="G_IO_CHANNEL_ERROR_FBIG">
+<parameter_description> File too large.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_INVAL">
+<parameter_description> Invalid argument.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_IO">
+<parameter_description> IO error.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_ISDIR">
+<parameter_description> File is a directory.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_NOSPC">
+<parameter_description> No space left on device.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_NXIO">
+<parameter_description> No such device or address.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_OVERFLOW">
+<parameter_description> Value too large for defined datatype.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_PIPE">
+<parameter_description> Broken pipe.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_CHANNEL_ERROR_FAILED">
+<parameter_description> Some other error.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOCondition">
+<description>
+A bitwise combination representing a condition to watch for on an
+event source.
+
+</description>
+<parameters>
+<parameter name="G_IO_IN">
+<parameter_description> There is data to read.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_OUT">
+<parameter_description> Data can be written (without blocking).
+</parameter_description>
+</parameter>
+<parameter name="G_IO_PRI">
+<parameter_description> There is urgent data to read.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERR">
+<parameter_description> Error condition.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_HUP">
+<parameter_description> Hung up (the connection has been broken, usually for
+pipes and sockets).
+</parameter_description>
+</parameter>
+<parameter name="G_IO_NVAL">
+<parameter_description> Invalid request. The file descriptor is not open.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOError">
+<description>
+#GIOError is only used by the deprecated functions
+g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
+
+</description>
+<parameters>
+<parameter name="G_IO_ERROR_NONE">
+<parameter_description> no error
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_AGAIN">
+<parameter_description> an EAGAIN error occurred
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_INVAL">
+<parameter_description> an EINVAL error occurred
+</parameter_description>
+</parameter>
+<parameter name="G_IO_ERROR_UNKNOWN">
+<parameter_description> another error occurred
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOFlags">
+<description>
+Specifies properties of a #GIOChannel. Some of the flags can only be
+read with g_io_channel_get_flags(), but not changed with
+g_io_channel_set_flags().
+
+</description>
+<parameters>
+<parameter name="G_IO_FLAG_APPEND">
+<parameter_description> turns on append mode, corresponds to <literal>O_APPEND</literal>
+(see the documentation of the UNIX open()
+syscall).
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_NONBLOCK">
+<parameter_description> turns on nonblocking mode, corresponds to
+<literal>O_NONBLOCK</literal>/<literal>O_NDELAY</literal>
+(see the documentation of the UNIX open() syscall).
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_IS_READABLE">
+<parameter_description> indicates that the io channel is readable.
+This flag cannot be changed.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_IS_WRITABLE">
+<parameter_description> indicates that the io channel is writable.
+This flag cannot be changed.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_IS_SEEKABLE">
+<parameter_description> indicates that the io channel is seekable,
+i.e. that g_io_channel_seek_position() can
+be used on it. This flag cannot be changed.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_MASK">
+<parameter_description> the mask that specifies all the valid flags.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_GET_MASK">
+<parameter_description> the mask of the flags that are returned from
+g_io_channel_get_flags().
+</parameter_description>
+</parameter>
+<parameter name="G_IO_FLAG_SET_MASK">
+<parameter_description> the mask of the flags that the user can modify
+with g_io_channel_set_flags().
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GIOStatus">
+<description>
+Stati returned by most of the #GIOFuncs functions.
+
+</description>
+<parameters>
+<parameter name="G_IO_STATUS_ERROR">
+<parameter_description> An error occurred.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STATUS_NORMAL">
+<parameter_description> Success.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STATUS_EOF">
+<parameter_description> End of file.
+</parameter_description>
+</parameter>
+<parameter name="G_IO_STATUS_AGAIN">
+<parameter_description> Resource temporarily unavailable.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GKeyFileError">
+<description>
+Error codes returned by key file parsing.
+
+</description>
+<parameters>
+<parameter name="G_KEY_FILE_ERROR_UNKNOWN_ENCODING">
+<parameter_description> the text being parsed was in
+an unknown encoding
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_ERROR_PARSE">
+<parameter_description> document was ill-formed
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_ERROR_NOT_FOUND">
+<parameter_description> the file was not found
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_ERROR_KEY_NOT_FOUND">
+<parameter_description> a requested key was not found
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_ERROR_GROUP_NOT_FOUND">
+<parameter_description> a requested group was not found
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_ERROR_INVALID_VALUE">
+<parameter_description> a value could not be parsed
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GKeyFileFlags">
+<description>
+Flags which influence the parsing.
+
+</description>
+<parameters>
+<parameter name="G_KEY_FILE_NONE">
+<parameter_description> No flags, default behaviour
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_KEEP_COMMENTS">
+<parameter_description> Use this flag if you plan to write the
+(possibly modified) contents of the key file back to a file;
+otherwise all comments will be lost when the key file is
+written back.
+</parameter_description>
+</parameter>
+<parameter name="G_KEY_FILE_KEEP_TRANSLATIONS">
+<parameter_description> Use this flag if you plan to write the
+(possibly modified) contents of the key file back to a file;
+otherwise only the translations for the current language will be
+written back.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GLogLevelFlags">
+<description>
+Flags specifying the level of log messages.
+
+It is possible to change how GLib treats messages of the various
+levels using g_log_set_handler() and g_log_set_fatal_mask().
+
+</description>
+<parameters>
+<parameter name="G_LOG_FLAG_RECURSION">
+<parameter_description> internal flag
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_FLAG_FATAL">
+<parameter_description> internal flag
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_ERROR">
+<parameter_description> log level for errors, see g_error().
+This level is also used for messages produced by g_assert().
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_CRITICAL">
+<parameter_description> log level for critical messages, see g_critical().
+This level is also used for messages produced by g_return_if_fail()
+and g_return_val_if_fail().
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_WARNING">
+<parameter_description> log level for warnings, see g_warning()
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_MESSAGE">
+<parameter_description> log level for messages, see g_message()
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_INFO">
+<parameter_description> log level for informational messages
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_DEBUG">
+<parameter_description> log level for debug messages, see g_debug()
+</parameter_description>
+</parameter>
+<parameter name="G_LOG_LEVEL_MASK">
+<parameter_description> a mask including all log levels
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GMarkupCollectType">
+<description>
+A mixed enumerated type and flags field. You must specify one type
+(string, strdup, boolean, tristate). Additionally, you may optionally
+bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
+
+It is likely that this enum will be extended in the future to
+support other types.
+
+</description>
+<parameters>
+<parameter name="G_MARKUP_COLLECT_INVALID">
+<parameter_description> used to terminate the list of attributes
+to collect
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_COLLECT_STRING">
+<parameter_description> collect the string pointer directly from
+the attribute_values[] array. Expects a parameter of type (const
+char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the
+attribute isn't present then the pointer will be set to %NULL
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_COLLECT_STRDUP">
+<parameter_description> as with %G_MARKUP_COLLECT_STRING, but
+expects a parameter of type (char **) and g_strdup()s the
+returned pointer. The pointer must be freed with g_free()
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_COLLECT_BOOLEAN">
+<parameter_description> expects a parameter of type (gboolean *)
+and parses the attribute value as a boolean. Sets %FALSE if the
+attribute isn't present. Valid boolean values consist of
+(case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
+"yes", "y", "1"
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_COLLECT_TRISTATE">
+<parameter_description> as with %G_MARKUP_COLLECT_BOOLEAN, but
+in the case of a missing attribute a value is set that compares
+equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is
+implied
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_COLLECT_OPTIONAL">
+<parameter_description> can be bitwise ORed with the other fields.
+If present, allows the attribute not to appear. A default value
+is set depending on what value type is used
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GMarkupError">
+<description>
+Error codes returned by markup parsing.
+
+</description>
+<parameters>
+<parameter name="G_MARKUP_ERROR_BAD_UTF8">
+<parameter_description> text being parsed was not valid UTF-8
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_EMPTY">
+<parameter_description> document contained nothing, or only whitespace
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_PARSE">
+<parameter_description> document was ill-formed
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_UNKNOWN_ELEMENT">
+<parameter_description> error should be set by #GMarkupParser
+functions; element wasn't known
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE">
+<parameter_description> error should be set by #GMarkupParser
+functions; attribute wasn't known
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_INVALID_CONTENT">
+<parameter_description> error should be set by #GMarkupParser
+functions; content was invalid
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_ERROR_MISSING_ATTRIBUTE">
+<parameter_description> error should be set by #GMarkupParser
+functions; a required attribute was missing
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GMarkupParseFlags">
+<description>
+Flags that affect the behaviour of the parser.
+
+</description>
+<parameters>
+<parameter name="G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG">
+<parameter_description> flag you should not use
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_TREAT_CDATA_AS_TEXT">
+<parameter_description> When this flag is set, CDATA marked
+sections are not passed literally to the @passthrough function of
+the parser. Instead, the content of the section (without the
+<literal><![CDATA[</literal> and <literal>]]></literal>) is
+passed to the @text function. This flag was added in GLib 2.12
+</parameter_description>
+</parameter>
+<parameter name="G_MARKUP_PREFIX_ERROR_POSITION">
+<parameter_description> Normally errors caught by GMarkup
+itself have line/column information prefixed to them to let the
+caller know the location of the error. When this flag is set the
+location information is also prefixed to errors generated by the
+#GMarkupParser implementation functions
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GModuleFlags">
+<description>
+Flags passed to g_module_open().
+Note that these flags are not supported on all platforms.
+
+</description>
+<parameters>
+<parameter name="G_MODULE_BIND_LAZY">
+<parameter_description> specifies that symbols are only resolved when
+needed. The default action is to bind all symbols when the module
+is loaded.
+</parameter_description>
+</parameter>
+<parameter name="G_MODULE_BIND_LOCAL">
+<parameter_description> specifies that symbols in the module should
+not be added to the global name space. The default action on most
+platforms is to place symbols in the module in the global name space,
+which may cause conflicts with existing symbols.
+</parameter_description>
+</parameter>
+<parameter name="G_MODULE_BIND_MASK">
+<parameter_description> mask for all flags.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GNormalizeMode">
+<description>
+Defines how a Unicode string is transformed in a canonical
+form, standardizing such issues as whether a character with
+an accent is represented as a base character and combining
+accent or as a single precomposed character. Unicode strings
+should generally be normalized before comparing them.
+
+</description>
+<parameters>
+<parameter name="G_NORMALIZE_DEFAULT">
+<parameter_description> standardize differences that do not affect the
+text content, such as the above-mentioned accent representation
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_NFD">
+<parameter_description> another name for %G_NORMALIZE_DEFAULT
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_DEFAULT_COMPOSE">
+<parameter_description> like %G_NORMALIZE_DEFAULT, but with
+composed forms rather than a maximally decomposed form
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_NFC">
+<parameter_description> another name for %G_NORMALIZE_DEFAULT_COMPOSE
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_ALL">
+<parameter_description> beyond %G_NORMALIZE_DEFAULT also standardize the
+"compatibility" characters in Unicode, such as SUPERSCRIPT THREE
+to the standard forms (in this case DIGIT THREE). Formatting
+information may be lost but for most text operations such
+characters should be considered the same
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_NFKD">
+<parameter_description> another name for %G_NORMALIZE_ALL
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_ALL_COMPOSE">
+<parameter_description> like %G_NORMALIZE_ALL, but with composed
+forms rather than a maximally decomposed form
+</parameter_description>
+</parameter>
+<parameter name="G_NORMALIZE_NFKC">
+<parameter_description> another name for %G_NORMALIZE_ALL_COMPOSE
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
<signal name="GObject::notify">
<description>
-The notify signal is emitted on an object when one of its
-properties has been changed. Note that getting this signal
-doesn't guarantee that the value of the property has actually
-changed, it may also be emitted when the setter for the property
-is called to reinstate the previous value.
+The notify signal is emitted on an object when one of its
+properties has been changed. Note that getting this signal
+doesn't guarantee that the value of the property has actually
+changed, it may also be emitted when the setter for the property
+is called to reinstate the previous value.
+
+This signal is typically used to obtain change notification for a
+single property, by specifying the property name as a detail in the
+g_signal_connect() call, like this:
+|[
+g_signal_connect (text_view->buffer, "notify::paste-target-list",
+G_CALLBACK (gtk_text_view_target_list_notify),
+text_view)
+]|
+It is important to note that you must use
+<link linkend="canonical-parameter-name">canonical</link> parameter names as
+detail strings for the notify signal.
+
+</description>
+<parameters>
+<parameter name="gobject">
+<parameter_description> the object which received the signal.
+</parameter_description>
+</parameter>
+<parameter name="pspec">
+<parameter_description> the #GParamSpec of the property which changed.
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</signal>
+
+<enum name="GOnceStatus">
+<description>
+The possible statuses of a one-time initialization function
+controlled by a #GOnce struct.
+
+Since: 2.4
+
+</description>
+<parameters>
+<parameter name="G_ONCE_STATUS_NOTCALLED">
+<parameter_description> the function has not been called yet.
+</parameter_description>
+</parameter>
+<parameter name="G_ONCE_STATUS_PROGRESS">
+<parameter_description> the function call is currently in progress.
+</parameter_description>
+</parameter>
+<parameter name="G_ONCE_STATUS_READY">
+<parameter_description> the function has been called.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GOptionArg">
+<description>
+The #GOptionArg enum values determine which type of extra argument the
+options expect to find. If an option expects an extra argument, it
+can be specified in several ways; with a short option:
+<option>-x arg</option>, with a long option: <option>--name arg</option>
+or combined in a single argument: <option>--name=arg</option>.
+
+</description>
+<parameters>
+<parameter name="G_OPTION_ARG_NONE">
+<parameter_description> No extra argument. This is useful for simple flags.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_STRING">
+<parameter_description> The option takes a string argument.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_INT">
+<parameter_description> The option takes an integer argument.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_CALLBACK">
+<parameter_description> The option provides a callback to parse the
+extra argument.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_FILENAME">
+<parameter_description> The option takes a filename as argument.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_STRING_ARRAY">
+<parameter_description> The option takes a string argument, multiple
+uses of the option are collected into an array of strings.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_FILENAME_ARRAY">
+<parameter_description> The option takes a filename as argument,
+multiple uses of the option are collected into an array of strings.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_DOUBLE">
+<parameter_description> The option takes a double argument. The argument
+can be formatted either for the user's locale or for the "C" locale. Since 2.12
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ARG_INT64">
+<parameter_description> The option takes a 64-bit integer. Like %G_OPTION_ARG_INT
+but for larger numbers. The number can be in decimal base, or in hexadecimal
+(when prefixed with <literal>0x</literal>, for example, <literal>0xffffffff</literal>).
+Since 2.12
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GOptionError">
+<description>
+Error codes returned by option parsing.
+
+</description>
+<parameters>
+<parameter name="G_OPTION_ERROR_UNKNOWN_OPTION">
+<parameter_description> An option was not known to the parser.
+This error will only be reported, if the parser hasn't been instructed
+to ignore unknown options, see g_option_context_set_ignore_unknown_options().
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ERROR_BAD_VALUE">
+<parameter_description> A value couldn't be parsed.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_ERROR_FAILED">
+<parameter_description> A #GOptionArgFunc callback failed.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GOptionFlags">
+<description>
+Flags which modify individual options.
+
+</description>
+<parameters>
+<parameter name="G_OPTION_FLAG_HIDDEN">
+<parameter_description> The option doesn't appear in <option>--help</option>
+output.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_IN_MAIN">
+<parameter_description> The option appears in the main section of the
+<option>--help</option> output, even if it is defined in a group.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_REVERSE">
+<parameter_description> For options of the %G_OPTION_ARG_NONE kind, this flag
+indicates that the sense of the option is reversed.
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_NO_ARG">
+<parameter_description> For options of the %G_OPTION_ARG_CALLBACK kind,
+this flag indicates that the callback does not take any argument
+(like a %G_OPTION_ARG_NONE option). Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_FILENAME">
+<parameter_description> For options of the %G_OPTION_ARG_CALLBACK
+kind, this flag indicates that the argument should be passed to the
+callback in the GLib filename encoding rather than UTF-8. Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_OPTIONAL_ARG">
+<parameter_description> For options of the %G_OPTION_ARG_CALLBACK
+kind, this flag indicates that the argument supply is optional. If no argument
+is given then data of %GOptionParseFunc will be set to NULL. Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_OPTION_FLAG_NOALIAS">
+<parameter_description> This flag turns off the automatic conflict resolution
+which prefixes long option names with <literal>groupname-</literal> if
+there is a conflict. This option should only be used in situations where
+aliasing is necessary to model some legacy commandline interface. It is
+not safe to use this option, unless all option groups are under your
+direct control. Since 2.8.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GParamFlags">
+<description>
+Through the #GParamFlags flag values, certain aspects of parameters
+can be configured.
+
+</description>
+<parameters>
+<parameter name="G_PARAM_READABLE">
+<parameter_description> the parameter is readable
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_WRITABLE">
+<parameter_description> the parameter is writable
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_CONSTRUCT">
+<parameter_description> the parameter will be set upon object construction
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_CONSTRUCT_ONLY">
+<parameter_description> the parameter will only be set upon object construction
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_LAX_VALIDATION">
+<parameter_description> upon parameter conversion (see g_param_value_convert())
+strict validation is not required
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_STATIC_NAME">
+<parameter_description> the string used as name when constructing the
+parameter is guaranteed to remain valid and
+unmodified for the lifetime of the parameter.
+Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_STATIC_NICK">
+<parameter_description> the string used as nick when constructing the
+parameter is guaranteed to remain valid and
+unmmodified for the lifetime of the parameter.
+Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_STATIC_BLURB">
+<parameter_description> the string used as blurb when constructing the
+parameter is guaranteed to remain valid and
+unmodified for the lifetime of the parameter.
+Since 2.8
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_PRIVATE">
+<parameter_description> internal
+</parameter_description>
+</parameter>
+<parameter name="G_PARAM_DEPRECATED">
+<parameter_description> the parameter is deprecated and will be removed
+in a future version. A warning will be generated if it is used
+while running with G_ENABLE_DIAGNOSTIC=1.
+Since 2.26
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GRegexCompileFlags">
+<description>
+Flags specifying compile-time options.
+
+Since: 2.14
+
+</description>
+<parameters>
+<parameter name="G_REGEX_CASELESS">
+<parameter_description> Letters in the pattern match both upper- and
+lowercase letters. This option can be changed within a pattern
+by a "(?i)" option setting.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MULTILINE">
+<parameter_description> By default, GRegex treats the strings as consisting
+of a single line of characters (even if it actually contains
+newlines). The "start of line" metacharacter ("^") matches only
+at the start of the string, while the "end of line" metacharacter
+("$") matches only at the end of the string, or before a terminating
+newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When
+#G_REGEX_MULTILINE is set, the "start of line" and "end of line"
+constructs match immediately following or immediately before any
+newline in the string, respectively, as well as at the very start
+and end. This can be changed within a pattern by a "(?m)" option
+setting.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_DOTALL">
+<parameter_description> A dot metacharater (".") in the pattern matches all
+characters, including newlines. Without it, newlines are excluded.
+This option can be changed within a pattern by a ("?s") option setting.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_EXTENDED">
+<parameter_description> Whitespace data characters in the pattern are
+totally ignored except when escaped or inside a character class.
+Whitespace does not include the VT character (code 11). In addition,
+characters between an unescaped "#" outside a character class and
+the next newline character, inclusive, are also ignored. This can
+be changed within a pattern by a "(?x)" option setting.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ANCHORED">
+<parameter_description> The pattern is forced to be "anchored", that is,
+it is constrained to match only at the first matching point in the
+string that is being searched. This effect can also be achieved by
+appropriate constructs in the pattern itself such as the "^"
+metacharater.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_DOLLAR_ENDONLY">
+<parameter_description> A dollar metacharacter ("$") in the pattern
+matches only at the end of the string. Without this option, a
+dollar also matches immediately before the final character if
+it is a newline (but not before any other newlines). This option
+is ignored if #G_REGEX_MULTILINE is set.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_UNGREEDY">
+<parameter_description> Inverts the "greediness" of the quantifiers so that
+they are not greedy by default, but become greedy if followed by "?".
+It can also be set by a "(?U)" option setting within the pattern.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_RAW">
+<parameter_description> Usually strings must be valid UTF-8 strings, using this
+flag they are considered as a raw sequence of bytes.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_NO_AUTO_CAPTURE">
+<parameter_description> Disables the use of numbered capturing
+parentheses in the pattern. Any opening parenthesis that is not
+followed by "?" behaves as if it were followed by "?:" but named
+parentheses can still be used for capturing (and they acquire numbers
+in the usual way).
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_OPTIMIZE">
+<parameter_description> Optimize the regular expression. If the pattern will
+be used many times, then it may be worth the effort to optimize it
+to improve the speed of matches.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_FIRSTLINE">
+<parameter_description> Limits an unanchored pattern to match before (or at) the
+first newline. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_DUPNAMES">
+<parameter_description> Names used to identify capturing subpatterns need not
+be unique. This can be helpful for certain types of pattern when it
+is known that only one instance of the named subpattern can ever be
+matched.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_NEWLINE_CR">
+<parameter_description> Usually any newline character or character sequence is
+recognized. If this option is set, the only recognized newline character
+is '\r'.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_NEWLINE_LF">
+<parameter_description> Usually any newline character or character sequence is
+recognized. If this option is set, the only recognized newline character
+is '\n'.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_NEWLINE_CRLF">
+<parameter_description> Usually any newline character or character sequence is
+recognized. If this option is set, the only recognized newline character
+sequence is '\r\n'.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_NEWLINE_ANYCRLF">
+<parameter_description> Usually any newline character or character sequence
+is recognized. If this option is set, the only recognized newline character
+sequences are '\r', '\n', and '\r\n'. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_BSR_ANYCRLF">
+<parameter_description> Usually any newline character or character sequence
+is recognised. If this option is set, then "\R" only recognizes the newline
+characters '\r', '\n' and '\r\n'. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_JAVASCRIPT_COMPAT">
+<parameter_description> Changes behaviour so that it is compatible with
+JavaScript rather than PCRE. Since: 2.34
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GRegexError">
+<description>
+Error codes returned by regular expressions functions.
+
+Since: 2.14
+
+</description>
+<parameters>
+<parameter name="G_REGEX_ERROR_COMPILE">
+<parameter_description> Compilation of the regular expression failed.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_OPTIMIZE">
+<parameter_description> Optimization of the regular expression failed.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_REPLACE">
+<parameter_description> Replacement failed due to an ill-formed replacement
+string.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MATCH">
+<parameter_description> The match process failed.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INTERNAL">
+<parameter_description> Internal error of the regular expression engine.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_STRAY_BACKSLASH">
+<parameter_description> "\\" at end of pattern. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_CONTROL_CHAR">
+<parameter_description> "\\c" at end of pattern. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNRECOGNIZED_ESCAPE">
+<parameter_description> Unrecognized character follows "\\".
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER">
+<parameter_description> Numbers out of order in "{}"
+quantifier. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_QUANTIFIER_TOO_BIG">
+<parameter_description> Number too big in "{}" quantifier.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS">
+<parameter_description> Missing terminating "]" for
+character class. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS">
+<parameter_description> Invalid escape sequence
+in character class. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_RANGE_OUT_OF_ORDER">
+<parameter_description> Range out of order in character class.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_NOTHING_TO_REPEAT">
+<parameter_description> Nothing to repeat. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNRECOGNIZED_CHARACTER">
+<parameter_description> Unrecognized character after "(?",
+"(?<" or "(?P". Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS">
+<parameter_description> POSIX named classes are
+supported only within a class. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNMATCHED_PARENTHESIS">
+<parameter_description> Missing terminating ")" or ")"
+without opening "(". Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE">
+<parameter_description> Reference to non-existent
+subpattern. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNTERMINATED_COMMENT">
+<parameter_description> Missing terminating ")" after comment.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_EXPRESSION_TOO_LARGE">
+<parameter_description> Regular expression too large.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MEMORY_ERROR">
+<parameter_description> Failed to get memory. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND">
+<parameter_description> Lookbehind assertion is not
+fixed length. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MALFORMED_CONDITION">
+<parameter_description> Malformed number or name after "(?(".
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES">
+<parameter_description> Conditional group contains
+more than two branches. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_ASSERTION_EXPECTED">
+<parameter_description> Assertion expected after "(?(".
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME">
+<parameter_description> Unknown POSIX class name.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED">
+<parameter_description> POSIX collating
+elements are not supported. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_HEX_CODE_TOO_LARGE">
+<parameter_description> Character value in "\\x{...}" sequence
+is too large. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_CONDITION">
+<parameter_description> Invalid condition "(?(0)". Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND">
+<parameter_description> \\C not allowed in
+lookbehind assertion. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INFINITE_LOOP">
+<parameter_description> Recursive call could loop indefinitely.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR">
+<parameter_description> Missing terminator
+in subpattern name. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME">
+<parameter_description> Two named subpatterns have
+the same name. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MALFORMED_PROPERTY">
+<parameter_description> Malformed "\\P" or "\\p" sequence.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNKNOWN_PROPERTY">
+<parameter_description> Unknown property name after "\\P" or
+"\\p". Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG">
+<parameter_description> Subpattern name is too long
+(maximum 32 characters). Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_TOO_MANY_SUBPATTERNS">
+<parameter_description> Too many named subpatterns (maximum
+10,000). Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_OCTAL_VALUE">
+<parameter_description> Octal value is greater than "\\377".
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE">
+<parameter_description> "DEFINE" group contains more
+than one branch. Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_DEFINE_REPETION">
+<parameter_description> Repeating a "DEFINE" group is not allowed.
+This error is never raised. Since: 2.16 Deprecated: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS">
+<parameter_description> Inconsistent newline options.
+Since 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_BACK_REFERENCE">
+<parameter_description> "\\g" is not followed by a braced,
+angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE">
+<parameter_description> relative reference must not be zero. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN">
+<parameter_description> the backtracing
+control verb used does not allow an argument. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB">
+<parameter_description> unknown backtracing
+control verb. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_NUMBER_TOO_BIG">
+<parameter_description> number is too big in escape sequence. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_SUBPATTERN_NAME">
+<parameter_description> Missing subpattern name. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_DIGIT">
+<parameter_description> Missing digit. Since 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_DATA_CHARACTER">
+<parameter_description> In JavaScript compatibility mode,
+"[" is an invalid data character. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME">
+<parameter_description> different names for subpatterns of the
+same number are not allowed. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED">
+<parameter_description> the backtracing control
+verb requires an argument. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_INVALID_CONTROL_CHAR">
+<parameter_description> "\\c" must be followed by an ASCII
+character. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_MISSING_NAME">
+<parameter_description> "\\k" is not followed by a braced, angle-bracketed, or
+quoted name. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS">
+<parameter_description> "\\N" is not supported in a class. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES">
+<parameter_description> too many forward references. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_NAME_TOO_LONG">
+<parameter_description> the name is too long in "(*MARK)", "(*PRUNE)",
+"(*SKIP)", or "(*THEN)". Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE">
+<parameter_description> the character value in the \\u sequence is
+too large. Since: 2.34
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GRegexMatchFlags">
+<description>
+Flags specifying match-time options.
+
+Since: 2.14
+
+</description>
+<parameters>
+<parameter name="G_REGEX_MATCH_ANCHORED">
+<parameter_description> The pattern is forced to be "anchored", that is,
+it is constrained to match only at the first matching point in the
+string that is being searched. This effect can also be achieved by
+appropriate constructs in the pattern itself such as the "^"
+metacharater.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NOTBOL">
+<parameter_description> Specifies that first character of the string is
+not the beginning of a line, so the circumflex metacharacter should
+not match before it. Setting this without #G_REGEX_MULTILINE (at
+compile time) causes circumflex never to match. This option affects
+only the behaviour of the circumflex metacharacter, it does not
+affect "\A".
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NOTEOL">
+<parameter_description> Specifies that the end of the subject string is
+not the end of a line, so the dollar metacharacter should not match
+it nor (except in multiline mode) a newline immediately before it.
+Setting this without #G_REGEX_MULTILINE (at compile time) causes
+dollar never to match. This option affects only the behaviour of
+the dollar metacharacter, it does not affect "\Z" or "\z".
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NOTEMPTY">
+<parameter_description> An empty string is not considered to be a valid
+match if this option is set. If there are alternatives in the pattern,
+they are tried. If all the alternatives match the empty string, the
+entire match fails. For example, if the pattern "a?b?" is applied to
+a string not beginning with "a" or "b", it matches the empty string
+at the start of the string. With this flag set, this match is not
+valid, so GRegex searches further into the string for occurrences
+of "a" or "b".
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_PARTIAL">
+<parameter_description> Turns on the partial matching feature, for more
+documentation on partial matching see g_match_info_is_partial_match().
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NEWLINE_CR">
+<parameter_description> Overrides the newline definition set when
+creating a new #GRegex, setting the '\r' character as line terminator.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NEWLINE_LF">
+<parameter_description> Overrides the newline definition set when
+creating a new #GRegex, setting the '\n' character as line terminator.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NEWLINE_CRLF">
+<parameter_description> Overrides the newline definition set when
+creating a new #GRegex, setting the '\r\n' characters sequence as line terminator.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NEWLINE_ANY">
+<parameter_description> Overrides the newline definition set when
+creating a new #GRegex, any Unicode newline sequence
+is recognised as a newline. These are '\r', '\n' and '\rn', and the
+single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
+U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
+U+2029 PARAGRAPH SEPARATOR.
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NEWLINE_ANYCRLF">
+<parameter_description> Overrides the newline definition set when
+creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence
+is recognized as a newline. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_BSR_ANYCRLF">
+<parameter_description> Overrides the newline definition for "\R" set when
+creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences
+are recognized as a newline by "\R". Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_BSR_ANY">
+<parameter_description> Overrides the newline definition for "\R" set when
+creating a new #GRegex; any Unicode newline character or character sequence
+are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the
+single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
+U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
+U+2029 PARAGRAPH SEPARATOR. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_PARTIAL_SOFT">
+<parameter_description> An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_PARTIAL_HARD">
+<parameter_description> Turns on the partial matching feature. In contrast to
+to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match
+is found, without continuing to search for a possible complete match. See
+see g_match_info_is_partial_match() for more information. Since: 2.34
+</parameter_description>
+</parameter>
+<parameter name="G_REGEX_MATCH_NOTEMPTY_ATSTART">
+<parameter_description> Like #G_REGEX_MATCH_NOTEMPTY, but only applied to
+the start of the matched string. For anchored
+patterns this can only happen for pattern containing "\K". Since: 2.34
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSeekType">
+<description>
+An enumeration specifying the base position for a
+g_io_channel_seek_position() operation.
+
+</description>
+<parameters>
+<parameter name="G_SEEK_CUR">
+<parameter_description> the current position in the file.
+</parameter_description>
+</parameter>
+<parameter name="G_SEEK_SET">
+<parameter_description> the start of the file.
+</parameter_description>
+</parameter>
+<parameter name="G_SEEK_END">
+<parameter_description> the end of the file.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GShellError">
+<description>
+Error codes returned by shell functions.
+
+</description>
+<parameters>
+<parameter name="G_SHELL_ERROR_BAD_QUOTING">
+<parameter_description> Mismatched or otherwise mangled quoting.
+</parameter_description>
+</parameter>
+<parameter name="G_SHELL_ERROR_EMPTY_STRING">
+<parameter_description> String to be parsed was empty.
+</parameter_description>
+</parameter>
+<parameter name="G_SHELL_ERROR_FAILED">
+<parameter_description> Some other error.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSignalFlags">
+<description>
+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.
+
+</description>
+<parameters>
+<parameter name="G_SIGNAL_RUN_FIRST">
+<parameter_description> Invoke the object method handler in the first emission stage.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_RUN_LAST">
+<parameter_description> Invoke the object method handler in the third emission stage.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_RUN_CLEANUP">
+<parameter_description> Invoke the object method handler in the last emission stage.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_NO_RECURSE">
+<parameter_description> Signals being emitted for an object while currently being in
+emission for this very object will not be emitted recursively,
+but instead cause the first emission to be restarted.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_DETAILED">
+<parameter_description> This signal supports "::detail" appendices to the signal name
+upon handler connections and emissions.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_ACTION">
+<parameter_description> 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 object methods which can be called generically by
+third-party code.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_NO_HOOKS">
+<parameter_description> No emissions hooks are supported for this signal.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MUST_COLLECT">
+<parameter_description> Varargs signal emission will always collect the
+arguments, even if there are no signal handlers connected. Since 2.30.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_DEPRECATED">
+<parameter_description> The signal is deprecated and will be removed
+in a future version. A warning will be generated if it is connected while
+running with G_ENABLE_DIAGNOSTIC=1. Since 2.32.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSignalMatchType">
+<description>
+The match types specify what g_signal_handlers_block_matched(),
+g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
+match signals by.
+
+</description>
+<parameters>
+<parameter name="G_SIGNAL_MATCH_ID">
+<parameter_description> The signal id must be equal.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MATCH_DETAIL">
+<parameter_description> The signal detail be equal.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MATCH_CLOSURE">
+<parameter_description> The closure must be the same.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MATCH_FUNC">
+<parameter_description> The C closure callback must be the same.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MATCH_DATA">
+<parameter_description> The closure data must be the same.
+</parameter_description>
+</parameter>
+<parameter name="G_SIGNAL_MATCH_UNBLOCKED">
+<parameter_description> Only unblocked signals may matched.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSpawnError">
+<description>
+Error codes returned by spawning processes.
+
+</description>
+<parameters>
+<parameter name="G_SPAWN_ERROR_FORK">
+<parameter_description> Fork failed due to lack of memory.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_READ">
+<parameter_description> Read or select on pipes failed.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_CHDIR">
+<parameter_description> Changing to working directory failed.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_ACCES">
+<parameter_description> execv() returned <literal>EACCES</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_PERM">
+<parameter_description> execv() returned <literal>EPERM</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_TOO_BIG">
+<parameter_description> execv() returned <literal>E2BIG</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_2BIG">
+<parameter_description> deprecated alias for %G_SPAWN_ERROR_TOO_BIG
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NOEXEC">
+<parameter_description> execv() returned <literal>ENOEXEC</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NAMETOOLONG">
+<parameter_description> execv() returned <literal>ENAMETOOLONG</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NOENT">
+<parameter_description> execv() returned <literal>ENOENT</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NOMEM">
+<parameter_description> execv() returned <literal>ENOMEM</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NOTDIR">
+<parameter_description> execv() returned <literal>ENOTDIR</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_LOOP">
+<parameter_description> execv() returned <literal>ELOOP</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_TXTBUSY">
+<parameter_description> execv() returned <literal>ETXTBUSY</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_IO">
+<parameter_description> execv() returned <literal>EIO</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_NFILE">
+<parameter_description> execv() returned <literal>ENFILE</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_MFILE">
+<parameter_description> execv() returned <literal>EMFILE</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_INVAL">
+<parameter_description> execv() returned <literal>EINVAL</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_ISDIR">
+<parameter_description> execv() returned <literal>EISDIR</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_LIBBAD">
+<parameter_description> execv() returned <literal>ELIBBAD</literal>
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_ERROR_FAILED">
+<parameter_description> Some other fatal failure,
+<literal>error->message</literal> should explain.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GSpawnFlags">
+<description>
+Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
+
+</description>
+<parameters>
+<parameter name="G_SPAWN_LEAVE_DESCRIPTORS_OPEN">
+<parameter_description> the parent's open file descriptors will be
+inherited by the child; otherwise all descriptors except stdin/stdout/stderr
+will be closed before calling exec() in the child.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_DO_NOT_REAP_CHILD">
+<parameter_description> the child will not be automatically reaped; you
+must use g_child_watch_add() yourself (or call waitpid()
+or handle <literal>SIGCHLD</literal> yourself), or the child will become a zombie.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_SEARCH_PATH">
+<parameter_description> <literal>argv[0]</literal> need not be an absolute path,
+it will be looked for in the user's <envar>PATH</envar>.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_STDOUT_TO_DEV_NULL">
+<parameter_description> the child's standard output will be discarded,
+instead of going to the same location as the parent's standard output.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_STDERR_TO_DEV_NULL">
+<parameter_description> the child's standard error will be discarded.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_CHILD_INHERITS_STDIN">
+<parameter_description> the child will inherit the parent's standard
+input (by default, the child's standard input is attached to
+<filename>/dev/null</filename>).
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_FILE_AND_ARGV_ZERO">
+<parameter_description> the first element of <literal>argv</literal> is
+the file to execute, while the remaining elements are the actual argument
+vector to pass to the file. Normally g_spawn_async_with_pipes() uses
+<literal>argv[0]</literal> as the file to execute, and passes all of
+<literal>argv</literal> to the child.
+</parameter_description>
+</parameter>
+<parameter name="G_SPAWN_SEARCH_PATH_FROM_ENVP">
+<parameter_description> if <literal>argv[0]</literal> is not an abolute path,
+it will be looked for in the <envar>PATH</envar> from the passed child
+environment. Since: 2.34
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTestTrapFlags">
+<description>
+Test traps are guards around forked tests.
+These flags determine what traps to set.
+
+</description>
+<parameters>
+<parameter name="G_TEST_TRAP_SILENCE_STDOUT">
+<parameter_description> Redirect stdout of the test child to
+<filename>/dev/null</filename> so it cannot be observed on the
+console during test runs. The actual output is still captured
+though to allow later tests with g_test_trap_assert_stdout().
+</parameter_description>
+</parameter>
+<parameter name="G_TEST_TRAP_SILENCE_STDERR">
+<parameter_description> Redirect stderr of the test child to
+<filename>/dev/null</filename> so it cannot be observed on the
+console during test runs. The actual output is still captured
+though to allow later tests with g_test_trap_assert_stderr().
+</parameter_description>
+</parameter>
+<parameter name="G_TEST_TRAP_INHERIT_STDIN">
+<parameter_description> If this flag is given, stdin of the
+forked child process is shared with stdin of its parent process.
+It is redirected to <filename>/dev/null</filename> otherwise.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GThreadError">
+<description>
+Possible errors of thread related functions.
+
+</description>
+<parameters>
+<parameter name="G_THREAD_ERROR_AGAIN">
+<parameter_description> a thread couldn't be created due to resource
+shortage. Try again later.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GThreadPriority">
+<description>
+Deprecated:2.32: Thread priorities no longer have any effect.
+
+</description>
+<parameters>
+<parameter name="G_THREAD_PRIORITY_LOW">
+<parameter_description> a priority lower than normal
+</parameter_description>
+</parameter>
+<parameter name="G_THREAD_PRIORITY_NORMAL">
+<parameter_description> the default priority
+</parameter_description>
+</parameter>
+<parameter name="G_THREAD_PRIORITY_HIGH">
+<parameter_description> a priority higher than normal
+</parameter_description>
+</parameter>
+<parameter name="G_THREAD_PRIORITY_URGENT">
+<parameter_description> the highest priority
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTimeType">
+<description>
+Disambiguates a given time in two ways.
+
+First, specifies if the given time is in universal or local time.
+
+Second, if the time is in local time, specifies if it is local
+standard time or local daylight time. This is important for the case
+where the same local time occurs twice (during daylight savings time
+transitions, for example).
+
+</description>
+<parameters>
+<parameter name="G_TIME_TYPE_STANDARD">
+<parameter_description> the time is in local standard time
+</parameter_description>
+</parameter>
+<parameter name="G_TIME_TYPE_DAYLIGHT">
+<parameter_description> the time is in local daylight time
+</parameter_description>
+</parameter>
+<parameter name="G_TIME_TYPE_UNIVERSAL">
+<parameter_description> the time is in UTC
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTokenType">
+<description>
+The possible types of token returned from each
+g_scanner_get_next_token() call.
+
+</description>
+<parameters>
+<parameter name="G_TOKEN_EOF">
+<parameter_description> the end of the file
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_LEFT_PAREN">
+<parameter_description> a '(' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_LEFT_CURLY">
+<parameter_description> a '{' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_LEFT_BRACE">
+<parameter_description> a '[' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_RIGHT_CURLY">
+<parameter_description> a '}' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_RIGHT_PAREN">
+<parameter_description> a ')' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_RIGHT_BRACE">
+<parameter_description> a ']' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_EQUAL_SIGN">
+<parameter_description> a '=' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_COMMA">
+<parameter_description> a ',' character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_NONE">
+<parameter_description> not a token
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_ERROR">
+<parameter_description> an error occurred
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_CHAR">
+<parameter_description> a character
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_BINARY">
+<parameter_description> a binary integer
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_OCTAL">
+<parameter_description> an octal integer
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_INT">
+<parameter_description> an integer
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_HEX">
+<parameter_description> a hex integer
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_FLOAT">
+<parameter_description> a floating point number
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_STRING">
+<parameter_description> a string
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_SYMBOL">
+<parameter_description> a symbol
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_IDENTIFIER">
+<parameter_description> an identifier
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_IDENTIFIER_NULL">
+<parameter_description> a null identifier
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_COMMENT_SINGLE">
+<parameter_description> one line comment
+</parameter_description>
+</parameter>
+<parameter name="G_TOKEN_COMMENT_MULTI">
+<parameter_description> multi line comment
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTraverseFlags">
+<description>
+Specifies which nodes are visited during several of the tree
+functions, including g_node_traverse() and g_node_find().
+
+</description>
+<parameters>
+<parameter name="G_TRAVERSE_LEAVES">
+<parameter_description> only leaf nodes should be visited. This name has
+been introduced in 2.6, for older version use
+%G_TRAVERSE_LEAFS.
+</parameter_description>
+</parameter>
+<parameter name="G_TRAVERSE_NON_LEAVES">
+<parameter_description> only non-leaf nodes should be visited. This
+name has been introduced in 2.6, for older
+version use %G_TRAVERSE_NON_LEAFS.
+</parameter_description>
+</parameter>
+<parameter name="G_TRAVERSE_ALL">
+<parameter_description> all nodes should be visited.
+</parameter_description>
+</parameter>
+<parameter name="G_TRAVERSE_MASK">
+<parameter_description> a mask of all traverse flags.
+</parameter_description>
+</parameter>
+<parameter name="G_TRAVERSE_LEAFS">
+<parameter_description> identical to %G_TRAVERSE_LEAVES.
+</parameter_description>
+</parameter>
+<parameter name="G_TRAVERSE_NON_LEAFS">
+<parameter_description> identical to %G_TRAVERSE_NON_LEAVES.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTraverseType">
+<description>
+Specifies the type of traveral performed by g_tree_traverse(),
+g_node_traverse() and g_node_find().
+
+</description>
+<parameters>
+<parameter name="G_IN_ORDER">
+<parameter_description> vists a node's left child first, then the node itself,
+then its right child. This is the one to use if you
+want the output sorted according to the compare
+function.
+</parameter_description>
+</parameter>
+<parameter name="G_PRE_ORDER">
+<parameter_description> visits a node, then its children.
+</parameter_description>
+</parameter>
+<parameter name="G_POST_ORDER">
+<parameter_description> visits the node's children, then the node itself.
+</parameter_description>
+</parameter>
+<parameter name="G_LEVEL_ORDER">
+<parameter_description> is not implemented for <link
+linkend="glib-Balanced-Binary-Trees">Balanced Binary
+Trees</link>. For <link
+linkend="glib-N-ary-Trees">N-ary Trees</link>, it
+vists the root node first, then its children, then
+its grandchildren, and so on. Note that this is less
+efficient than the other orders.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTypeDebugFlags">
+<description>
+These flags used to be passed to g_type_init_with_debug_flags() which
+is now deprecated.
+
+If you need to enable debugging features, use the GOBJECT_DEBUG
+environment variable.
+
+Deprecated: 2.36: g_type_init() is now done automatically
+
+</description>
+<parameters>
+<parameter name="G_TYPE_DEBUG_NONE">
+<parameter_description> Print no messages.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_DEBUG_OBJECTS">
+<parameter_description> Print messages about object bookkeeping.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_DEBUG_SIGNALS">
+<parameter_description> Print messages about signal emissions.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_DEBUG_MASK">
+<parameter_description> Mask covering all debug flags.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTypeFlags">
+<description>
+Bit masks used to check or determine characteristics of a type.
+
+</description>
+<parameters>
+<parameter name="G_TYPE_FLAG_ABSTRACT">
+<parameter_description> Indicates an abstract type. No instances can be
+created for an abstract type.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_FLAG_VALUE_ABSTRACT">
+<parameter_description> Indicates an abstract value type, i.e. a type
+that introduces a value table, but can't be used for
+g_value_init().
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GTypeFundamentalFlags">
+<description>
+Bit masks used to check or determine specific characteristics of a
+fundamental type.
+
+</description>
+<parameters>
+<parameter name="G_TYPE_FLAG_CLASSED">
+<parameter_description> Indicates a classed type.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_FLAG_INSTANTIATABLE">
+<parameter_description> Indicates an instantiable type (implies classed).
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_FLAG_DERIVABLE">
+<parameter_description> Indicates a flat derivable type.
+</parameter_description>
+</parameter>
+<parameter name="G_TYPE_FLAG_DEEP_DERIVABLE">
+<parameter_description> Indicates a deep derivable type (implies derivable).
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GUnicodeBreakType">
+<description>
+These are the possible line break classifications.
+
+Since new unicode versions may add new types here, applications should be ready
+to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
+
+See <ulink url="http://www.unicode.org/unicode/reports/tr14/">http://www.unicode.org/unicode/reports/tr14/</ulink>.
+
+</description>
+<parameters>
+<parameter name="G_UNICODE_BREAK_MANDATORY">
+<parameter_description> Mandatory Break (BK)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_CARRIAGE_RETURN">
+<parameter_description> Carriage Return (CR)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_LINE_FEED">
+<parameter_description> Line Feed (LF)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_COMBINING_MARK">
+<parameter_description> Attached Characters and Combining Marks (CM)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_SURROGATE">
+<parameter_description> Surrogates (SG)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_ZERO_WIDTH_SPACE">
+<parameter_description> Zero Width Space (ZW)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_INSEPARABLE">
+<parameter_description> Inseparable (IN)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_NON_BREAKING_GLUE">
+<parameter_description> Non-breaking ("Glue") (GL)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_CONTINGENT">
+<parameter_description> Contingent Break Opportunity (CB)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_SPACE">
+<parameter_description> Space (SP)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_AFTER">
+<parameter_description> Break Opportunity After (BA)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_BEFORE">
+<parameter_description> Break Opportunity Before (BB)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_BEFORE_AND_AFTER">
+<parameter_description> Break Opportunity Before and After (B2)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HYPHEN">
+<parameter_description> Hyphen (HY)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_NON_STARTER">
+<parameter_description> Nonstarter (NS)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_OPEN_PUNCTUATION">
+<parameter_description> Opening Punctuation (OP)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_CLOSE_PUNCTUATION">
+<parameter_description> Closing Punctuation (CL)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_QUOTATION">
+<parameter_description> Ambiguous Quotation (QU)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_EXCLAMATION">
+<parameter_description> Exclamation/Interrogation (EX)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_IDEOGRAPHIC">
+<parameter_description> Ideographic (ID)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_NUMERIC">
+<parameter_description> Numeric (NU)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_INFIX_SEPARATOR">
+<parameter_description> Infix Separator (Numeric) (IS)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_SYMBOL">
+<parameter_description> Symbols Allowing Break After (SY)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_ALPHABETIC">
+<parameter_description> Ordinary Alphabetic and Symbol Characters (AL)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_PREFIX">
+<parameter_description> Prefix (Numeric) (PR)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_POSTFIX">
+<parameter_description> Postfix (Numeric) (PO)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_COMPLEX_CONTEXT">
+<parameter_description> Complex Content Dependent (South East Asian) (SA)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_AMBIGUOUS">
+<parameter_description> Ambiguous (Alphabetic or Ideographic) (AI)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_UNKNOWN">
+<parameter_description> Unknown (XX)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_NEXT_LINE">
+<parameter_description> Next Line (NL)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_WORD_JOINER">
+<parameter_description> Word Joiner (WJ)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HANGUL_L_JAMO">
+<parameter_description> Hangul L Jamo (JL)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HANGUL_V_JAMO">
+<parameter_description> Hangul V Jamo (JV)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HANGUL_T_JAMO">
+<parameter_description> Hangul T Jamo (JT)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HANGUL_LV_SYLLABLE">
+<parameter_description> Hangul LV Syllable (H2)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE">
+<parameter_description> Hangul LVT Syllable (H3)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_CLOSE_PARANTHESIS">
+<parameter_description> Closing Parenthesis (CP). Since 2.28
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER">
+<parameter_description> Conditional Japanese Starter (CJ). Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_HEBREW_LETTER">
+<parameter_description> Hebrew Letter (HL). Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_BREAK_REGIONAL_INDICATOR">
+<parameter_description> Regional Indicator (RI). Since: 2.36
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GUnicodeScript">
+<description>
+The #GUnicodeScript enumeration identifies different writing
+systems. The values correspond to the names as defined in the
+Unicode standard. The enumeration has been added in GLib 2.14,
+and is interchangeable with #PangoScript.
+
+Note that new types may be added in the future. Applications
+should be ready to handle unknown values.
+See <ulink
+url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex
+#24: Script names</ulink>.
+
+</description>
+<parameters>
+<parameter name="G_UNICODE_SCRIPT_INVALID_CODE">
+<parameter_description>
+a value never returned from g_unichar_get_script()
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_COMMON">
+<parameter_description> a character used by multiple different scripts
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_INHERITED">
+<parameter_description> a mark glyph that takes its script from the
+i base glyph to which it is attached
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_ARABIC">
+<parameter_description> Arabic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_ARMENIAN">
+<parameter_description> Armenian
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BENGALI">
+<parameter_description> Bengali
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BOPOMOFO">
+<parameter_description> Bopomofo
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CHEROKEE">
+<parameter_description> Cherokee
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_COPTIC">
+<parameter_description> Coptic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CYRILLIC">
+<parameter_description> Cyrillic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_DESERET">
+<parameter_description> Deseret
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_DEVANAGARI">
+<parameter_description> Devanagari
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_ETHIOPIC">
+<parameter_description> Ethiopic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GEORGIAN">
+<parameter_description> Georgian
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GOTHIC">
+<parameter_description> Gothic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GREEK">
+<parameter_description> Greek
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GUJARATI">
+<parameter_description> Gujarati
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GURMUKHI">
+<parameter_description> Gurmukhi
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_HAN">
+<parameter_description> Han
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_HANGUL">
+<parameter_description> Hangul
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_HEBREW">
+<parameter_description> Hebrew
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_HIRAGANA">
+<parameter_description> Hiragana
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KANNADA">
+<parameter_description> Kannada
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KATAKANA">
+<parameter_description> Katakana
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KHMER">
+<parameter_description> Khmer
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LAO">
+<parameter_description> Lao
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LATIN">
+<parameter_description> Latin
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MALAYALAM">
+<parameter_description> Malayalam
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MONGOLIAN">
+<parameter_description> Mongolian
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MYANMAR">
+<parameter_description> Myanmar
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OGHAM">
+<parameter_description> Ogham
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OLD_ITALIC">
+<parameter_description> Old Italic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_ORIYA">
+<parameter_description> Oriya
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_RUNIC">
+<parameter_description> Runic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SINHALA">
+<parameter_description> Sinhala
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SYRIAC">
+<parameter_description> Syriac
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAMIL">
+<parameter_description> Tamil
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TELUGU">
+<parameter_description> Telugu
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_THAANA">
+<parameter_description> Thaana
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_THAI">
+<parameter_description> Thai
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TIBETAN">
+<parameter_description> Tibetan
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL">
+<parameter_description>
+Canadian Aboriginal
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_YI">
+<parameter_description> Yi
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAGALOG">
+<parameter_description> Tagalog
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_HANUNOO">
+<parameter_description> Hanunoo
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BUHID">
+<parameter_description> Buhid
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAGBANWA">
+<parameter_description> Tagbanwa
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BRAILLE">
+<parameter_description> Braille
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CYPRIOT">
+<parameter_description> Cypriot
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LIMBU">
+<parameter_description> Limbu
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OSMANYA">
+<parameter_description> Osmanya
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SHAVIAN">
+<parameter_description> Shavian
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LINEAR_B">
+<parameter_description> Linear B
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAI_LE">
+<parameter_description> Tai Le
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_UGARITIC">
+<parameter_description> Ugaritic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_NEW_TAI_LUE">
+<parameter_description>
+New Tai Lue
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BUGINESE">
+<parameter_description> Buginese
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_GLAGOLITIC">
+<parameter_description> Glagolitic
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TIFINAGH">
+<parameter_description> Tifinagh
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SYLOTI_NAGRI">
+<parameter_description>
+Syloti Nagri
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OLD_PERSIAN">
+<parameter_description>
+Old Persian
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KHAROSHTHI">
+<parameter_description> Kharoshthi
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_UNKNOWN">
+<parameter_description> an unassigned code point
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BALINESE">
+<parameter_description> Balinese
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CUNEIFORM">
+<parameter_description> Cuneiform
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_PHOENICIAN">
+<parameter_description> Phoenician
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_PHAGS_PA">
+<parameter_description> Phags-pa
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_NKO">
+<parameter_description> N'Ko
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KAYAH_LI">
+<parameter_description> Kayah Li. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LEPCHA">
+<parameter_description> Lepcha. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_REJANG">
+<parameter_description> Rejang. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SUNDANESE">
+<parameter_description> Sundanese. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SAURASHTRA">
+<parameter_description> Saurashtra. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CHAM">
+<parameter_description> Cham. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OL_CHIKI">
+<parameter_description> Ol Chiki. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_VAI">
+<parameter_description> Vai. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CARIAN">
+<parameter_description> Carian. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LYCIAN">
+<parameter_description> Lycian. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LYDIAN">
+<parameter_description> Lydian. Since 2.16.3
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_AVESTAN">
+<parameter_description> Avestan. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BAMUM">
+<parameter_description> Bamum. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS">
+<parameter_description>
+Egyptian Hieroglpyhs. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC">
+<parameter_description>
+Imperial Aramaic. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI">
+<parameter_description>
+Inscriptional Pahlavi. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN">
+<parameter_description>
+Inscriptional Parthian. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_JAVANESE">
+<parameter_description> Javanese. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_KAITHI">
+<parameter_description> Kaithi. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_LISU">
+<parameter_description> Lisu. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MEETEI_MAYEK">
+<parameter_description>
+Meetei Mayek. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN">
+<parameter_description>
+Old South Arabian. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_OLD_TURKIC">
+<parameter_description> Old Turkic. Since 2.28
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SAMARITAN">
+<parameter_description> Samaritan. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAI_THAM">
+<parameter_description> Tai Tham. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAI_VIET">
+<parameter_description> Tai Viet. Since 2.26
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BATAK">
+<parameter_description> Batak. Since 2.28
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_BRAHMI">
+<parameter_description> Brahmi. Since 2.28
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MANDAIC">
+<parameter_description> Mandaic. Since 2.28
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_CHAKMA">
+<parameter_description> Chakma. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MEROITIC_CURSIVE">
+<parameter_description> Meroitic Cursive. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS">
+<parameter_description> Meroitic Hieroglyphs. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_MIAO">
+<parameter_description> Miao. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SHARADA">
+<parameter_description> Sharada. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_SORA_SOMPENG">
+<parameter_description> Sora Sompeng. Since: 2.32
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SCRIPT_TAKRI">
+<parameter_description> Takri. Since: 2.32
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GUnicodeType">
+<description>
+These are the possible character classifications from the
+Unicode specification.
+See <ulink url="http://www.unicode.org/Public/UNIDATA/UnicodeData.html">http://www.unicode.org/Public/UNIDATA/UnicodeData.html</ulink>.
-This signal is typically used to obtain change notification for a
-single property, by specifying the property name as a detail in the
-g_signal_connect() call, like this:
-|[
-g_signal_connect (text_view->buffer, "notify::paste-target-list",
-G_CALLBACK (gtk_text_view_target_list_notify),
-text_view)
-]|
-It is important to note that you must use
-<link linkend="canonical-parameter-name">canonical</link> parameter names as
-detail strings for the notify signal.
+</description>
+<parameters>
+<parameter name="G_UNICODE_CONTROL">
+<parameter_description> General category "Other, Control" (Cc)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_FORMAT">
+<parameter_description> General category "Other, Format" (Cf)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_UNASSIGNED">
+<parameter_description> General category "Other, Not Assigned" (Cn)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_PRIVATE_USE">
+<parameter_description> General category "Other, Private Use" (Co)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SURROGATE">
+<parameter_description> General category "Other, Surrogate" (Cs)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_LOWERCASE_LETTER">
+<parameter_description> General category "Letter, Lowercase" (Ll)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_MODIFIER_LETTER">
+<parameter_description> General category "Letter, Modifier" (Lm)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_OTHER_LETTER">
+<parameter_description> General category "Letter, Other" (Lo)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_TITLECASE_LETTER">
+<parameter_description> General category "Letter, Titlecase" (Lt)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_UPPERCASE_LETTER">
+<parameter_description> General category "Letter, Uppercase" (Lu)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SPACING_MARK">
+<parameter_description> General category "Mark, Spacing" (Mc)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_ENCLOSING_MARK">
+<parameter_description> General category "Mark, Enclosing" (Me)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_NON_SPACING_MARK">
+<parameter_description> General category "Mark, Nonspacing" (Mn)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_DECIMAL_NUMBER">
+<parameter_description> General category "Number, Decimal Digit" (Nd)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_LETTER_NUMBER">
+<parameter_description> General category "Number, Letter" (Nl)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_OTHER_NUMBER">
+<parameter_description> General category "Number, Other" (No)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_CONNECT_PUNCTUATION">
+<parameter_description> General category "Punctuation, Connector" (Pc)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_DASH_PUNCTUATION">
+<parameter_description> General category "Punctuation, Dash" (Pd)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_CLOSE_PUNCTUATION">
+<parameter_description> General category "Punctuation, Close" (Pe)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_FINAL_PUNCTUATION">
+<parameter_description> General category "Punctuation, Final quote" (Pf)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_INITIAL_PUNCTUATION">
+<parameter_description> General category "Punctuation, Initial quote" (Pi)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_OTHER_PUNCTUATION">
+<parameter_description> General category "Punctuation, Other" (Po)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_OPEN_PUNCTUATION">
+<parameter_description> General category "Punctuation, Open" (Ps)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_CURRENCY_SYMBOL">
+<parameter_description> General category "Symbol, Currency" (Sc)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_MODIFIER_SYMBOL">
+<parameter_description> General category "Symbol, Modifier" (Sk)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_MATH_SYMBOL">
+<parameter_description> General category "Symbol, Math" (Sm)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_OTHER_SYMBOL">
+<parameter_description> General category "Symbol, Other" (So)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_LINE_SEPARATOR">
+<parameter_description> General category "Separator, Line" (Zl)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_PARAGRAPH_SEPARATOR">
+<parameter_description> General category "Separator, Paragraph" (Zp)
+</parameter_description>
+</parameter>
+<parameter name="G_UNICODE_SPACE_SEPARATOR">
+<parameter_description> General category "Separator, Space" (Zs)
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GUserDirectory">
+<description>
+These are logical ids for special directories which are defined
+depending on the platform used. You should use g_get_user_special_dir()
+to retrieve the full path associated to the logical id.
+
+The #GUserDirectory enumeration can be extended at later date. Not
+every platform has a directory for every logical id in this
+enumeration.
+
+Since: 2.14
</description>
<parameters>
-<parameter name="gobject">
-<parameter_description> the object which received the signal.
+<parameter name="G_USER_DIRECTORY_DESKTOP">
+<parameter_description> the user's Desktop directory
</parameter_description>
</parameter>
-<parameter name="pspec">
-<parameter_description> the #GParamSpec of the property which changed.
+<parameter name="G_USER_DIRECTORY_DOCUMENTS">
+<parameter_description> the user's Documents directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_DOWNLOAD">
+<parameter_description> the user's Downloads directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_MUSIC">
+<parameter_description> the user's Music directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_PICTURES">
+<parameter_description> the user's Pictures directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_PUBLIC_SHARE">
+<parameter_description> the user's shared directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_TEMPLATES">
+<parameter_description> the user's Templates directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_DIRECTORY_VIDEOS">
+<parameter_description> the user's Movies directory
+</parameter_description>
+</parameter>
+<parameter name="G_USER_N_DIRECTORIES">
+<parameter_description> the number of enum values
</parameter_description>
</parameter>
</parameters>
-<return></return>
-</signal>
+</enum>
+
+<enum name="GVariantClass">
+<description>
+The range of possible top-level types of #GVariant instances.
+
+Since: 2.24
+
+</description>
+<parameters>
+<parameter name="G_VARIANT_CLASS_BOOLEAN">
+<parameter_description> The #GVariant is a boolean.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_BYTE">
+<parameter_description> The #GVariant is a byte.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_INT16">
+<parameter_description> The #GVariant is a signed 16 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_UINT16">
+<parameter_description> The #GVariant is an unsigned 16 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_INT32">
+<parameter_description> The #GVariant is a signed 32 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_UINT32">
+<parameter_description> The #GVariant is an unsigned 32 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_INT64">
+<parameter_description> The #GVariant is a signed 64 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_UINT64">
+<parameter_description> The #GVariant is an unsigned 64 bit integer.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_HANDLE">
+<parameter_description> The #GVariant is a file handle index.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_DOUBLE">
+<parameter_description> The #GVariant is a double precision floating
+point value.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_STRING">
+<parameter_description> The #GVariant is a normal string.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_OBJECT_PATH">
+<parameter_description> The #GVariant is a D-Bus object path
+string.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_SIGNATURE">
+<parameter_description> The #GVariant is a D-Bus signature string.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_VARIANT">
+<parameter_description> The #GVariant is a variant.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_MAYBE">
+<parameter_description> The #GVariant is a maybe-typed value.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_ARRAY">
+<parameter_description> The #GVariant is an array.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_TUPLE">
+<parameter_description> The #GVariant is a tuple.
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_CLASS_DICT_ENTRY">
+<parameter_description> The #GVariant is a dictionary entry.
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
+
+<enum name="GVariantParseError">
+<description>
+Error codes returned by parsing text-format GVariants.
+
+</description>
+<parameters>
+<parameter name="G_VARIANT_PARSE_ERROR_FAILED">
+<parameter_description> generic error (unused)
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED">
+<parameter_description> a non-basic #GVariantType was given where a basic type was expected
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE">
+<parameter_description> cannot infer the #GVariantType
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED">
+<parameter_description> an indefinite #GVariantType was given where a definite type was expected
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END">
+<parameter_description> extra data after parsing finished
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INVALID_CHARACTER">
+<parameter_description> invalid character in number or unicode escape
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING">
+<parameter_description> not a valid #GVariant format string
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH">
+<parameter_description> not a valid object path
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE">
+<parameter_description> not a valid type signature
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING">
+<parameter_description> not a valid #GVariant type string
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE">
+<parameter_description> could not find a common type for array entries
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE">
+<parameter_description> the numerical value is out of range of the given type
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG">
+<parameter_description> the numerical value is out of range for any type
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_TYPE_ERROR">
+<parameter_description> cannot parse as variant of the specified type
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN">
+<parameter_description> an unexpected token was encountered
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD">
+<parameter_description> an unknown keyword was encountered
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT">
+<parameter_description> unterminated string constant
+</parameter_description>
+</parameter>
+<parameter name="G_VARIANT_PARSE_ERROR_VALUE_EXPECTED">
+<parameter_description> no value given
+</parameter_description>
+</parameter>
+</parameters>
+</enum>
<function name="g_access">
<description>
</return>
</function>
+<function name="g_alloca">
+<description>
+Allocates @size bytes on the stack; these bytes will be freed when the current
+stack frame is cleaned up. This macro essentially just wraps the alloca()
+function present on most UNIX variants.
+Thus it provides the same advantages and pitfalls as alloca():
+<variablelist>
+<varlistentry><term></term><listitem><para>
++ alloca() is very fast, as on most systems it's implemented by just adjusting
+the stack pointer register.
+</para></listitem></varlistentry>
+<varlistentry><term></term><listitem><para>
++ It doesn't cause any memory fragmentation, within its scope, separate alloca()
+blocks just build up and are released together at function end.
+</para></listitem></varlistentry>
+<varlistentry><term></term><listitem><para>
+- Allocation sizes have to fit into the current stack frame. For instance in a
+threaded environment on Linux, the per-thread stack size is limited to 2 Megabytes,
+so be sparse with alloca() uses.
+</para></listitem></varlistentry>
+<varlistentry><term></term><listitem><para>
+- Allocation failure due to insufficient stack space is not indicated with a %NULL
+return like e.g. with malloc(). Instead, most systems probably handle it the same
+way as out of stack space situations from infinite function recursion, i.e.
+with a segmentation fault.
+</para></listitem></varlistentry>
+<varlistentry><term></term><listitem><para>
+- Special care has to be taken when mixing alloca() with GNU C variable sized arrays.
+Stack space allocated with alloca() in the same scope as a variable sized array
+will be freed together with the variable sized array upon exit of that scope, and
+not upon exit of the enclosing function scope.
+</para></listitem></varlistentry>
+</variablelist>
+
+
+</description>
+<parameters>
+<parameter name="size">
+<parameter_description> number of bytes to allocate.
+</parameter_description>
+</parameter>
+</parameters>
+<return> space for @size bytes, allocated on the stack
+</return>
+</function>
+
<function name="g_array_append_val">
<description>
Adds the value on to the end of the array. The array will grow in
to the value parameter @v. This means that you cannot use it with
literal values such as "27". You must use variables.</para></note>
+
</description>
<parameters>
<parameter name="a">
<description>
Adds @len elements onto the end of the array.
+
</description>
<parameters>
<parameter name="array">
<note><para>If array elements contain dynamically-allocated memory,
they should be freed separately.</para></note>
+
</description>
<parameters>
<parameter name="array">
</programlisting>
</example>
+
</description>
<parameters>
<parameter name="a">
to the value parameter @v. This means that you cannot use it with
literal values such as "27". You must use variables.</para></note>
+
</description>
<parameters>
<parameter name="a">
<description>
Inserts @len elements into a #GArray at the given index.
+
</description>
<parameters>
<parameter name="array">
<description>
Creates a new #GArray with a reference count of 1.
+
</description>
<parameters>
<parameter name="zero_terminated">
to the value parameter @v. This means that you cannot use it with
literal values such as "27". You must use variables.</para></note>
+
</description>
<parameters>
<parameter name="a">
existing elements in the array have to be moved to make space for
the new elements.
+
</description>
<parameters>
<parameter name="array">
Removes the element at the given index from a #GArray. The following
elements are moved down one place.
+
</description>
<parameters>
<parameter name="array">
does not preserve the order of the #GArray. But it is faster than
g_array_remove_index().
+
</description>
<parameters>
<parameter name="array">
</parameter>
</parameters>
<return> the #GArray.
+
</return>
</function>
Sets the size of the array, expanding it if necessary. If the array
was created with @clear_ set to %TRUE, the new elements are set to 0.
+
</description>
<parameters>
<parameter name="array">
are going to add many elements to the array. Note however that the
size of the array is still 0.
+
</description>
<parameters>
<parameter name="zero_terminated">
Adds the given bytes to the end of the #GByteArray. The array will
grow in size automatically if necessary.
+
</description>
<parameters>
<parameter name="array">
@array is greater than one, the #GByteArray wrapper is preserved but
the size of @array will be set to zero.
+
</description>
<parameters>
<parameter name="array">
<description>
Creates a new #GByteArray with a reference count of 1.
+
</description>
<parameters>
</parameters>
Adds the given data to the start of the #GByteArray. The array will
grow in size automatically if necessary.
+
</description>
<parameters>
<parameter name="array">
Removes the byte at the given index from a #GByteArray. The
following bytes are moved down one place.
+
</description>
<parameters>
<parameter name="array">
does not preserve the order of the #GByteArray. But it is faster
than g_byte_array_remove_index().
+
</description>
<parameters>
<parameter name="array">
</parameter>
</parameters>
<return> the #GByteArray.
+
</return>
</function>
<description>
Sets the size of the #GByteArray, expanding it if necessary.
+
</description>
<parameters>
<parameter name="array">
bytes to the array. Note however that the size of the array is still
0.
+
</description>
<parameters>
<parameter name="reserved_size">
source is still active. Typically, you will want to call
g_spawn_close_pid() in the callback function for the source.
-Note further that using g_child_watch_source_new() is not
-compatible with calling <literal>waitpid(-1)</literal> in
-the application. Calling waitpid() for individual pids will
-still work fine.
+Note further that using g_child_watch_source_new() is not
+compatible with calling <literal>waitpid</literal> with a
+nonpositive first argument in the application. Calling waitpid()
+for individual pids will still work fine.
Since: 2.4
</parameters>
<return> the list of items whose strings begin with
@prefix. This should not be changed.
+
</return>
</function>
<description>
Creates a new #GCompletion.
+
</description>
<parameters>
<parameter name="func">
Gets a data element, using its string identifier. This is slower than
g_datalist_id_get_data() because it compares strings.
+
</description>
<parameters>
<parameter name="datalist">
Removes an element, without calling its destroy notification
function.
+
</description>
<parameters>
<parameter name="datalist">
<description>
Gets the data element corresponding to a string.
+
</description>
<parameters>
<parameter name="l">
<description>
Gets the data element corresponding to a #GQuark.
+
</description>
<parameters>
<parameter name="dataset_location">
Removes an element, without calling its destroy notification
function.
+
</description>
<parameters>
<parameter name="dataset_location">
</parameter_description>
</parameter>
</parameters>
-<return> a newly-allocated string holding the resulting
-filename, or %NULL on an error.
+<return> a newly-allocated string holding
+the resulting filename, or %NULL on an error.
</return>
</function>
</parameter_description>
</parameter>
<parameter name="bytes_read">
-<parameter_description> location to store the number of bytes in the
-input string that were successfully converted, or %NULL.
+<parameter_description> location to store the number of bytes in
+the input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be
less than @len if there were partial characters
at the end of the input. If the error
</parameter_description>
</parameter>
</parameters>
-<return> The converted string, or %NULL on an error.
+<return>
+The converted string, or %NULL on an error.
</return>
</function>
</parameter_description>
</parameter>
<parameter name="buf">
-<parameter_description> a buffer to read data into
+<parameter_description>
+a buffer to read data into
</parameter_description>
</parameter>
<parameter name="count">
</parameter_description>
</parameter>
<parameter name="str_return">
-<parameter_description> Location to store a pointer to a string holding
-the remaining data in the #GIOChannel. This data should
-be freed with g_free() when no longer needed. This
-data is terminated by an extra nul character, but there
-may be other nuls in the intervening data.
+<parameter_description> Location to
+store a pointer to a string holding the remaining data in the
+#GIOChannel. This data should be freed with g_free() when no
+longer needed. This data is terminated by an extra nul
+character, but there may be other nuls in the intervening data.
</parameter_description>
</parameter>
<parameter name="length">
</parameter_description>
</parameter>
<parameter name="line_term">
-<parameter_description> The line termination string. Use %NULL for autodetect.
-Autodetection breaks on "\n", "\r\n", "\r", "\0", and
-the Unicode paragraph separator. Autodetection should
-not be used for anything other than file-based channels.
+<parameter_description> The line termination string. Use %NULL for
+autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0",
+and the Unicode paragraph separator. Autodetection should not be
+used for anything other than file-based channels.
</parameter_description>
</parameter>
<parameter name="length">
On Windows this function returns the file descriptor or socket of
the #GIOChannel.
+
</description>
<parameters>
<parameter name="channel">
valid file descriptor and socket. If that happens a warning is
issued, and GLib assumes that it is the file descriptor you mean.
+
</description>
<parameters>
<parameter name="fd">
This function is available only in GLib on Windows.
+
</description>
<parameters>
<parameter name="fd">
This function creates a #GIOChannel that can be used to poll for
Windows messages for the window in question.
+
</description>
<parameters>
<parameter name="hwnd">
socket in non-blocking mode. This is a side-effect of the
implementation and unavoidable.
+
</description>
<parameters>
<parameter name="socket">
g_list_append(), g_list_prepend(), g_list_insert() and
g_list_insert_sorted() and so is rarely used on its own.
+
</description>
<parameters>
</parameters>
<description>
A convenience macro to get the next element in a #GList.
+
</description>
<parameters>
<parameter name="list">
<description>
A convenience macro to get the previous element in a #GList.
+
</description>
<parameters>
<parameter name="list">
</return>
</function>
+<function name="g_main_destroy">
+<description>
+Frees the memory allocated for the #GMainLoop.
+
+Deprecated: 2.2: Use g_main_loop_unref() instead
+
+</description>
+<parameters>
+<parameter name="loop">
+<parameter_description> a #GMainLoop
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_main_is_running">
+<description>
+Checks if the main loop is running.
+
+Deprecated: 2.2: Use g_main_loop_is_running() instead
+
+</description>
+<parameters>
+<parameter name="loop">
+<parameter_description> a #GMainLoop
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if the main loop is running
+
+</return>
+</function>
+
+<function name="g_main_iteration">
+<description>
+Runs a single iteration for the default #GMainContext.
+
+Deprecated: 2.2: Use g_main_context_iteration() instead.
+
+</description>
+<parameters>
+<parameter name="may_block">
+<parameter_description> set to %TRUE if it should block (i.e. wait) until an event
+source becomes ready. It will return after an event source has been
+processed. If set to %FALSE it will return immediately if no event
+source is ready to be processed.
+</parameter_description>
+</parameter>
+</parameters>
+<return> %TRUE if more events are pending.
+
+</return>
+</function>
+
<function name="g_main_loop_get_context">
<description>
Returns the #GMainContext of @loop.
<return></return>
</function>
+<function name="g_main_new">
+<description>
+Creates a new #GMainLoop for th default main context.
+
+Deprecated: 2.2: Use g_main_loop_new() instead
+
+</description>
+<parameters>
+<parameter name="is_running">
+<parameter_description> set to %TRUE to indicate that the loop is running. This
+is not very important since calling g_main_run() will set this
+to %TRUE anyway.
+</parameter_description>
+</parameter>
+</parameters>
+<return> a new #GMainLoop
+
+</return>
+</function>
+
+<function name="g_main_pending">
+<description>
+Checks if any events are pending for the default #GMainContext
+(i.e. ready to be processed).
+
+
+</description>
+<parameters>
+</parameters>
+<return> %TRUE if any events are pending.
+
+Deprected: 2.2: Use g_main_context_pending() instead.
+</return>
+</function>
+
+<function name="g_main_quit">
+<description>
+Stops the #GMainLoop.
+If g_main_run() was called to run the #GMainLoop, it will now return.
+
+Deprecated: 2.2: Use g_main_loop_quit() instead
+
+</description>
+<parameters>
+<parameter name="loop">
+<parameter_description> a #GMainLoop
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_main_run">
+<description>
+Runs a main loop until it stops running.
+
+Deprecated: 2.2: Use g_main_loop_run() instead
+
+</description>
+<parameters>
+<parameter name="loop">
+<parameter_description> a #GMainLoop
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_main_set_poll_func">
+<description>
+Sets the function to use for the handle polling of file descriptors
+for the default main context.
+
+Deprecated: 2.2: Use g_main_context_set_poll_func() again
+
+</description>
+<parameters>
+<parameter name="func">
+<parameter_description> the function to call to poll all file descriptors
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_malloc">
<description>
Allocates @n_bytes bytes of memory.
<return></return>
</function>
+<function name="g_new">
+<description>
+Allocates @n_structs elements of type @struct_type.
+The returned pointer is cast to a pointer to the given type.
+If @n_structs is 0 it returns %NULL.
+Care is taken to avoid overflow when calculating the size of the allocated block.
+
+Since the returned pointer is already casted to the right type,
+it is normally unnecessary to cast it explicitly, and doing
+so might hide memory allocation errors.
+
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the allocated memory, cast to a pointer to @struct_type
+</return>
+</function>
+
+<function name="g_new0">
+<description>
+Allocates @n_structs elements of type @struct_type, initialized to 0's.
+The returned pointer is cast to a pointer to the given type.
+If @n_structs is 0 it returns %NULL.
+Care is taken to avoid overflow when calculating the size of the allocated block.
+
+Since the returned pointer is already casted to the right type,
+it is normally unnecessary to cast it explicitly, and doing
+so might hide memory allocation errors.
+
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate.
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate.
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the allocated memory, cast to a pointer to @struct_type.
+</return>
+</function>
+
+<function name="g_newa">
+<description>
+Wraps g_alloca() in a more typesafe manner.
+
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> Type of memory chunks to be allocated
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> Number of chunks to be allocated
+</parameter_description>
+</parameter>
+</parameters>
+<return> Pointer to stack space for @n_structs chunks of type @struct_type
+</return>
+</function>
+
+<function name="g_node_append">
+<description>
+Inserts a #GNode as the last child of the given parent.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="node">
+<parameter_description> the #GNode to insert
+</parameter_description>
+</parameter>
+</parameters>
+<return> the inserted #GNode
+</return>
+</function>
+
+<function name="g_node_append_data">
+<description>
+Inserts a new #GNode as the last child of the given parent.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the data for the new #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the new #GNode
+</return>
+</function>
+
<function name="g_node_child_index">
<description>
Gets the position of the first child of a #GNode
</return>
</function>
+<function name="g_node_first_child">
+<description>
+Gets the first child of a #GNode.
+
+
+</description>
+<parameters>
+<parameter name="node">
+<parameter_description> a #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the first child of @node, or %NULL if @node is %NULL
+or has no children
+</return>
+</function>
+
<function name="g_node_first_sibling">
<description>
Gets the first sibling of a #GNode.
</return>
</function>
+<function name="g_node_insert_data">
+<description>
+Inserts a new #GNode at the given position.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="position">
+<parameter_description> the position to place the new #GNode at. If position is -1,
+the new #GNode is inserted as the last child of @parent
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the data for the new #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the new #GNode
+</return>
+</function>
+
+<function name="g_node_insert_data_after">
+<description>
+Inserts a new #GNode after the given sibling.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="sibling">
+<parameter_description> the sibling #GNode to place the new #GNode after
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the data for the new #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the new #GNode
+</return>
+</function>
+
+<function name="g_node_insert_data_before">
+<description>
+Inserts a new #GNode before the given sibling.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="sibling">
+<parameter_description> the sibling #GNode to place the new #GNode before
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the data for the new #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the new #GNode
+</return>
+</function>
+
<function name="g_node_is_ancestor">
<description>
Returns %TRUE if @node is an ancestor of @descendant.
</return>
</function>
+<function name="g_node_next_sibling">
+<description>
+Gets the next sibling of a #GNode.
+
+
+</description>
+<parameters>
+<parameter name="node">
+<parameter_description> a #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the next sibling of @node, or %NULL if @node is the last node
+or %NULL
+</return>
+</function>
+
<function name="g_node_nth_child">
<description>
Gets a child of a #GNode, using the given index.
</return>
</function>
+<function name="g_node_prepend_data">
+<description>
+Inserts a new #GNode as the first child of the given parent.
+
+
+</description>
+<parameters>
+<parameter name="parent">
+<parameter_description> the #GNode to place the new #GNode under
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the data for the new #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the new #GNode
+</return>
+</function>
+
+<function name="g_node_prev_sibling">
+<description>
+Gets the previous sibling of a #GNode.
+
+
+</description>
+<parameters>
+<parameter name="node">
+<parameter_description> a #GNode
+</parameter_description>
+</parameter>
+</parameters>
+<return> the previous sibling of @node, or %NULL if @node is the first
+node or %NULL
+</return>
+</function>
+
<function name="g_node_reverse_children">
<description>
Reverses the order of the children of a #GNode.
offers the g_utf8_strreverse() function to reverse UTF-8 encoded
strings.
+
</description>
<parameters>
<parameter name="pspec">
the pattern once with g_pattern_spec_new() and call
g_pattern_match_string() repeatedly.
+
</description>
<parameters>
<parameter name="pattern">
matched against more than one pattern, consider using
g_pattern_match() instead while supplying the reversed string.
+
</description>
<parameters>
<parameter name="pspec">
Compares two compiled pattern specs and returns whether they will
match the same set of strings.
+
</description>
<parameters>
<parameter name="pspec1">
<description>
Compiles a pattern to a #GPatternSpec.
+
</description>
<parameters>
<parameter name="pattern">
memory, they should be freed separately if @free_seg is %TRUE and no
#GDestroyNotify function has been set for @array.</para></note>
+
</description>
<parameters>
<parameter name="array">
<description>
Returns the pointer at the given index of the pointer array.
+
</description>
<parameters>
<parameter name="array">
<description>
Creates a new #GPtrArray with a reference count of 1.
+
</description>
<parameters>
</parameters>
It returns %TRUE if the pointer was removed, or %FALSE if the
pointer was not found.
+
</description>
<parameters>
<parameter name="array">
It returns %TRUE if the pointer was removed, or %FALSE if the
pointer was not found.
+
</description>
<parameters>
<parameter name="array">
non-%NULL #GDestroyNotify function it is called for the removed
element.
+
</description>
<parameters>
<parameter name="array">
than g_ptr_array_remove_index(). If @array has a non-%NULL
#GDestroyNotify function it is called for the removed element.
+
</description>
<parameters>
<parameter name="array">
you are going to add many pointers to the array. Note however that
the size of the array is still 0.
+
</description>
<parameters>
<parameter name="reserved_size">
Returns a random #gboolean from @rand_. This corresponds to a
unbiased coin toss.
+
</description>
<parameters>
<parameter name="rand_">
<description>
Returns a random #gboolean. This corresponds to a unbiased coin toss.
+
</description>
<parameters>
</parameters>
</parameter>
</parameters>
<return> the number of matches.
+
</return>
</function>
</parameter>
</parameters>
<return> the number of records deleted.
+
</return>
</function>
</parameter>
</parameters>
<return> %TRUE if a record matches.
+
</return>
</function>
</parameter>
</parameters>
<return> a new #GRelation.
+
</return>
</function>
</parameter>
</parameters>
<return> the records (tuples) that matched.
+
</return>
</function>
</return>
</function>
+<function name="g_renew">
+<description>
+Reallocates the memory pointed to by @mem, so that it now has space for
+@n_structs elements of type @struct_type. It returns the new address of
+the memory, which may have been moved.
+Care is taken to avoid overflow when calculating the size of the allocated block.
+
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate
+</parameter_description>
+</parameter>
+<parameter name="mem">
+<parameter_description> the currently allocated memory
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the new allocated memory, cast to a pointer to @struct_type
+</return>
+</function>
+
+<function name="g_return_if_fail">
+<description>
+Verifies that the expression evaluates to %TRUE. If the expression
+evaluates to %FALSE, a critical message is logged and the current
+function returns. This can only be used in functions which do not
+return a value.
+
+If G_DISABLE_CHECKS is defined then the check is not performed. You
+should therefore not depend on any side effects of @expr.
+
+</description>
+<parameters>
+<parameter name="expr">
+<parameter_description> the expression to check
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_return_if_reached">
+<description>
+Logs a critical message and returns from the current function.
+This can only be used in functions which do not return a value.
+
+</description>
+<parameters>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_return_val_if_fail">
+<description>
+Verifies that the expression evaluates to %TRUE. If the expression
+evaluates to %FALSE, a critical message is logged and @val is
+returned from the current function.
+
+If G_DISABLE_CHECKS is defined then the check is not performed. You
+should therefore not depend on any side effects of @expr.
+
+</description>
+<parameters>
+<parameter name="expr">
+<parameter_description> the expression to check
+</parameter_description>
+</parameter>
+<parameter name="val">
+<parameter_description> the value to return from the current function
+if the expression is not true
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_return_val_if_reached">
+<description>
+Logs a critical message and returns @val.
+
+</description>
+<parameters>
+<parameter name="val">
+<parameter_description> the value to return from the current function
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_rmdir">
<description>
A wrapper for the POSIX rmdir() function. The rmdir() function
<return></return>
</function>
+<function name="g_signal_connect">
+<description>
+Connects a #GCallback function to a signal for a particular object.
+
+The handler will be called before the default handler of the signal.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> the instance to connect to.
+</parameter_description>
+</parameter>
+<parameter name="detailed_signal">
+<parameter_description> a string of the form "signal-name::detail".
+</parameter_description>
+</parameter>
+<parameter name="c_handler">
+<parameter_description> the #GCallback to connect.
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> data to pass to @c_handler calls.
+</parameter_description>
+</parameter>
+</parameters>
+<return> the handler id
+</return>
+</function>
+
+<function name="g_signal_connect_after">
+<description>
+Connects a #GCallback function to a signal for a particular object.
+
+The handler will be called after the default handler of the signal.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> the instance to connect to.
+</parameter_description>
+</parameter>
+<parameter name="detailed_signal">
+<parameter_description> a string of the form "signal-name::detail".
+</parameter_description>
+</parameter>
+<parameter name="c_handler">
+<parameter_description> the #GCallback to connect.
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> data to pass to @c_handler calls.
+</parameter_description>
+</parameter>
+</parameters>
+<return> the handler id
+</return>
+</function>
+
<function name="g_signal_connect_closure">
<description>
Connects a closure to a signal for a particular object.
ensures that the @gobject stays alive during the call to @c_handler
by temporarily adding a reference count to @gobject.
-Note that there is a bug in GObject that makes this function
-much less useful than it might seem otherwise. Once @gobject is
-disposed, the callback will no longer be called, but, the signal
-handler is <emphasis>not</emphasis> currently disconnected. If the
-@instance is itself being freed at the same time than this doesn't
-matter, since the signal will automatically be removed, but
-if @instance persists, then the signal handler will leak. You
-should not remove the signal yourself because in a future versions of
-GObject, the handler <emphasis>will</emphasis> automatically
-be disconnected.
-
-It's possible to work around this problem in a way that will
-continue to work with future versions of GObject by checking
-that the signal handler is still connected before disconnected it:
-<informalexample><programlisting>
-if (g_signal_handler_is_connected (instance, id))
-g_signal_handler_disconnect (instance, id);
-</programlisting></informalexample>
+When the object is destroyed the signal handler will be automatically
+disconnected. Note that this is not currently threadsafe (ie:
+emitting a signal while @gobject is being destroyed in another thread
+is not safe).
</description>
</return>
</function>
+<function name="g_signal_connect_swapped">
+<description>
+Connects a #GCallback function to a signal for a particular object.
+
+The instance on which the signal is emitted and @data will be swapped when
+calling the handler.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> the instance to connect to.
+</parameter_description>
+</parameter>
+<parameter name="detailed_signal">
+<parameter_description> a string of the form "signal-name::detail".
+</parameter_description>
+</parameter>
+<parameter name="c_handler">
+<parameter_description> the #GCallback to connect.
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> data to pass to @c_handler calls.
+</parameter_description>
+</parameter>
+</parameters>
+<return> the handler id
+</return>
+</function>
+
<function name="g_signal_emit">
<description>
Emits a signal.
<return></return>
</function>
+<function name="g_signal_handlers_block_by_func">
+<description>
+Blocks all handlers on an instance that match @func and @data.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> The instance to block handlers from.
+</parameter_description>
+</parameter>
+<parameter name="func">
+<parameter_description> The C closure callback of the handlers (useless for non-C closures).
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> The closure data of the handlers' closures.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The number of handlers that matched.
+</return>
+</function>
+
<function name="g_signal_handlers_block_matched">
<description>
Blocks all handlers on an instance that match a certain selection criteria.
</return>
</function>
+<function name="g_signal_handlers_disconnect_by_data">
+<description>
+Disconnects all handlers on an instance that match @data.
+
+Since: 2.32
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> The instance to remove handlers from
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> the closure data of the handlers' closures
+</parameter_description>
+</parameter>
+</parameters>
+<return> The number of handlers that matched.
+
+</return>
+</function>
+
+<function name="g_signal_handlers_disconnect_by_func">
+<description>
+Disconnects all handlers on an instance that match @func and @data.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> The instance to remove handlers from.
+</parameter_description>
+</parameter>
+<parameter name="func">
+<parameter_description> The C closure callback of the handlers (useless for non-C closures).
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> The closure data of the handlers' closures.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The number of handlers that matched.
+</return>
+</function>
+
<function name="g_signal_handlers_disconnect_matched">
<description>
Disconnects all handlers on an instance that match a certain
</return>
</function>
+<function name="g_signal_handlers_unblock_by_func">
+<description>
+Unblocks all handlers on an instance that match @func and @data.
+
+
+</description>
+<parameters>
+<parameter name="instance">
+<parameter_description> The instance to unblock handlers from.
+</parameter_description>
+</parameter>
+<parameter name="func">
+<parameter_description> The C closure callback of the handlers (useless for non-C closures).
+</parameter_description>
+</parameter>
+<parameter name="data">
+<parameter_description> The closure data of the handlers' closures.
+</parameter_description>
+</parameter>
+</parameters>
+<return> The number of handlers that matched.
+</return>
+</function>
+
<function name="g_signal_handlers_unblock_matched">
<description>
Unblocks all handlers on an instance that match a certain selection
g_slist_append(), g_slist_prepend(), g_slist_insert() and
g_slist_insert_sorted() functions and so is rarely used on its own.
+
</description>
<parameters>
</parameters>
<description>
A convenience macro to get the next element in a #GSList.
+
</description>
<parameters>
<parameter name="slist">
</parameter>
</parameters>
<return> the #GMutex corresponding to @mutex.
+
</return>
</function>
</parameter>
</parameters>
<return> %TRUE, if the #GStaticMutex could be locked.
+
</return>
</function>
</parameter>
</parameters>
<return> %TRUE, if @mutex could be locked.
+
</return>
</function>
</parameters>
<return> number of times @mutex has been locked by the current
thread.
+
</return>
</function>
@lock for reading and returns %TRUE. This lock has to be unlocked by
g_static_rw_lock_reader_unlock().
-Deprectated: 2.32: Use g_rw_lock_reader_trylock() instead
</description>
<parameters>
</parameter>
</parameters>
<return> %TRUE, if @lock could be locked for reading.
+
+Deprectated: 2.32: Use g_rw_lock_reader_trylock() instead
</return>
</function>
%FALSE. Otherwise it locks @lock for writing and returns %TRUE. This
lock has to be unlocked by g_static_rw_lock_writer_unlock().
-Deprectated: 2.32: Use g_rw_lock_writer_trylock() instead
</description>
<parameters>
</parameter>
</parameters>
<return> %TRUE, if @lock could be locked for writing.
+
+Deprectated: 2.32: Use g_rw_lock_writer_trylock() instead
</return>
</function>
<function name="g_strcmp0">
<description>
-Compares @str1 and @str2 like strcmp(). Handles %NULL
+Compares @str1 and @str2 like strcmp(). Handles %NULL
gracefully by sorting it before non-%NULL strings.
Comparing two %NULL pointers returns 0.
</parameter_description>
</parameter>
</parameters>
-<return> -1, 0 or 1, if @str1 is <, == or > than @str2.
+<return> an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.
</return>
</function>
* context is already owned by another thread.
* /
g_test_expect_message (G_LOG_DOMAIN,
-G_LOG_LEVEL_CRITICIAL,
+G_LOG_LEVEL_CRITICAL,
"assertion.*acquired_context.*failed");
g_main_context_push_thread_default (bad_context);
g_test_assert_expected_messages ();
</parameter>
</parameters>
<return> the new #GThread on success.
+
</return>
</function>
including any fractional part. The @microseconds out parameter is
essentially useless.
+
</description>
<parameters>
<parameter name="timer">
Creates a new timer, and starts timing (i.e. g_timer_start() is
implicitly called for you).
+
</description>
<parameters>
</parameters>
</return>
</function>
+<function name="g_try_new">
+<description>
+Attempts to allocate @n_structs elements of type @struct_type, and returns
+%NULL on failure. Contrast with g_new(), which aborts the program on failure.
+The returned pointer is cast to a pointer to the given type.
+The function returns %NULL when @n_structs is 0 of if an overflow occurs.
+
+Since: 2.8
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the allocated memory, cast to a pointer to @struct_type
+</return>
+</function>
+
+<function name="g_try_new0">
+<description>
+Attempts to allocate @n_structs elements of type @struct_type, initialized
+to 0's, and returns %NULL on failure. Contrast with g_new0(), which aborts
+the program on failure.
+The returned pointer is cast to a pointer to the given type.
+The function returns %NULL when @n_structs is 0 of if an overflow occurs.
+
+Since: 2.8
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the allocated memory, cast to a pointer to @struct_type
+</return>
+</function>
+
<function name="g_try_realloc">
<description>
Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL
</return>
</function>
+<function name="g_try_renew">
+<description>
+Attempts to reallocate the memory pointed to by @mem, so that it now has
+space for @n_structs elements of type @struct_type, and returns %NULL on
+failure. Contrast with g_renew(), which aborts the program on failure.
+It returns the new address of the memory, which may have been moved.
+The function returns %NULL if an overflow occurs.
+
+Since: 2.8
+
+</description>
+<parameters>
+<parameter name="struct_type">
+<parameter_description> the type of the elements to allocate
+</parameter_description>
+</parameter>
+<parameter name="mem">
+<parameter_description> the currently allocated memory
+</parameter_description>
+</parameter>
+<parameter name="n_structs">
+<parameter_description> the number of elements to allocate
+</parameter_description>
+</parameter>
+</parameters>
+<return> a pointer to the new allocated memory, cast to a pointer to @struct_type
+</return>
+</function>
+
<function name="g_tuples_destroy">
<description>
Frees the records which were returned by g_relation_select(). This
</parameter>
</parameters>
<return> the field of the record.
+
</return>
</function>
<function name="g_type_init">
<description>
-Prior to any use of the type system, g_type_init() has to be called
-to initialize the type system and assorted other code portions
-(such as the various fundamental type implementations or the signal
-system).
-
-This function is idempotent: If you call it multiple times, all but
-the first calls will be silently ignored.
-
-There is no way to undo the effect of g_type_init().
+This function used to initialise the type system. Since GLib 2.36,
+the type system is initialised automatically and this function does
+nothing.
-Since version 2.24 this also initializes the thread system
+Deprecated: 2.36: the type system is now initialised automatically
</description>
<parameters>
<function name="g_type_init_with_debug_flags">
<description>
-Similar to g_type_init(), but additionally sets debug flags.
+This function used to initialise the type system with debugging
+flags. Since GLib 2.36, the type system is initialised automatically
+and this function does nothing.
+
+If you need to enable debugging features, use the GOBJECT_DEBUG
+environment variable.
-This function is idempotent.
+Deprecated: 2.36: the type system is now initialised automatically
</description>
<parameters>
<function name="g_unix_signal_source_new">
<description>
Create a #GSource that will be dispatched upon delivery of the UNIX
-signal @signum. Currently only <literal>SIGHUP</literal>,
-<literal>SIGINT</literal>, and <literal>SIGTERM</literal> can
-be monitored. Note that unlike the UNIX default, all sources which
-have created a watch will be dispatched, regardless of which
-underlying thread invoked g_unix_signal_source_new().
+signal @signum. In GLib versions before 2.36, only
+<literal>SIGHUP</literal>, <literal>SIGINT</literal>,
+<literal>SIGTERM</literal> can be monitored. In GLib 2.36,
+<literal>SIGUSR1</literal> and <literal>SIGUSR2</literal> were
+added.
+
+Note that unlike the UNIX default, all sources which have created a
+watch will be dispatched, regardless of which underlying thread
+invoked g_unix_signal_source_new().
For example, an effective use of this function is to handle <literal>SIGTERM</literal>
cleanly; flushing any outstanding files, and then calling
</return>
</function>
+<function name="g_utf8_next_char">
+<description>
+Skips to the next character in a UTF-8 string. The string must be
+valid; this macro is as fast as possible, and has no error-checking.
+You would use this macro to iterate over a string character by
+character. The macro returns the start of the next UTF-8 character.
+Before using this macro, use g_utf8_validate() to validate strings
+that may contain invalid UTF-8.
+
+</description>
+<parameters>
+<parameter name="p">
+<parameter_description> Pointer to the start of a valid UTF-8 character
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
<function name="g_utf8_normalize">
<description>
Converts a string into canonical form, standardizing
</return>
</function>
+<function name="g_variant_get_data_as_bytes">
+<description>
+Returns a pointer to the serialised form of a #GVariant instance.
+The semantics of this function are exactly the same as
+g_variant_get_data(), except that the returned #GBytes holds
+a reference to the variant data.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="value">
+<parameter_description> a #GVariant
+</parameter_description>
+</parameter>
+</parameters>
+<return> A new #GBytes representing the variant data
+
+</return>
+</function>
+
<function name="g_variant_get_double">
<description>
Returns the double precision floating point value of @value.
</return>
</function>
+<function name="g_variant_new_from_bytes">
+<description>
+Constructs a new serialised-mode #GVariant instance. This is the
+inner interface for creation of new serialised values that gets
+called from various functions in gvariant.c.
+
+A reference is taken on @bytes.
+
+Since: 2.36
+
+</description>
+<parameters>
+<parameter name="type">
+<parameter_description> a #GVariantType
+</parameter_description>
+</parameter>
+<parameter name="bytes">
+<parameter_description> a #GBytes
+</parameter_description>
+</parameter>
+<parameter name="trusted">
+<parameter_description> if the contents of @bytes are trusted
+</parameter_description>
+</parameter>
+</parameters>
+<return> a new #GVariant with a floating reference
+
+</return>
+</function>
+
<function name="g_variant_new_from_data">
<description>
Creates a new #GVariant instance from serialised data.
Officially, the language understood by the parser is "any string
produced by g_variant_print()".
+
</description>
<parameters>
<parameter name="type">
<return></return>
</function>
+<function name="g_warn_if_fail">
+<description>
+Logs a warning if the expression is not true.
+
+Since: 2.16
+
+</description>
+<parameters>
+<parameter name="expr">
+<parameter_description> the expression to check
+</parameter_description>
+</parameter>
+</parameters>
+<return></return>
+</function>
+
+<function name="g_warn_if_reached">
+<description>
+Logs a critical warning.
+
+Since: 2.16
+
+</description>
+<parameters>
+</parameters>
+<return></return>
+</function>
+
<function name="g_warning">
<description>
A convenience function/macro to log a warning message.
<return></return>
</function>
+<function name="gchararray">
+<description>
+A C representable type name for #G_TYPE_STRING.
+
+</description>
+<parameters>
+</parameters>
+<return></return>
+</function>
+
<function name="gconstpointer">
<description>
An untyped pointer to constant data.
<return></return>
</function>
+<function name="gunichar">
+<description>
+A type which can hold any UTF-32 or UCS-4 character code,
+also known as a Unicode code point.
+
+If you want to produce the UTF-8 representation of a #gunichar,
+use g_ucs4_to_utf8(). See also g_utf8_to_ucs4() for the reverse
+process.
+
+To print/scan values of this type as integer, use
+%G_GINT32_MODIFIER and/or %G_GUINT32_FORMAT.
+
+The notation to express a Unicode code point in running text is
+as a hexadecimal number with four to six digits and uppercase
+letters, prefixed by the string "U+". Leading zeros are omitted,
+unless the code point would have fewer than four hexadecimal digits.
+For example, "U+0041 LATIN CAPITAL LETTER A". To print a code point
+in the U+-notation, use the format string "U+\%04"G_GINT32_FORMAT"X".
+To scan, use the format string "U+\%06"G_GINT32_FORMAT"X".
+
+|[
+gunichar c;
+sscanf ("U+0041", "U+%06"G_GINT32_FORMAT"X", &c)
+g_print ("Read U+%04"G_GINT32_FORMAT"X", c);
+]|
+
+</description>
+<parameters>
+</parameters>
+<return></return>
+</function>
+
+<function name="gunichar2">
+<description>
+A type which can hold any UTF-16 code
+point<footnote id="utf16_surrogate_pairs">UTF-16 also has so called
+<firstterm>surrogate pairs</firstterm> to encode characters beyond
+the BMP as pairs of 16bit numbers. Surrogate pairs cannot be stored
+in a single gunichar2 field, but all GLib functions accepting gunichar2
+arrays will correctly interpret surrogate pairs.</footnote>.
+
+To print/scan values of this type to/from text you need to convert
+to/from UTF-8, using g_utf16_to_utf8()/g_utf8_to_utf16().
+
+To print/scan values of this type as integer, use
+%G_GINT16_MODIFIER and/or %G_GUINT16_FORMAT.
+
+</description>
+<parameters>
+</parameters>
+<return></return>
+</function>
+
<function name="gushort">
<description>
Corresponds to the standard C <type>unsigned short</type> type.
Returns: the summary
See set_summary() for more information
+ Since: 2.14
</description>
<parameters>
</parameters>
<return> the summary
-
- Since: 2.14
</return>
</function>
Returns: the description
See set_description() for more information
+ Since: 2.14
</description>
<parameters>
</parameters>
<return> the description
-
- Since: 2.14
</return>
</function>
<description>
Return value: the value associated with the key as a double.
+Since: 2.14
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> the value associated with the key as a double, or
0.0 if the key was not found or could not be parsed.
-
-Since: 2.14
</return>
</function>
Loads a key file into an empty KeyFile instance.
If the file could not be loaded then a FileError or KeyFileError exception is thrown.
+Since: 2.6
\throw Glib::FileError
\throw Glib::KeyFileError
</description>
</parameter_description>
</parameter>
</parameters>
-<return> %TRUE if a key file could be loaded, %FALSE othewise
-Since: 2.6
+<return> %TRUE if a key file could be loaded, %FALSE otherwise
</return>
</function>
<description>
Returns the value associated with @key under @group_name.
+Since: 2.6
+
\throw Glib::FileError in the event the key cannot be found (with the Glib::KEY_FILE_ERROR_KEY_NOT_FOUND code).
\throw Glib::KeyFileError in the event that the @group_name cannot be found (with the Glib::KEY_FILE_ERROR_GROUP_NOT_FOUND).
</description>
</parameter>
</parameters>
<return> The value as a string.
-
-Since: 2.6
</return>
</function>
@comment will be read from above the first group in the file.
Use the overrides for a %NULL @key or @group.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameter>
</parameters>
<return> The comment
-
-Since: 2.6
</return>
</function>
Looks whether the key file has the key @key in the group
@group_name.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> %TRUE if @key is a part of @group_name, %FALSE
otherwise.
-
-Since: 2.6
</return>
</function>
<description>
Return value: a newly allocated string or %NULL.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> a newly allocated string or %NULL if the specified
key cannot be found.
-
-Since: 2.6
</return>
</function>
<description>
Return value: a newly allocated string or %NULL.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> a newly allocated string or %NULL if the specified
key cannot be found.
-
-Since: 2.6
</return>
</function>
<description>
Return value: a newly allocated string or %NULL.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> a newly allocated string or %NULL if the specified
key cannot be found.
-
-Since: 2.6
</return>
</function>
<description>
Return value: the value associated with the key as a boolean.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> the value associated with the key as a boolean,
or %FALSE if the key was not found or could not be parsed.
-
-Since: 2.6
</return>
</function>
<description>
Return value: the value associated with the key as an integer.
+Since: 2.6
+
\throw Glib::KeyFileError
</description>
<parameters>
</parameters>
<return> the value associated with the key as an integer, or
0 if the key was not found or could not be parsed.
-
-Since: 2.6
</return>
</function>
(c-name "GDateTime")
)
+(define-object GArray
+ (in-module "GLib")
+ (c-name "GArray")
+)
+
+(define-object IOChannel
+ (in-module "GLib")
+ (c-name "GIOChannel")
+)
+
(define-object KeyFile
(in-module "GLib")
(c-name "GKeyFile")
static Glib::RefPtr<IOChannel> create_from_fd(int fd);
_IGNORE(g_io_channel_unix_new)
-/* defined(DOXYGEN_SHOULD_SKIP_THIS) actually does the opposite of what it looks like... */
-#if defined(G_OS_WIN32) || defined(DOXYGEN_SHOULD_SKIP_THIS)
+#ifdef G_OS_WIN32
/** Create an I/O channel for C runtime (emulated Unix-like) file descriptors.
* After calling add_watch() on a I/O channel returned by this function, you
static Glib::RefPtr<IOChannel> create_from_win32_socket(int socket);
_IGNORE(g_io_channel_win32_new_socket)
-#endif /* defined(G_OS_WIN32) || defined(DOXYGEN_SHOULD_SKIP_THIS) */
+#endif /* G_OS_WIN32 */
/** Read a single UCS-4 character.
* @retval thechar The Unicode character.
/** Constructor that should be used by derived classes.
* Use this constructor if you want to inherit from IOChannel.
- * It will set up a GIOChannel that will call the vfuncs of your
+ * It will set up a GIOChannel that will call the vfuncs of your
* class even if it is being used from C code, and it will keep
* a reference to the C++ code while the GIOChannel exists.
*/
{
GError* gerror = 0;
const bool value =
- static_cast<bool>(g_key_file_get_boolean(const_cast<GKeyFile*>(gobj()),
+ static_cast<bool>(g_key_file_get_boolean(const_cast<GKeyFile*>(gobj()),
0, key.c_str(), &gerror));
if(gerror)
Glib::Error::throw_exception(gerror);
void KeyFile::set_double(const Glib::ustring& key, double value)
{
- g_key_file_set_double(gobj(), 0, key.c_str(), value);
+ g_key_file_set_double(gobj(), 0, key.c_str(), value);
}
# define GLIBMM_ERROR_ARG
*/
_WRAP_GERROR(KeyFileError, GKeyFileError, G_KEY_FILE_ERROR, NO_GTYPE)
-/** This class lets you parse, edit or create files containing groups of key-value pairs, which we call key files
- * for lack of a better name. Several freedesktop.org specifications use key files now, e.g the Desktop Entry
+/** This class lets you parse, edit or create files containing groups of key-value pairs, which we call key files
+ * for lack of a better name. Several freedesktop.org specifications use key files now, e.g the Desktop Entry
* Specification and the Icon Theme Specification.
*
- * The syntax of key files is described in detail in the Desktop Entry Specification, here is a quick summary: Key
- * files consists of groups of key-value pairs, interspersed with comments.
+ * The syntax of key files is described in detail in the Desktop Entry Specification, here is a quick summary: Key
+ * files consists of groups of key-value pairs, interspersed with comments.
*
* @code
* # this is just an example
*
* Lines beginning with a '#' and blank lines are considered comments.
*
- * Groups are started by a header line containing the group name enclosed in '[' and ']', and ended implicitly by
+ * Groups are started by a header line containing the group name enclosed in '[' and ']', and ended implicitly by
* the start of the next group or the end of the file. Each key-value pair must be contained in a group.
- *
- * Key-value pairs generally have the form key=value, with the exception of localized strings, which have the form
- * key[locale]=value. Space before and after the '=' character are ignored. Newline, tab, carriage return and
- * backslash characters in value are escaped as \\n, \\t, \\r, and \\\\, respectively. To preserve leading spaces in
+ *
+ * Key-value pairs generally have the form key=value, with the exception of localized strings, which have the form
+ * key[locale]=value. Space before and after the '=' character are ignored. Newline, tab, carriage return and
+ * backslash characters in value are escaped as \\n, \\t, \\r, and \\\\, respectively. To preserve leading spaces in
* values, these can also be escaped as \\s.
- *
- * Key files can store strings (possibly with localized variants), integers, booleans and lists of these. Lists are
- * separated by a separator character, typically ';' or ','. To use the list separator character in a value in a
+ *
+ * Key files can store strings (possibly with localized variants), integers, booleans and lists of these. Lists are
+ * separated by a separator character, typically ';' or ','. To use the list separator character in a value in a
* list, it has to be escaped by prefixing it with a backslash.
- *
- * This syntax is obviously inspired by the .ini files commonly met on Windows, but there are some important
+ *
+ * This syntax is obviously inspired by the .ini files commonly met on Windows, but there are some important
* differences:
* - .ini files use the ';' character to begin comments, key files use the '#' character.
* - Key files allow only comments before the first group.
* - Key files are always encoded in UTF-8.
* - Key and Group names are case-sensitive, for example a group called [GROUP] is a different group from [group].
- *
- * Note that in contrast to the Desktop Entry Specification, groups in key files may contain the same key multiple
- * times; the last entry wins. Key files may also contain multiple groups with the same name; they are merged
- * together. Another difference is that keys and group names in key files are not restricted to ASCII characters.
+ *
+ * Note that in contrast to the Desktop Entry Specification, groups in key files may contain the same key multiple
+ * times; the last entry wins. Key files may also contain multiple groups with the same name; they are merged
+ * together. Another difference is that keys and group names in key files are not restricted to ASCII characters.
*
* @newin{2,14}
*/
_IGNORE(g_key_file_free)
/** Creates a glibmm KeyFile wrapper for a GKeyFile object.
- * Note, when using this that when the wrapper is deleted,
- * it will not automatically deleted the GKeyFile unless you
- * set the delete_c_instance boolean to true.
- * @param castitem The C instance to wrap
- * @param delete_c_instance If the C instance should be deleted when
+ * Note, when using this that when the wrapper is deleted,
+ * it will not automatically delete the GKeyFile unless you
+ * set the @a takes_ownership boolean to <tt>true</tt>.
+ * @param castitem The C instance to wrap.
+ * @param takes_ownership If the C instance should be deleted when
* the wrapper is deleted.
*/
KeyFile(GKeyFile* castitem, bool takes_ownership = false);
public:
- _WRAP_METHOD(bool load_from_file(const std::string& filename, KeyFileFlags flags = Glib::KEY_FILE_NONE), g_key_file_load_from_file, errthrow)
+ _WRAP_METHOD(bool load_from_file(const std::string& file, KeyFileFlags flags = Glib::KEY_FILE_NONE), g_key_file_load_from_file, errthrow)
/** Loads a KeyFile from memory
* @param data The data to use as a KeyFile
/** Associates a new double value with @a key under the start group.
* If @a key cannot be found then it is created.
- *
+ *
* @newin{2,12}
* @param key A key.
* @param value An double value.
_WRAP_METHOD(void set_int64(const Glib::ustring& group_name, const Glib::ustring& key, gint64 value), g_key_file_set_int64)
_WRAP_METHOD(void set_uint64(const Glib::ustring& group_name, const Glib::ustring& key, guint64 value), g_key_file_set_uint64)
- /** Sets a list of string values for @a key under @a group_name. If
+ /** Sets a list of string values for @a key under @a group_name. If
* key cannot be found it is created. If @a group_name cannot be found
* it is created.
* @param group_name The name of a group
static void text(GMarkupParseContext* context,
const char* text,
- gsize text_len,
+ gsize text_len,
void* user_data,
GError** error);
static void passthrough(GMarkupParseContext* context,
const char* passthrough_text,
- gsize text_len,
+ gsize text_len,
void* user_data,
GError** error);
void ParserCallbacks::text(GMarkupParseContext* context,
const char* text,
- gsize text_len,
+ gsize text_len,
void* user_data,
GError** error)
{
void ParserCallbacks::passthrough(GMarkupParseContext* context,
const char* passthrough_text,
- gsize text_len,
+ gsize text_len,
void* user_data,
GError** error)
{
_IGNORE(g_module_open, g_module_close)
public:
-
+
/** Opens a module.
*
* First of all it tries to open file_name as a module. If that
namespace Glib
{
-//Hand-written, instead of using _WRAP_ENUM,
+//Hand-written, instead of using _WRAP_ENUM,
//because the C enum values don't have a prefix.
/** Specifies the type of traveral performed by methods such as NodeTree::_traverse() and NodeTree::find().
- *
+ *
* @ingroup glibmmEnums
*/
enum TraverseType
/** N-ary Trees - trees of data with any number of branches
* The NodeTree class and its associated functions provide an N-ary tree data structure, in which nodes in the tree can contain arbitrary data.
- *
+ *
* To insert a node into a tree use insert(), insert_before(), append() or prepend().
- *
+ *
* To create a new node and insert it into a tree use insert_data(), insert_data_before(), append_data() and prepend_data().
- *
+ *
* To reverse the children of a node use reverse_children().
- *
+ *
* To find a node use root(), find(), find_child(), index_of(), child_index(), first_child(), last_child(), nth_child(), first_sibling(), prev_sibling(), next_sibling() or last_sibling().
- *
+ *
* To get information about a node or tree use is_leaf(), is_root(), depth(), node_count(), child_count(), is_ancestor() or max_height().
- *
+ *
* To traverse a tree, calling a function for each node visited in the traversal, use traverse() or foreach().
- *
+ *
* To remove a node or subtree from a tree use unlink().
*
* @newin{2,18}
*/
-template <typename T>
+template <typename T>
class NodeTree
{
_CLASS_GENERIC(NodeTree, GNode)
/** Inserts a NodeTree beneath the parent at the given position.
*
- * @param position the position to place node at, with respect to its siblings
+ * @param position the position to place node at, with respect to its siblings
* If position is -1, node is inserted as the last child of parent
* @param node the NodeTree to insert
* @return the inserted NodeTree
/** Inserts a NodeTree as the first child.
*
- * @param data the data for the NodeTree
+ * @param node the NodeTree to prepend
* @return the NodeTree
*/
NodeTree<T>& prepend(NodeTree<T>& node)
/** Inserts a new NodeTree at the given position.
*
- * @param position the position to place the new NodeTree at.
+ * @param position the position to place the new NodeTree at.
* If position is -1, the new NodeTree is inserted as the last child of parent
- * @param data the data for the new NodeTree
+ * @param the_data the data for the new NodeTree
* @return the new NodeTree
*/
NodeTree<T>* insert_data(int position, const T& the_data)
/** Inserts a new NodeTree before the given sibling.
*
- * @param sibling the sibling NodeTree to place node before.
- * @param data the data for the new NodeTree
+ * @param sibling the sibling NodeTree to place node before.
+ * @param the_data the data for the new NodeTree
* @return the new NodeTree
*/
NodeTree<T>* insert_data_before(NodeTree<T>& sibling, const T& the_data)
/** Inserts a new NodeTree as the last child.
*
- * @param data the data for the new NodeTree
+ * @param the_data the data for the new NodeTree
* @return the new NodeTree
*/
NodeTree<T>* append_data(const T& the_data)
/** Inserts a new NodeTree as the first child.
*
- * @param data the data for the new NodeTree
+ * @param the_data the data for the new NodeTree
* @return the new NodeTree
*/
NodeTree<T>* prepend_data(const T& the_data)
};
/** Traverses a tree starting at the current node.
- * It calls the given function for each node visited.
+ * It calls the given function for each node visited.
* The traversal can be halted at any point by returning true from @a func.
*
* @param order The order in which nodes are visited.
* @param flags Which types of children are to be visited.
- * @param max_depth The maximum depth of the traversal.
- * Nodes below this depth will not be visited.
+ * @param max_depth The maximum depth of the traversal.
+ * Nodes below this depth will not be visited.
* If max_depth is -1 all nodes in the tree are visited.
* If max_depth is 1, only the root is visited.
* If max_depth is 2, the root and its children are visited. And so on.
/** Finds the first child of a NodeTree with the given data.
*
* @param flags Which types of children are to be visited, one of TRAVERSE_ALL, TRAVERSE_LEAVES and TRAVERSE_NON_LEAVES.
- * @param data The data for which to search.
+ * @param the_data The data for which to search.
* @return the found child, or 0 if the data is not found
*/
NodeTree<T>* find_child(const T& the_data, TraverseFlags flags = TRAVERSE_ALL)
type_foreach_gnode_slot bound_slot = sigc::bind(real_slot, the_data, &child);
g_node_children_foreach(gobj(), (GTraverseFlags)flags, c_callback_foreach_compare_child, reinterpret_cast<gpointer>(&bound_slot));
-
+
return wrap(child);
}
/** Finds the first child of a NodeTree with the given data.
*
* @param flags Which types of children are to be visited, one of TRAVERSE_ALL, TRAVERSE_LEAVES and TRAVERSE_NON_LEAVES.
- * @param data The data for which to search.
+ * @param the_data The data for which to search.
* @return the found child, or 0 if the data is not found
*/
const NodeTree<T>* find_child(const T& the_data, TraverseFlags flags = TRAVERSE_ALL) const
*
* @param order The order in which nodes are visited: IN_ORDER, TRAVERSE_PRE_ORDER, TRAVERSE_POST_ORDER, or TRAVERSE_LEVEL_ORDER
* @param flags Which types of children are to be visited: one of TRAVERSE_ALL, TRAVERSE_LEAVES and TRAVERSE_NON_LEAVES.
- * @param data The data for which to search.
+ * @param the_data The data for which to search.
* @return The found node, or 0 if the data is not found.
*/
NodeTree<T>* find(const T& the_data, TraverseType order = TRAVERSE_IN_ORDER, TraverseFlags flags = TRAVERSE_ALL)
*
* @param order The order in which nodes are visited.
* @param flags Which types of children are to be visited.
- * @param data The data for which to search.
+ * @param the_data The data for which to search.
* @return The found node, or 0 if the data is not found.
*/
const NodeTree<T>* find(const T& the_data, TraverseType order = TRAVERSE_IN_ORDER, TraverseFlags flags = TRAVERSE_ALL) const
/** Gets the position of the first child which contains the given data.
*
- * @param data The data to find.
+ * @param the_data The data to find.
* @return The index of the child which contains data, or -1 if the data is not found.
*/
int child_index(const T& the_data) const
}
_IGNORE(g_node_child_index)
- /** Gets the position with respect to its siblings.
+ /** Gets the position with respect to its siblings.
* child must be a child of node.
* The first child is numbered 0, the second 1, and so on.
*
/** Gets the first child.
*
- * @return The first child, or 0 if the node has no children.
+ * @return The first child, or 0 if the node has no children.
*/
NodeTree<T>* first_child()
{
/** Gets the first child.
*
- * @return The first child, or 0 if the node has no children.
+ * @return The first child, or 0 if the node has no children.
*/
const NodeTree<T>* first_child() const
{
*
* @return The nth child, or 0 if n is too large.
*/
- NodeTree<T>* nth_child(int n)
+ NodeTree<T>* nth_child(int n)
{
return wrap(g_node_nth_child(gobj(), n));
}
return const_cast<NodeTree<T>*>(this)->nth_child(n);
}
_IGNORE(g_node_nth_child)
-
+
/** Gets the first sibling
* @return The first sibling, or 0 if the node has no siblings.
*/
{
if(has_ownership_)
g_option_context_free(gobj());
-
+
gobject_ = 0;
}
* @param parameter_string A string which is displayed in the first line of --help output, after programname [OPTION...]
*/
explicit OptionContext(const Glib::ustring& parameter_string = Glib::ustring());
-
+
//Note that, unlike Glib::Wrap(), this would create a second C++ instance for the same C instance,
//so it should be used carefully. For instance you could not access data in a derived class via this second instance.
explicit OptionContext(GOptionContext* castitem, bool take_ownership = false);
virtual ~OptionContext();
-
+
_WRAP_METHOD(void set_help_enabled(bool help_enabled = true), g_option_context_set_help_enabled)
_WRAP_METHOD(bool get_help_enabled() const, g_option_context_get_help_enabled)
_WRAP_METHOD(void set_ignore_unknown_options(bool ignore_unknown = true), g_option_context_set_ignore_unknown_options)
//g_option_context_add_main_entries(), just creates a group internally, adds them to it, and does a set_main_group()
//- a group without callbacks seems to do some simple default parsing.
_IGNORE(g_option_context_add_main_entries)
-
- /** Adds an OptionGroup to the context, so that parsing with context will recognize the options in the group.
+
+ /** Adds an OptionGroup to the context, so that parsing with context will recognize the options in the group.
* Note that the group will not be copied, so it should exist for as long as the context exists.
*
* @param group The group to add.
*/
void add_group(OptionGroup& group);
_IGNORE(g_option_context_add_group)
-
- /** Sets an OptionGroup as the main group of the context. This has the same effect as calling add_group(), the only
+
+ /** Sets an OptionGroup as the main group of the context. This has the same effect as calling add_group(), the only
* difference is that the options in the main group are treated differently when generating --help output.
* Note that the group will not be copied, so it should exist for as long as the context exists.
*
*/
void set_main_group(OptionGroup& group);
_IGNORE(g_option_context_set_main_group)
-
+
//We don't need this (hopefully), and the memory management would be really awkward.
//OptionGroup& get_main_group();
//const OptionGroup& get_main_group() const;
#m4 _CONVERSION(`const OptionGroup&',`GOptionGroup*',`const_cast<GOptionGroup*>(($3).gobj())')
_WRAP_METHOD(Glib::ustring get_help(bool main_help, const OptionGroup& group) const, g_option_context_get_help)
-
- /** Returns a formatted, translated help text for the given context.
- * To obtain the text produced by --help, call get_help (true).
+
+ /** Returns a formatted, translated help text for the given context.
+ * To obtain the text produced by --help, call get_help (true).
* To obtain the text produced by --help-all, call get_help(false).
* To obtain the help text for an option group, call get_help(false, group).
*
OptionEntry::~OptionEntry()
{
- g_free(const_cast<char*>(gobject_->long_name));
+ g_free(const_cast<char*>(gobject_->long_name));
g_free(const_cast<char*>(gobject_->description));
g_free(const_cast<char*>(gobject_->arg_description));
- g_free(gobject_);
+ g_free(gobject_);
}
OptionEntry::OptionEntry(const OptionEntry& src)
gobject_->arg_data = src.gobject_->arg_data; //Shared, because it's not owned by any instance of this class anyway.
if(gobject_->description)
- g_free(const_cast<char*>(gobject_->description));
+ g_free(const_cast<char*>(gobject_->description));
gobject_->description = g_strdup(src.gobject_->description);
gobject_->long_name = 0;
}
- //Note that we do not use NULL for an empty string,
+ //Note that we do not use NULL for an empty string,
//because G_OPTION_REMAINING is actually a "", so it actually has a distinct meaning:
- //TODO: Wrap G_OPTION_REMAINING in C++ somehow, maybe as an explicit set_long_name(void) or set_is_remaining()? murrayc.
+ //TODO: Wrap G_OPTION_REMAINING in C++ somehow, maybe as an explicit set_long_name(void) or set_is_remaining()? murrayc.
gobj()->long_name = (value).c_str() ? g_strdup((value).c_str()) : 0;
}
gobj()->arg_description = (value).empty() ? 0 : g_strdup((value).c_str());
}
-
+
} // namespace Glib
namespace Glib
{
-/** An OptionEntry defines a single option. To have an effect, it must be added to an OptionGroup with
+/** An OptionEntry defines a single option. To have an effect, it must be added to an OptionGroup with
* OptionGroup::add_entry().
- *
- * The long name of an option can be used to specify it in a commandline as --long_name.
- * Every option must have a long name. To resolve conflicts if multiple option groups contain the same long name, it is also
+ *
+ * The long name of an option can be used to specify it in a commandline as --long_name.
+ * Every option must have a long name. To resolve conflicts if multiple option groups contain the same long name, it is also
* possible to specify the option as --groupname-long_name.
*
* If an option has a short name, it can be specified as -short_name in a commandline.
*
* The description for the option is shown in the --help output.
*
- * The arg_descripton is the placeholder to use for the extra argument parsed by the option in --help output.
+ * The arg_descripton is the placeholder to use for the extra argument parsed by the option in --help output.
*/
class OptionEntry
{
OptionEntry();
OptionEntry(const OptionEntry& src);
virtual ~OptionEntry();
-
+
OptionEntry& operator=(const OptionEntry& src);
//#m4 _CONVERSION(`Glib::ustring',`const gchar*',`($3).empty() ? NULL : g_strdup(($3).c_str())')
-
+
_MEMBER_GET(long_name, long_name, Glib::ustring, const char*)
void set_long_name(const Glib::ustring& value);
-
+
_MEMBER_GET(short_name, short_name, gchar, gchar)
_MEMBER_SET(short_name, short_name, gchar, gchar)
-
+
_MEMBER_GET(flags, flags, int, int)
/** Set one or more OptionEntry::Flags.
* Do not set FLAG_FILENAME. Character encoding is chosen when the OptionEntry
* is added to an OptionGroup.
*/
_MEMBER_SET(flags, flags, int, int)
-
+
_MEMBER_GET(description, description, Glib::ustring, const char*)
void set_description(const Glib::ustring& value);
-
+
_MEMBER_GET(arg_description, arg_description, Glib::ustring, const char*)
void set_arg_description(const Glib::ustring& value);
-
+
GOptionEntry* gobj() { return gobject_; }
const GOptionEntry* gobj() const { return gobject_; }
-
+
protected:
GOptionEntry* gobject_;
bool is_filename_option() const
{ return slot_filename_ != 0; }
-
+
const OptionGroup::SlotOptionArgString* get_slot_string() const
{ return slot_string_; }
-
+
const OptionGroup::SlotOptionArgFilename* get_slot_filename() const
{ return slot_filename_; }
//Glib::StringArrayHandle array_handle(*typed_arg, Glib::OWNERSHIP_NONE);
//The SUN Forte compiler complains about this:
- // "optiongroup.cc", line 354: Error: Cannot assign Glib::ArrayHandle<Glib::ustring,
- // Glib::Container_Helpers::TypeTraits<Glib::ustring>> to std::vector<Glib::ustring> without
+ // "optiongroup.cc", line 354: Error: Cannot assign Glib::ArrayHandle<Glib::ustring,
+ // Glib::Container_Helpers::TypeTraits<Glib::ustring>> to std::vector<Glib::ustring> without
// "std::vector<Glib::ustring>::operator=(const std::vector<Glib::ustring>&)";.
//
//(*typed_cpp_arg) = array_handle;
char*** typed_arg = static_cast<char***>(carg_);
vecustrings* typed_cpp_arg = static_cast<vecustrings*>(cpparg_);
if(typed_arg && typed_cpp_arg)
- {
+ {
typed_cpp_arg->clear();
//See comments above about the SUN Forte and Tru64 compilers.
break;
}
}
-}
+}
GOptionGroup* OptionGroup::gobj_give_ownership()
{
class OptionContext;
#endif //DOXYGEN_SHOULD_SKIP_THIS
-/** An OptionGroup defines the options in a single group.
+/** An OptionGroup defines the options in a single group.
* Libraries which need to parse commandline options are expected to provide a function that allows their OptionGroups to
* be added to the application's OptionContext.
*/
* const Glib::ustring& value, bool has_value);.
*/
typedef sigc::slot<bool, const Glib::ustring&, const Glib::ustring&, bool> SlotOptionArgString;
-
+
/** For example bool on_option_arg_filename(const Glib::ustring& option_name,
* const std::string& value, bool has_value);.
*/
OptionGroup(const Glib::ustring& name, const Glib::ustring& description, const Glib::ustring& help_description = Glib::ustring());
- /** This always takes ownership of the underlying GOptionGroup,
- * so it is only useful with C functions that return newly-allocated GOptionGroups.
+ /** This always takes ownership of the underlying GOptionGroup,
+ * so it is only useful with C functions that return newly-allocated GOptionGroups.
*/
- explicit OptionGroup(GOptionGroup* castitem);
+ explicit OptionGroup(GOptionGroup* castitem);
_IGNORE(g_option_group_new)
virtual ~OptionGroup();
void add_entry(const OptionEntry& entry, int& arg);
void add_entry(const OptionEntry& entry, double& arg);
void add_entry(const OptionEntry& entry, Glib::ustring& arg);
- void add_entry_filename(const OptionEntry& entry, std::string& arg);
+ void add_entry_filename(const OptionEntry& entry, std::string& arg);
void add_entry(const OptionEntry& entry, vecustrings& arg);
void add_entry_filename(const OptionEntry& entry, vecstrings& arg);
void add_entry(const OptionEntry& entry, const SlotOptionArgString& slot);
/** Perl-compatible regular expressions - matches strings against regular expressions.
*
- * The Glib::Regex functions implement regular expression pattern matching using
+ * The Glib::Regex functions implement regular expression pattern matching using
* syntax and semantics similar to Perl regular expression.
*
- * Some functions accept a start_position argument, setting it differs from just
- * passing over a shortened string and setting REGEX_MATCH_NOTBOL in the case
- * of a pattern that begins with any kind of lookbehind assertion. For example,
- * consider the pattern "\Biss\B" which finds occurrences of "iss" in the middle
- * of words. ("\B" matches only if the current position in the subject is not a
- * word boundary.) When applied to the string "Mississipi" from the fourth byte,
- * namely "issipi", it does not match, because "\B" is always false at the
- * start of the subject, which is deemed to be a word boundary. However, if
- * the entire string is passed , but with start_position set to 4, it finds the
+ * Some functions accept a start_position argument, setting it differs from just
+ * passing over a shortened string and setting REGEX_MATCH_NOTBOL in the case
+ * of a pattern that begins with any kind of lookbehind assertion. For example,
+ * consider the pattern "\Biss\B" which finds occurrences of "iss" in the middle
+ * of words. ("\B" matches only if the current position in the subject is not a
+ * word boundary.) When applied to the string "Mississipi" from the fourth byte,
+ * namely "issipi", it does not match, because "\B" is always false at the
+ * start of the subject, which is deemed to be a word boundary. However, if
+ * the entire string is passed , but with start_position set to 4, it finds the
* second occurrence of "iss" because it is able to look behind the starting point
* to discover that it is preceded by a letter.
*
- * Note that, unless you set the REGEX_RAW flag, all the strings passed to these
+ * Note that, unless you set the REGEX_RAW flag, all the strings passed to these
* functions must be encoded in UTF-8. The lengths and the positions inside the
- * strings are in bytes and not in characters, so, for instance,
- * "\xc3\xa0" (i.e. "Ã ") is two bytes long but it is treated as a single
+ * strings are in bytes and not in characters, so, for instance,
+ * "\xc3\xa0" (i.e. "Ã ") is two bytes long but it is treated as a single
* character. If you set REGEX_RAW the strings can be non-valid UTF-8 strings
- * and a byte is treated as a character, so "\xc3\xa0" is two bytes and
+ * and a byte is treated as a character, so "\xc3\xa0" is two bytes and
* two characters long.
*
- * When matching a pattern, "\n" matches only against a "\n" character in the
- * string, and "\r" matches only a "\r" character. To match any newline sequence
- * use "\R". This particular group matches either the two-character sequence
+ * When matching a pattern, "\n" matches only against a "\n" character in the
+ * string, and "\r" matches only a "\r" character. To match any newline sequence
+ * use "\R". This particular group matches either the two-character sequence
* CR + LF ("\r\n"), or one of the single characters LF (linefeed, U+000A, "\n"),
- * VT (vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"), CR (carriage
- * return, U+000D, "\r"), NEL (next line, U+0085), LS (line separator, U+2028),
+ * VT (vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"), CR (carriage
+ * return, U+000D, "\r"), NEL (next line, U+0085), LS (line separator, U+2028),
* or PS (paragraph separator, U+2029).
*
- * The behaviour of the dot, circumflex, and dollar metacharacters are affected
+ * The behaviour of the dot, circumflex, and dollar metacharacters are affected
* by newline characters, the default is to recognize any newline character (the
* same characters recognized by "\R"). This can be changed with REGEX_NEWLINE_CR,
- * REGEX_NEWLINE_LF and REGEX_NEWLINE_CRLF compile options, and with
- * REGEX_MATCH_NEWLINE_ANY, REGEX_MATCH_NEWLINE_CR, REGEX_MATCH_NEWLINE_LF
- * and REGEX_MATCH_NEWLINE_CRLF match options. These settings are also
+ * REGEX_NEWLINE_LF and REGEX_NEWLINE_CRLF compile options, and with
+ * REGEX_MATCH_NEWLINE_ANY, REGEX_MATCH_NEWLINE_CR, REGEX_MATCH_NEWLINE_LF
+ * and REGEX_MATCH_NEWLINE_CRLF match options. These settings are also
* relevant when compiling a pattern if REGEX_EXTENDED is set, and an unescaped
- * "#" outside a character class is encountered. This indicates a comment that
+ * "#" outside a character class is encountered. This indicates a comment that
* lasts until after the next newline.
*
- * Creating and manipulating the same Glib::Regex class from different threads is
- * not a problem as Glib::Regex does not modify its internal state between creation and
+ * Creating and manipulating the same Glib::Regex class from different threads is
+ * not a problem as Glib::Regex does not modify its internal state between creation and
* destruction, on the other hand Glib::MatchInfo is not threadsafe.
*
- * The regular expressions low level functionalities are obtained through the
- * excellent PCRE library written by Philip Hazel.
+ * The regular expressions low level functionalities are obtained through the
+ * excellent PCRE library written by Philip Hazel.
*
* @newin{2,14}
*/
public:
static Glib::RefPtr<Glib::Regex> create(const Glib::ustring& pattern, RegexCompileFlags compile_options = static_cast<RegexCompileFlags>(0), RegexMatchFlags match_options = static_cast<RegexMatchFlags>(0));
-
+
_WRAP_METHOD(Glib::ustring get_pattern() const, g_regex_get_pattern)
_WRAP_METHOD(int get_max_backref() const, g_regex_get_max_backref)
_WRAP_METHOD(int get_capture_count() const, g_regex_get_capture_count)
_WRAP_METHOD(bool get_has_cr_or_lf() const, g_regex_get_has_cr_or_lf)
-
+
_WRAP_METHOD(int get_string_number(const Glib::ustring& name) const, g_regex_get_string_number)
_WRAP_METHOD(RegexCompileFlags get_compile_flags() const, g_regex_get_compile_flags)
_WRAP_METHOD(RegexMatchFlags get_match_flags() const, g_regex_get_match_flags)
* which might emit it. Actually, proxies are controlled by
* the template derivatives, which serve as gatekeepers for the
* types allowed on a particular signal.
- *
*/
class SignalProxyNormal : public SignalProxyBase
{
public:
~SignalProxyNormal();
- /// stops the current signal emmision (not in libsigc++)
+ /// Stops the current signal emission (not in libsigc++)
void emission_stop();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
- /** Create a proxy for a signal that can be emitted by @a obj.
+ /** Creates a proxy for a signal that can be emitted by @a obj.
* @param obj The object that can emit the signal.
* @param info Information about the signal, including its name, and the C callbacks that should be called by glib.
*/
SignalProxyNormal(Glib::ObjectBase* obj, const SignalProxyInfo* info);
- /** Connects a signal to a generic signal handler. This is called by connect() in derived SignalProxy classes.
+ /** Connects a generic signal handler to a signal.
+ * This is called by connect() in derived SignalProxy classes.
*
- * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
+ * @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
* @param after Whether this signal handler should be called before or after the default signal handler.
*/
sigc::slot_base& connect_(const sigc::slot_base& slot, bool after);
- /** Connects a signal to a signal handler without a return value.
- * This is called by connect() in derived SignalProxy classes.
+ /** Connects a signal handler without a return value to a signal.
+ * This is called by connect_notify() in derived SignalProxy classes.
*
- * By default, the signal handler will be called before the default signal handler,
- * in which case any return value would be replaced anyway by that of the later signal handler.
- *
- * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
+ * @param slot The signal handler, which should have a @c void return type,
+ * usually created with sigc::mem_fun() or sigc::ptr_fun().
* @param after Whether this signal handler should be called before or after the default signal handler.
*/
sigc::slot_base& connect_notify_(const sigc::slot_base& slot, bool after);
private:
const SignalProxyInfo* info_;
- //TODO: We could maybe replace both connect_ and connect_notify_ with this in future, because they don't do anything extra.
- /** This is called by connect_ and connect_impl_.
+ //TODO: We could maybe replace both connect_() and connect_notify_() with this in future, because they don't do anything extra.
+ /** This is called by connect_() and connect_notify_().
*/
sigc::slot_base& connect_impl_(GCallback callback, const sigc::slot_base& slot, bool after);
SignalProxyNormal& operator=(const SignalProxyNormal&);
};
-
dnl
dnl GLIB_SIGNAL_PROXY([P1, P2, ...],return type)
dnl
/**** Glib::[SignalProxy]NUM($1) ***************************************************/
/** Proxy for signals with NUM($1) arguments.
- * Use the connect() method, with sigc::mem_fun() or sigc::ptr_fun() to connect signals to signal handlers.
+ * Use the connect() or connect_notify() method, with sigc::mem_fun() or sigc::ptr_fun()
+ * to connect signal handlers to signals.
*/
template <LIST(class R,ARG_CLASS($1))>
class [SignalProxy]NUM($1) : public SignalProxyNormal
[SignalProxy]NUM($1)(ObjectBase* obj, const SignalProxyInfo* info)
: SignalProxyNormal(obj, info) {}
- /** Connects a signal to a signal handler.
+ /** Connects a signal handler to a signal.
+ *
* For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
*
- * @param slot The signal handler, usually created with sigc::mem_fun(), or sigc::ptr_fun().
+ * @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
* @param after Whether this signal handler should be called before or after the default signal handler.
*/
sigc::connection connect(const SlotType& slot, bool after = true)
{ return sigc::connection(connect_(slot, after)); }
- /** Connects a signal to a signal handler without a return value.
- * By default, the signal handler will be called before the default signal handler,
- * in which case any return value would be replaced anyway by that of the later signal handler.
+ /** Connects a signal handler without a return value to a signal.
+ * By default, the signal handler will be called before the default signal handler.
*
- * For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
+ * For instance, connect_notify( sigc::mem_fun(*this, &TheClass::on_something) );
+ *
+ * If the signal requires signal handlers with a @c void return type,
+ * the only difference between connect() and connect_notify() is the default
+ * value of @a after.
*
- * @param slot The signal handler, which should have a void return type, usually created with sigc::mem_fun(), or sigc::ptr_fun().
+ * If the signal requires signal handlers with a return value of type T,
+ * connect_notify() binds <tt>return T()</tt> to the connected signal handler.
+ * For instance, if the return type is @c bool, the following two calls are equivalent.
+ * @code
+ * connect_notify( sigc::mem_fun(*this, &TheClass::on_something) );
+ * connect( sigc::bind_return<bool>(sigc::mem_fun(*this, &TheClass::on_something), false), false );
+ * @endcode
+ *
+ * @param slot The signal handler, which should have a @c void return type,
+ * usually created with sigc::mem_fun() or sigc::ptr_fun().
* @param after Whether this signal handler should be called before or after the default signal handler.
*/
sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
} // namespace Glib
-
#endif /* __header__ */
* specified by the only argument that must be provided, @a argv.
* The first string in @a argv is of
* course the name of the program to execute. By default, the name of
- * the program must be a full path; the PATH shell variable
+ * the program must be a full path; the PATH shell variable
* will only be searched if you pass the SPAWN_SEARCH_PATH flag.
*
* On Windows, note that all the string or string vector arguments to
* the child's environment.
*
* @a flags should be the bitwise OR of any flags you want to affect the
- * function's behaviour. The SPAWN_DO_NOT_REAP_CHILD flags means that
+ * function's behaviour. The SPAWN_DO_NOT_REAP_CHILD flags means that
* the child will not automatically be reaped; you must use a
- * ChildWatch source to be notified about the death of the child
+ * ChildWatch source to be notified about the death of the child
* process. Eventually you must call spawn_close_pid() on the
* @a child_pid, in order to free resources which may be associated
* with the child process. (On Unix, using a ChildWatch source is
- * equivalent to calling waitpid() or handling the SIGCHLD signal
+ * equivalent to calling waitpid() or handling the SIGCHLD signal
* manually. On Windows, calling spawn_close_pid() is equivalent
- * to calling CloseHandle() on the process handle returned in
+ * to calling CloseHandle() on the process handle returned in
* @a child_pid).
*
* PAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file
* descriptors will be inherited by the child; otherwise all
* descriptors except stdin/stdout/stderr will be closed before
- * calling exec() in the child. SPAWN_SEARCH_PATH
+ * calling exec() in the child. SPAWN_SEARCH_PATH
* means that argv[0] need not be an absolute path, it
- * will be looked for in the user's PATH.
- * SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will
- * be discarded, instead of going to the same location as the parent's
+ * will be looked for in the user's PATH.
+ * SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will
+ * be discarded, instead of going to the same location as the parent's
* standard output. If you use this flag, @a standard_output must be NULL.
* SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
* will be discarded, instead of going to the same location as the parent's
* SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
* process using the Win32 API, for example wait for its termination
* with the WaitFor*() functions, or examine its
- * exit code with GetExitCodeProcess(). You should close the handle
+ * exit code with GetExitCodeProcess(). You should close the handle
* with CloseHandle() or spawn_close_pid() when you no longer need it.
*
* If non-NULL, the @a standard_input, @a standard_output, @a standard_error
* when they are no longer in use. If these parameters are NULL, the corresponding
* pipe won't be created.
*
- * If @a standard_input is NULL, the child's standard input is attached to
+ * If @a standard_input is NULL, the child's standard input is attached to
* /dev/null unless SPAWN_CHILD_INHERITS_STDIN is set.
*
- * If @a standard_error is NULL, the child's standard error goes to the same
- * location as the parent's standard error unless SPAWN_STDERR_TO_DEV_NULL
+ * If @a standard_error is NULL, the child's standard error goes to the same
+ * location as the parent's standard error unless SPAWN_STDERR_TO_DEV_NULL
* is set.
*
- * If @a standard_output is NULL, the child's standard output goes to the same
- * location as the parent's standard output unless SPAWN_STDOUT_TO_DEV_NULL
+ * If @a standard_output is NULL, the child's standard output goes to the same
+ * location as the parent's standard output unless SPAWN_STDOUT_TO_DEV_NULL
* is set.
*
* If @a child_pid is not NULL and an error does not occur then the returned
* pid must be closed using spawn_close_pid().
*
* @note
- * If you are writing a gtkmm application, and the program you
+ * If you are writing a gtkmm application, and the program you
* are spawning is a graphical application, too, then you may
- * want to use spawn_on_screen_with_pipes() instead to ensure that
+ * want to use spawn_on_screen_with_pipes() instead to ensure that
* the spawned program opens its windows on the right screen.
*
* @param working_directory Child's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
int* standard_output = 0,
int* standard_error = 0);
-/** See pawn_async_with_pipes() for a full description. This function
+/** See spawn_async_with_pipes() for a full description. This function
* simply calls the spawn_async_with_pipes() without any pipes.
- *
+ *
* @note
- * If you are writing a GTK+ application, and the program you
+ * If you are writing a GTK+ application, and the program you
* are spawning is a graphical application, too, then you may
- * want to use gdk_spawn_on_screen() instead to ensure that
+ * want to use gdk_spawn_on_screen() instead to ensure that
* the spawned program opens its windows on the right screen.
*
* @param working_directory Child's current working directory, or an empty string to inherit parent's.
* @param argv Child's argument vector.
- * @param env Child's environment.
+ * @param envp Child's environment.
* @param flags Flags from SpawnFlags.
* @param child_setup Slot to run in the child just before exec().
* @param child_pid Return location for child process ID, or NULL
*
* @param working_directory Child's current working directory, or an empty string to inherit parent's.
* @param argv Child's argument vector.
- * @param env Child's environment.
* @param flags Flags from SpawnFlags.
* @param child_setup Slot to run in the child just before exec().
* @param child_pid Return location for child process ID, or NULL
/** Executes a child synchronously (waits for the child to exit before returning).
* All output from the child is stored in @a standard_output and @a standard_error,
- * if those parameters are non-NULL. Note that you must set the
+ * if those parameters are non-NULL. Note that you must set the
* SPAWN_STDOUT_TO_DEV_NULL and SPAWN_STDERR_TO_DEV_NULL flags when
* passing NULL for @a standard_output and @a standard_error.
* If @a exit_status is non-NULL, the exit status of the child is stored
- * there as it would be returned by waitpid(); standard UNIX macros such
+ * there as it would be returned by waitpid(); standard UNIX macros such
* as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status.
* Note that this function calls waitpid() even if @a exit_status is NULL, and
* does not accept the SPAWN_DO_NOT_REAP_CHILD flag.
- * If an error occurs, no data is returned in @a standard_output,
- * @a standard_error, or @a exit_status.
+ * If an error occurs, no data is returned in @a standard_output,
+ * @a standard_error, or @a exit_status.
*
* This function calls spawn_async_with_pipes() internally; see that
* function for full details on the other parameters and details on
* how these functions work on Windows.
- *
+ *
* @param working_directory Child's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
* @param argv Child's argument vector.
* @param envp Child's environment.
int* exit_status = 0);
/** Like the main spawn_sync() method, but inheriting the parent's environment.
- *
+ *
* @param working_directory Child's current working directory, or an empty string to inherit the parent's, in the GLib file name encoding.
* @param argv Child's argument vector.
* @param flags Flags from SpawnFlags
* command line in the background. Unlike spawn_async(), the
* SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
* that SPAWN_SEARCH_PATH can have security implications, so
- * consider using spawn_async() directly if appropriate.
- *
+ * consider using spawn_async() directly if appropriate.
+ *
* The same concerns on Windows apply as for spawn_command_line_sync().
*
* @param command_line A command line.
* If @a exit_status is non-NULL, the exit status of the child is stored there as
* it would be returned by waitpid(); standard UNIX macros such as WIFEXITED()
* and WEXITSTATUS() must be used to evaluate the exit status.
- *
+ *
* On Windows, please note the implications of shell_parse_argv()
- * parsing @a command_line. Parsing is done according to Unix shell rules, not
+ * parsing @a command_line. Parsing is done according to Unix shell rules, not
* Windows command interpreter rules.
* Space is a separator, and backslashes are
* special. Thus you cannot simply pass a @a command_line containing
* separator. You need to enclose such paths with single quotes, like
* "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
*
- * @param command_line A command line.
+ * @param command_line A command line.
* @param standard_output Return location for child output.
* @param standard_error Return location for child errors.
* @param exit_status Return location for child exit status, as returned by waitpid().
*
* @param pid The process identifier to close.
*/
-void spawn_close_pid(Pid pid);
+void spawn_close_pid(Pid pid);
/** @} group Spawn */
{
// This was always meant as an internal method. It is no longer called,
-// and no longer needs to be called. We are keeping it just to avoid
+// and no longer needs to be called. We are keeping it just to avoid
// breaking ABI, though hopefully nobody is using it anyway.
// TODO: Remove this when we can break ABI.
void thread_init_impl()
void thread_init(GThreadFunctions* /* vtable */)
{
//g_thread_init() is deprecated and now does nothing,
- //so we do not even call it. That avoids a need to link to gthread-2.0,
+ //so we do not even call it. That avoids a need to link to gthread-2.0,
//which contains the empty g_thread_init() implementation.
//g_thread_init(vtable);
-
+
Glib::thread_init_impl();
}
//Stop the deprecation ifdef guards around the API declarations:
#undef G_DISABLE_DEPRECATED
-//Stop the compiler warnings about using the deprecated API;
+//Stop the compiler warnings about using the deprecated API;
#define GLIB_DISABLE_DEPRECATION_WARNINGS 1
#define GLIBMM_G_DISABLE_DEPRECATED_UNDEFED 1
* @relates Glib::StaticRecMutex
* @hideinitializer
*
- * @deprecated Glib::StaticRecMutex is deprecated in favour of Glib::Threads::RecMutex, which can be used statically.
+ * @deprecated Glib::StaticRecMutex is deprecated in favour of Glib::Threads::RecMutex, which can be used statically.
*/
#define GLIBMM_STATIC_REC_MUTEX_INIT { G_STATIC_REC_MUTEX_INIT }
* @relates Glib::StaticRWLock
* @hideinitializer
*
- * @deprecated Glib::StaticRWLock is deprecated in favour of Glib::Threads::RWLock, which can be used statically.
+ * @deprecated Glib::StaticRWLock is deprecated in favour of Glib::Threads::RWLock, which can be used statically.
*/
#define GLIBMM_STATIC_RW_LOCK_INIT { G_STATIC_RW_LOCK_INIT }
* @relates Glib::StaticPrivate
* @hideinitializer
*
- * @deprecated Glib::StaticPrivate is deprecated in favour of Glib::Threads::Private, which can be used statically.
+ * @deprecated Glib::StaticPrivate is deprecated in favour of Glib::Threads::Private, which can be used statically.
*/
#define GLIBMM_STATIC_PRIVATE_INIT { G_STATIC_PRIVATE_INIT }
* @return The new Thread* on success.
* @throw Glib::ThreadError
*
- * @deprecated Use the simpler create() method instead, because all Threads
+ * @deprecated Use the simpler create() method instead, because all Threads
* are now joinable, and bounds and priority parameters now have no effect.
*/
static Thread* create(const sigc::slot<void>& slot, unsigned long stack_size,
* @deprecated All threads are now joinable.
*/
bool joinable() const;
-
+
/** Changes the priority of the thread to @a priority.
* @note It is not guaranteed, that threads with different priorities really
* behave accordingly. On some systems (e.g. Linux) only @c root can
* conversion to Mutex&, thus you can safely use Mutex::Lock with a
* StaticMutex.
*
- * @deprecated Use Glib::Threads::Mutex instead, which can be used statically.
+ * @deprecated Use Glib::Threads::Mutex instead, which can be used statically.
*/
struct StaticMutex
{
* @relates Glib::StaticMutex
* @hideinitializer
*
- * @deprecated Glib::StaticMutex is deprecated in favour of Glib::Threads::Mutex, which can be used statically.
+ * @deprecated Glib::StaticMutex is deprecated in favour of Glib::Threads::Mutex, which can be used statically.
*/
#define GLIBMM_STATIC_MUTEX_INIT { G_STATIC_MUTEX_INIT }
RWLock::WriterLock& operator=(const RWLock::WriterLock&);
};
-/** An opaque data structure to represent a condition.
- * A @a Cond is an object that threads can block on, if they find a certain
- * condition to be false. If other threads change the state of this condition
+/** An opaque data structure to represent a condition.
+ * A @a Cond is an object that threads can block on, if they find a certain
+ * condition to be false. If other threads change the state of this condition
* they can signal the @a Cond, such that the waiting thread is woken up.
* @par Usage example:
* @code
Cond();
~Cond();
- /** If threads are waiting for this @a Cond, exactly one of them is woken up.
- * It is good practice to hold the same lock as the waiting thread, while calling
+ /** If threads are waiting for this @a Cond, exactly one of them is woken up.
+ * It is good practice to hold the same lock as the waiting thread, while calling
* this method, though not required.
*
*/
void signal();
/** If threads are waiting for this @a Cond, all of them are woken up.
- * It is good practice to hold the same lock as the waiting thread, while calling
+ * It is good practice to hold the same lock as the waiting thread, while calling
* this method, though not required.
*/
void broadcast();
* The mutex is unlocked before falling asleep and locked again before resuming.
*
* @param mutex a @a Mutex that is currently locked.
- *
+ *
* @note It is important to use the @a wait() and @a timed_wait() methods
- * only inside a loop, which checks for the condition to be true as it is not
- * guaranteed that the waiting thread will find it fulfilled, even if the signaling
- * thread left the condition in that state. This is because another thread can have
- * altered the condition, before the waiting thread got the chance to be woken up,
+ * only inside a loop, which checks for the condition to be true as it is not
+ * guaranteed that the waiting thread will find it fulfilled, even if the signaling
+ * thread left the condition in that state. This is because another thread can have
+ * altered the condition, before the waiting thread got the chance to be woken up,
* even if the condition itself is protected by a @a Mutex.
*/
void wait(Mutex& mutex);
*
* @param mutex a @a Mutex that is currently locked.
* @param abs_time a max time to wait.
- *
+ *
* @note It is important to use the @a wait() and @a timed_wait() methods
- * only inside a loop, which checks for the condition to be true as it is not
- * guaranteed that the waiting thread will find it fulfilled, even if the signaling
- * thread left the condition in that state. This is because another thread can have
- * altered the condition, before the waiting thread got the chance to be woken up,
+ * only inside a loop, which checks for the condition to be true as it is not
+ * guaranteed that the waiting thread will find it fulfilled, even if the signaling
+ * thread left the condition in that state. This is because another thread can have
+ * altered the condition, before the waiting thread got the chance to be woken up,
* even if the condition itself is protected by a @a Mutex.
*/
bool timed_wait(Mutex& mutex, const Glib::TimeVal& abs_time);
/**** Glib::Thread *********************************************************/
// static
-Thread* Thread::create(const sigc::slot<void>& slot)
+Thread* Thread::create(const sigc::slot<void>& slot, const std::string& name)
{
// Make a copy of slot on the heap
sigc::slot_base *const slot_copy = new sigc::slot<void>(slot);
GError* error = 0;
+ GThread* thread;
- GThread *const thread = g_thread_try_new(NULL,
- &call_thread_entry_slot, slot_copy, &error);
+ if (name.size() > 0)
+ thread = g_thread_try_new(name.c_str(), &call_thread_entry_slot,
+ slot_copy, &error);
+ else
+ thread = g_thread_try_new(NULL, &call_thread_entry_slot,
+ slot_copy, &error);
if(error)
{
}
// static
+Thread* Thread::create(const sigc::slot<void>& slot)
+{
+ return create(slot, std::string());
+}
+
+// static
Thread* Thread::self()
{
return reinterpret_cast<Thread*>(g_thread_self());
_DEFS(glibmm,glib)
_CONFIGINCLUDE(glibmmconfig.h)
+
+// We use the (now deprecated) GThread definition in the API,
+// and we cannot stop that without breaking ABI.
+// (see the comment below),
+// so we must temporarily undef G_DISABLE_DEPRECATED when
+// including glib.h.
+
+// Temporarily undef G_DISABLE_DEPRECATED, redefining it later if appropriate.
+#if defined(G_DISABLE_DEPRECATED) && !defined(GLIBMM_G_DISABLE_DEPRECATED_UNDEFED)
+
+//Stop the deprecation ifdef guards around the API declarations:
+#undef G_DISABLE_DEPRECATED
+
+//Stop the compiler warnings about using the deprecated API;
+#define GLIB_DISABLE_DEPRECATION_WARNINGS 1
+
+#define GLIBMM_G_DISABLE_DEPRECATED_UNDEFED 1
+
+#endif
+
#include <glib.h>
+// Redefine G_DISABLE_DEPRECATED if it was defined before we temporarily undefed it:
+#if defined(GLIBMM_G_DISABLE_DEPRECATED_UNDEFED)
+#define G_DISABLE_DEPRECATED 1
+#undef GLIB_DISABLE_DEPRECATION_WARNINGS
+#undef GLIBMM_G_DISABLE_DEPRECATED_UNDEFED
+#endif
+
+
#include <glibmm/error.h>
#include <sigc++/sigc++.h>
class Exit;
//See http://bugzilla.gnome.org/show_bug.cgi?id=512348 about the sigc::trackable issue.
+ // TODO: At the next ABI break, consider changing const sigc::slot<void>& slot
+ // to const std::function<void()>& func, if it can be assumed that all supported
+ // compilers understand the C++11 template class std::function<>.
/** Creates a new thread.
* You can wait for this thread's termination by calling join().
*
* pass additional arguments using sigc::bind(). If the thread was created
* successfully, it is returned, otherwise a Threads::ThreadError exception is thrown.
*
- * Because sigc::trackable is not thread safe, if the slot represents a
- * non-static class method (that is, it is created by sigc::mem_fun()), the
- * class concerned should not derive from sigc::trackable.
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static class method and is created by sigc::mem_fun(), the class concerned
+ * should not derive from sigc::trackable. You can use, say, boost::bind() or,
+ * in C++11, std::bind() or a C++11 lambda expression instead of sigc::mem_fun().
*
* @param slot A slot to execute in the new thread.
* @return The new Thread* on success.
*/
static Thread* create(const sigc::slot<void>& slot);
+ // TODO: At next ABI break, remove the single parameter create
+ // method and default name to std::string()
+
+ /** Creates a new named thread.
+ * You can wait for this thread's termination by calling join().
+ *
+ * The new thread executes the function or method @a slot points to. You can
+ * pass additional arguments using sigc::bind(). If the thread was created
+ * successfully, it is returned, otherwise a Threads::ThreadError exception is thrown.
+ *
+ * Because sigc::trackable is not thread-safe, if the slot represents a
+ * non-static class method and is created by sigc::mem_fun(), the class concerned
+ * should not derive from sigc::trackable. You can use, say, boost::bind() or,
+ * in C++11, std::bind() or a C++11 lambda expression instead of sigc::mem_fun().
+ *
+ * The @a name can be useful for discriminating threads in a debugger.
+ * Some systems restrict the length of @a name to 16 bytes.
+ *
+ * @param slot A slot to execute in the new thread.
+ * @param name A name for the new thread.
+ * @return The new Thread* on success.
+ * @throw Glib::Threads::ThreadError
+ *
+ * @newin{2,36}
+ */
+ static Thread* create(const sigc::slot<void>& slot, const std::string& name);
+
/** Returns the Thread* corresponding to the calling thread.
* @return The current thread.
*/
RWLock::WriterLock& operator=(const RWLock::WriterLock&);
};
-/** An opaque data structure to represent a condition.
- * A @a Cond is an object that threads can block on, if they find a certain
- * condition to be false. If other threads change the state of this condition
+/** An opaque data structure to represent a condition.
+ * A @a Cond is an object that threads can block on, if they find a certain
+ * condition to be false. If other threads change the state of this condition
* they can signal the @a Cond, such that the waiting thread is woken up.
* @par Usage example:
* @code
Cond();
~Cond();
- /** If threads are waiting for this @a Cond, exactly one of them is woken up.
- * It is good practice to hold the same lock as the waiting thread, while calling
+ /** If threads are waiting for this @a Cond, exactly one of them is woken up.
+ * It is good practice to hold the same lock as the waiting thread, while calling
* this method, though not required.
*
*/
void signal();
/** If threads are waiting for this @a Cond, all of them are woken up.
- * It is good practice to hold the same lock as the waiting thread, while calling
+ * It is good practice to hold the same lock as the waiting thread, while calling
* this method, though not required.
*/
void broadcast();
* The mutex is unlocked before falling asleep and locked again before resuming.
*
* @param mutex a @a Mutex that is currently locked.
- *
+ *
* @note It is important to use the @a wait() and @a wait_until() methods
- * only inside a loop, which checks for the condition to be true as it is not
- * guaranteed that the waiting thread will find it fulfilled, even if the signaling
- * thread left the condition in that state. This is because another thread can have
- * altered the condition, before the waiting thread got the chance to be woken up,
+ * only inside a loop, which checks for the condition to be true as it is not
+ * guaranteed that the waiting thread will find it fulfilled, even if the signaling
+ * thread left the condition in that state. This is because another thread can have
+ * altered the condition, before the waiting thread got the chance to be woken up,
* even if the condition itself is protected by a @a Mutex.
*/
void wait(Mutex& mutex);
- /** Waits until this thread is woken up on this @a Cond, but not longer than until the time, that is specified by @a abs_time.
+ /** Waits until this thread is woken up on this @a Cond, but not longer than until the time, that is specified by @a end_time.
* The mutex is unlocked before falling asleep and locked again before resuming.
*
* @param mutex a @a Mutex that is currently locked.
- * @param abs_time a max time to wait.
- *
+ * @param end_time a max time to wait.
+ *
* @note It is important to use the @a wait() and @a wait_until() methods
- * only inside a loop, which checks for the condition to be true as it is not
- * guaranteed that the waiting thread will find it fulfilled, even if the signaling
- * thread left the condition in that state. This is because another thread can have
- * altered the condition, before the waiting thread got the chance to be woken up,
+ * only inside a loop, which checks for the condition to be true as it is not
+ * guaranteed that the waiting thread will find it fulfilled, even if the signaling
+ * thread left the condition in that state. This is because another thread can have
+ * altered the condition, before the waiting thread got the chance to be woken up,
* even if the condition itself is protected by a @a Mutex.
*/
bool wait_until(Mutex& mutex, gint64 end_time);
* Various uri-related functions.
*/
-//Note that the illegal_characters and reserved_chars_allowed parameters are bytes and may not be UTF-8
+//Note that the illegal_characters and reserved_chars_allowed parameters are bytes and may not be UTF-8
//so they are not Glib::ustring. See http://bugzilla.gnome.org/show_bug.cgi?id=508773
/** Unescapes a whole escaped string.
* If any of the characters in @a illegal_characters or the character zero appears
- * as an escaped character in @a escaped_string then that is an error and an empty string
+ * as an escaped character in @a escaped_string then that is an error and an empty string
* will be returned. This is useful it you want to avoid, for instance, having a
* slash being expanded in an escaped path element, which might confuse pathname
* handling.
* @param escaped_string An escaped string to be unescaped.
* @param illegal_characters An optional string of illegal characters not to be allowed.
* @result An unescaped version of @a escaped_string.
- *
+ *
* @ingroup UriUtils
* @newin{2,16}
*/
std::string uri_unescape_string(const std::string& escaped_string, const std::string& illegal_characters = std::string());
-//TODO: Use iterator?
+//TODO: Use iterator?
//char * g_uri_unescape_segment (const char *escaped_string,
// const char *escaped_string_end,
// const char *illegal_characters);
/** Gets the scheme portion of a URI. RFC 3986 decodes the scheme as:
* @code
- * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+ * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
* @endcode
* Common schemes include "file", "http", "svn+ssh", etc.
*
* @param uri
- * @result The "Scheme" component of the URI, or an empty string on error.
- *
+ * @result The "Scheme" component of the URI, or an empty string on error.
+ *
* @ingroup UriUtils
* @newin{2,16}
*/
VariantContainerBase result = VariantContainerBase(g_variant_new_tuple(
var_array, children.size()));
-
- g_variant_ref_sink(result.gobj());
-
delete[] var_array;
-
return result;
}
//static
VariantContainerBase
-VariantContainerBase::create_maybe(const VariantType& child_type,
+VariantContainerBase::create_maybe(const VariantType& child_type,
const VariantBase& child)
{
GVariant* g_variant = g_variant_new_maybe(child_type.gobj(),
const_cast<GVariant*>(child.gobj()));
-
VariantContainerBase result = VariantContainerBase(g_variant);
-
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
/****************** Specializations ***********************************/
+VariantBase::operator const void*() const
+{
+ return gobj() ? GINT_TO_POINTER(1) : 0;
+}
+
void VariantBase::init(const GVariant* cobject, bool take_a_reference)
{
if(gobject_)
Variant<VariantBase> Variant<VariantBase>::create(const VariantBase& data)
{
Variant<VariantBase> result = Variant<VariantBase>(g_variant_new_variant(const_cast<GVariant*>(data.gobj())));
-
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
{
Variant<Glib::ustring> result =
Variant<Glib::ustring>(g_variant_new_string(data.c_str()));
-
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
{
Variant<std::string> result =
Variant<std::string>(g_variant_new_bytestring(data.c_str()));
-
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
Variant<type_vec_ustring>(g_variant_new(
array_variant_type.get_string().c_str(), builder));
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
// Terminate the string array.
str_array[data.size()] = NULL;
- // Create the variant using the builder.
+ // Create the variant using g_variant_new_bytestring_array() (passing the
+ // newly constructed array.
Variant<type_vec_string> result =
Variant<type_vec_string>(g_variant_new_bytestring_array(str_array,
data.size()));
g_strfreev(str_array);
+ return result;
+}
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
+Variant<type_vec_string>
+Variant<type_vec_string>::create_from_object_paths(const type_vec_string& data)
+{
+ // Create a string array to add the strings of the vector to.
+ char** str_array = g_new(char*, data.size() + 1);
+ // Add the elements of the vector into the string array.
+ for(type_vec_string::size_type i = 0; i < data.size(); i++)
+ {
+ str_array[i] = g_strdup(data[i].c_str());
+ }
+
+ // Terminate the string array.
+ str_array[data.size()] = NULL;
+
+ // Create the variant using g_variant_new_objv() (passing the
+ // newly constructed array.
+ Variant<type_vec_string> result =
+ Variant<type_vec_string>(g_variant_new_objv(str_array, data.size()));
+
+ g_strfreev(str_array);
return result;
}
* information about the type of that value. The range of possible
* values is determined by the type. The type system used is VariantType.
*
- * See the VariantBase class and it's derived types, such as VariantContainerbase,
+ * See the VariantBase class and it's derived types, such as VariantContainerBase,
* and the Variant<> template type.
*
* Variant instances always have a type and a value (which are given
g_variant_get, g_variant_get_va)
public:
+ /** This typedef is just to make it more obvious that
+ * our operator const void* should be used like operator bool().
+ */
+ typedef const void* BoolExpr;
+
+ /** Test whether the Variant has an underlying instance.
+ *
+ * Mimics usage of pointers:
+ * @code
+ * if (variant)
+ * do_something();
+ * @endcode
+ *
+ * @newin{2,36}
+ */
+ operator BoolExpr() const;
+
/** Replace the underlying GVariant.
* This is for use by methods that take a VariantBase& as an output
* parameter.
*/
void init(const GVariant* cobject, bool take_a_reference = false);
+// It's necessary to take an extra reference of the 'const GVariantType*'
+// returned by g_variant_get_type() because it doesn't do that already.
+#m4 _CONVERSION(`const GVariantType*',`VariantType',`Glib::wrap(const_cast<GVariantType*>($3), true)')
_WRAP_METHOD(VariantType get_type() const, g_variant_get_type)
+
_WRAP_METHOD(std::string get_type_string() const, g_variant_get_type_string)
_WRAP_METHOD(bool is_floating() const, g_variant_is_floating)
_WRAP_METHOD(bool is_of_type(const VariantType& type) const, g_variant_is_of_type)
#m4 _CONVERSION(`const VariantBase&',`gconstpointer',`const_cast<GVariant*>(($3).gobj())')
_WRAP_METHOD(guint hash() const, g_variant_hash)
+
+ /** Checks if @a *this and @a other have the same type and value.
+ *
+ * @newin{2,24}
+ * @param other The Variant to compare with.
+ * @return <tt>true</tt> if @a *this and @a other are equal.
+ */
_WRAP_METHOD(bool equal(const VariantBase& other) const, g_variant_equal)
/** Gets a VariantBase instance that has the same value as this variant and
template<class V_CastTo>
static V_CastTo cast_dynamic(const VariantBase& v) throw(std::bad_cast);
+private:
+ /** Relational operators are deleted to prevent invalid conversion
+ * to const void*.
+ */
+ bool operator<(const VariantBase& src) const;
+
+ /// See operator<().
+ bool operator<=(const VariantBase& src) const;
+
+ /// See operator<().
+ bool operator>(const VariantBase& src) const;
+
+ /// See operator<().
+ bool operator>=(const VariantBase& src) const;
+
+ /// See operator<().
+ bool operator==(const VariantBase& src) const;
+
+ /// See operator<().
+ bool operator!=(const VariantBase& src) const;
};
template<class V_CastTo>
* @newin{2,28}
*/
static void create_signature(VariantStringBase& output,
- const std::string& object_path);
+ const std::string& signature);
_IGNORE(g_variant_new_signature)
_WRAP_METHOD(static bool is_signature(const std::string& string), g_variant_is_signature)
_WRAP_METHOD(VariantBase get() const, g_variant_get_variant)
};
+/** Specialization of Variant containing a Variant<T>.
+ * @newin{2,36}
+ * @ingroup Variant
+ */
+template<class T>
+class Variant< Variant<T> > : public VariantContainerBase
+{
+public:
+ typedef GVariant* CType;
+ typedef Variant<T> CppType;
+ typedef Variant<CppType> CppContainerType;
+
+ /// Default constructor.
+ Variant< Variant<T> >();
+
+ /** GVariant constructor.
+ * @param castitem The GVariant to wrap.
+ * @param take_a_reference Whether to take an extra reference of the
+ * GVariant or not (not taking one could destroy the GVariant with the
+ * wrapper).
+ * @newin{2,36}
+ */
+ explicit Variant< Variant<T> >(GVariant* castitem, bool take_a_reference = false);
+
+ /** Gets the VariantType.
+ * @return The VariantType.
+ * @newin{2,36}
+ */
+ static const VariantType& variant_type() G_GNUC_CONST;
+
+ /** Creates a new Variant< Variant<T> >.
+ * @param data The value of the new Variant.
+ * @return The new Variant.
+ * @newin{2,36}
+ */
+ static Variant< Variant<T> > create(const Variant<T>& data);
+
+ /** Gets the contents of the Variant.
+ * @return The contents of the Variant.
+ * @newin{2,36}
+ */
+ Variant<T> get() const;
+};
+
/** Specialization of Variant containing a Glib::ustring, for variants of type
* string, bytestring, object path, or signature.
* @newin{2,28}
* This function is O(1).
*
* @param index The index of the element.
- * @return The element at index @index.
+ * @return The element at index @a index.
* @throw std::out_of_range
* @newin{2,28}
*/
* This function is O(1).
*
* @param index The index of the element.
- * @return The element at index @index.
+ * @return The element at index @a index.
* @throw std::out_of_range
* @newin{2,28}
*/
static Variant< std::vector<std::string> >
create(const std::vector<std::string>& data);
+ /** Creates a new Variant from an array of D-Bus object paths.
+ * @param paths The array to use for creation.
+ * @return The new Variant.
+ * @newin{2,36}
+ */
+ static Variant< std::vector<std::string> >
+ create_from_object_paths(const std::vector<std::string>& paths);
+
/** Gets a specific element of the string array. It is an error if @a index
* is greater than the number of child items in the container. See
* VariantContainerBase::get_n_children().
* This function is O(1).
*
* @param index The index of the element.
- * @return The element at index @index.
+ * @return The element at index @a index.
* @throw std::out_of_range
* @newin{2,28}
*/
std::vector<std::string> get() const;
_IGNORE(g_variant_get_bytestring_array, g_variant_dup_bytestring_array)
+ // Object paths are merely strings so it is possible to get them already with
+ // the existing get() methods in this class.
+ _IGNORE(g_variant_get_objv, g_variant_dup_objv)
+
/** Gets a VariantIter of the Variant.
* @return the VaraintIter.
* @newin{2,28}
* This function is O(1).
*
* @param index The index of the element.
- * @return The dictionary entry at index @index.
+ * @return The dictionary entry at index @a index.
* @throw std::out_of_range
* @newin{2,28}
*/
namespace Glib
{
+/*--------------------Variant< Variant<T> >---------------------*/
+
+template<class T>
+Variant< Variant<T> >::Variant()
+: VariantContainerBase()
+{
+}
+
+template<class T>
+Variant< Variant<T> >::Variant(GVariant* castitem, bool take_a_reference)
+: VariantContainerBase(castitem, take_a_reference)
+{
+}
+
+// static
+template<class T>
+const VariantType& Variant< Variant<T> >::variant_type()
+{
+ return VARIANT_TYPE_VARIANT;
+}
+
+template<class T>
+Variant< Variant<T> > Variant< Variant<T> >::create(const Variant<T>& data)
+{
+ Variant< Variant<T> > result = Variant< Variant<T> >(
+ g_variant_new_variant(const_cast<GVariant*>(data.gobj())));
+ return result;
+}
+
+template<class T>
+Variant<T> Variant< Variant<T> >::get() const
+{
+ GVariant* const gvariant = g_variant_get_variant(gobject_);
+ return Variant<T>(gvariant, true);
+}
+
/*--------------------Variant< std::pair<K, V> >---------------------*/
// static
Variant< std::pair<K, V> > result = Variant< std::pair<K, V> >(
g_variant_new_dict_entry(key.gobj(), value.gobj()));
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
for(typename std::vector<T>::const_iterator iter = data.begin();
iter < data.end(); iter++)
{
- g_variant_builder_add(builder,
- reinterpret_cast<gchar*>(element_variant_type.gobj()), *iter);
+ Glib::Variant<T> variant = Glib::Variant<T>::create(*iter);
+ g_variant_builder_add_value(builder, variant.gobj());
}
// Create the variant using the builder.
Variant< std::vector<T> >(g_variant_new(
reinterpret_cast<gchar*>(array_variant_type.gobj()), builder));
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
template<class T>
T Variant< std::vector<T> >::get_child(gsize index) const
{
- gsize n_elements = 0;
+ if(index >= g_variant_n_children(const_cast<GVariant*>(gobj())))
+ throw std::out_of_range(
+ "Variant< std::vector<T> >::get_child(): Index out of bounds.");
- const T* array = reinterpret_cast<const T*>(
- g_variant_get_fixed_array(const_cast<GVariant*>(gobj()), &n_elements,
- sizeof(T)));
+ Glib::Variant<T> variant;
- if(index >= n_elements)
- throw std::out_of_range(
- "Variant< std::vector<T> >::get(): Index out of bounds.");
+ GVariant* gvariant =
+ g_variant_get_child_value(const_cast<GVariant*>(gobj()), index);
- return array[index];
+ variant.init(gvariant);
+ return variant.get();
}
template<class T>
std::vector<T> Variant< std::vector<T> >::get() const
{
- gsize n_elements = 0;
+ std::vector<T> result;
+
+ gsize n_children = g_variant_n_children(const_cast<GVariant*>(gobj()));
- const T* array = reinterpret_cast<const T*>(
- g_variant_get_fixed_array(const_cast<GVariant*>(gobj()), &n_elements,
- sizeof(T)));
+ for(gsize i = 0; i < n_children; i++)
+ {
+ Glib::Variant<T> variant;
+
+ GVariant* gvariant =
+ g_variant_get_child_value(const_cast<GVariant*>(gobj()), i);
+
+ variant.init(gvariant);
+ result.push_back(variant.get());
+ }
- std::vector<T> result(array, array + n_elements);
return result;
}
Variant< std::map<K, V> > result = Variant< std::map<K, V> >(g_variant_new(
reinterpret_cast<gchar*>(array_variant_type.gobj()), builder));
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
Variant<$1> Variant<$1>::create($1 data)
{
Variant<$1> result = Variant<$1>(g_variant_new_$3(data));
-
- // Remove the floating reference (since it is newly created).
- g_variant_ref_sink(result.gobj());
-
return result;
}
/** GVariant constructor.
* @param castitem The GVariant to wrap.
+ * @param take_a_reference Whether to take an extra reference of the
+ * GVariant or not (not taking one could destroy the GVariant with the
+ * wrapper).
*/
explicit Variant<$1>(GVariant* castitem, bool take_a_reference = false)
: VariantBase(castitem, take_a_reference)
bool next_value(VariantBase& value);
_IGNORE(g_variant_iter_next_value)
-
- // Ignore varargs function
- _IGNORE(g_variant_iter_next)
+
+ // Ignore varargs functions
+ _IGNORE(g_variant_iter_loop, g_variant_iter_next)
};
} // namespace Glib
{
g_variant_type_free (gobject_);
}
-
+
if(castitem)
gobject_ = g_variant_type_copy(castitem);
else
gobject_ = 0;
-
+
return *this;
}
+VariantType VariantType::create_tuple(const std::vector<VariantType>& items)
+{
+ typedef GVariantType* var_ptr;
+ var_ptr* const var_array = new var_ptr[items.size()];
+
+ for(std::vector<VariantType>::size_type i = 0; i < items.size(); i++)
+ {
+ var_array[i] = const_cast<GVariantType*>(items[i].gobj());
+ }
+
+ VariantType result = Glib::wrap(g_variant_type_new_tuple(var_array, items.size()));
+ delete[] var_array;
+ return result;
+}
+
const VariantType VARIANT_TYPE_BOOL(G_VARIANT_TYPE_BOOLEAN);
const VariantType VARIANT_TYPE_BYTE(G_VARIANT_TYPE_BYTE);
#include <glibmmconfig.h>
#include <glib-object.h> //For gsize
#include <string>
+#include <vector>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GVariantType GVariantType;
_WRAP_METHOD(static VariantType create_array(const VariantType& element), g_variant_type_new_array)
_WRAP_METHOD(static VariantType create_maybe(const VariantType& element), g_variant_type_new_maybe)
- //TODO: Use a single list parameter:
- //_WRAP_METHOD(static VariantType create_tuple(const GVariantType * const *items, gint length), g_variant_type_new_tuple)
+ /** Constructs a new tuple type, from @a items.
+ *
+ * @param items A vector of VariantTypes, one for each item.
+ * @return A new tuple VariantType.
+ *
+ * @newin{2,36}
+ */
+ static VariantType create_tuple(const std::vector<VariantType>& items);
+ _IGNORE(g_variant_type_new_tuple)
_WRAP_METHOD(static VariantType create_dict_entry(const VariantType& key, const VariantType& value), g_variant_type_new_dict_entry)
#m4 _CONVERSION(`const VariantType&',`gconstpointer',`const_cast<GVariantType*>(($3).gobj())')
_WRAP_METHOD(guint hash() const, g_variant_type_hash)
+
+ /** Compares @a *this and @a other for equality.
+ *
+ * Only returns <tt>true</tt> if the types are exactly equal. Even if one type
+ * is an indefinite type and the other is a subtype of it, <tt>false</tt> will
+ * be returned if they are not exactly equal. If you want to check for
+ * subtypes, use is_subtype_of().
+ *
+ * @param other The VariantType to compare with.
+ * @return <tt>true</tt> if @a *this and @a other are exactly equal.
+ *
+ * @newin{2,24}
+ */
_WRAP_METHOD(bool equal(const VariantType& other) const, g_variant_type_equal)
_WRAP_METHOD(bool is_subtype_of(const VariantType& supertype) const, g_variant_type_is_subtype_of)
+// It's necessary to take an extra reference of the 'const GVariantType*'
+// returned by g_variant_type_element() because it doesn't do that already.
+#m4 _CONVERSION(`const GVariantType*',`VariantType',`Glib::wrap(const_cast<GVariantType*>($3), true)')
_WRAP_METHOD(VariantType element() const, g_variant_type_element)
_WRAP_METHOD(VariantType first() const, g_variant_type_first)
_WRAP_METHOD(VariantType next () const, g_variant_type_next)
vec_strings.push_back("a");
Glib::Variant<std::vector<std::string> > variant_vec_strings =
Glib::Variant<std::vector<std::string> >::create(vec_strings);
-
+
//Dict:
typedef std::pair<Glib::ustring, Glib::ustring> TypeDictEntry;
" in the variant are: " << value << '.' << std::endl;
}
+ //std::vector< std::map< Glib::ustring, Glib::Variant<int> > >
+ typedef std::map< Glib::ustring, Glib::Variant<int> > ComplexDictType;
+
+ ComplexDictType complex_dict1;
+ ComplexDictType complex_dict2;
+
+ for(int i = 0; i < 10; i++)
+ {
+ // Convert integer i to string.
+ std::stringstream ss;
+ ss << i;
+
+ Glib::ustring s = "String " + ss.str();
+
+ Glib::Variant<int> v = Glib::Variant<int>::create(i);
+
+ complex_dict1.insert(
+ std::pair< Glib::ustring, Glib::Variant<int> >("Map 1 " + s, v));
+
+ complex_dict2.insert(
+ std::pair< Glib::ustring, Glib::Variant<int> >("Map 2 " + s, v));
+ }
+
+ typedef std::vector< std::map< Glib::ustring, Glib::Variant<int> > >
+ ComplexVecType;
+
+ ComplexVecType complex_vector;
+ complex_vector.push_back(complex_dict1);
+ complex_vector.push_back(complex_dict2);
+
+ Glib::Variant<ComplexVecType> complex_variant =
+ Glib::Variant<ComplexVecType>::create(complex_vector);
+
+ // This will output the type string aa{sv}.
+ ostr << "The type string of the variant containing a vector of "
+ "dictionaries is: " << std::endl << complex_variant.get_type_string() <<
+ "." << std::endl << std::endl;
+
+ ComplexVecType copy_complex_vector = complex_variant.get();
+
+ for(guint i = 0; i < copy_complex_vector.size(); i++)
+ {
+ ostr << "Printing dictionary # " << i + 1 << ":" << std::endl;
+
+ ComplexDictType map = copy_complex_vector[i];
+
+ for(ComplexDictType::const_iterator iter = map.begin();
+ iter != map.end(); iter++)
+ {
+ std::pair< Glib::ustring, Glib::Variant<int> > entry = *iter;
+ ostr << entry.first << " -> " << entry.second.get() << "." << std::endl;
+ }
+ ostr << std::endl;
+ }
+
test_variant_floating();
test_dynamic_cast();
class GtkDoc:
def __init__(self):
self.name = None
- self.block_type = '' # The block type ('function', 'signal', 'property')
+ # The block type ('function', 'signal', property', 'enum')
+ self.block_type = ''
self.params = []
self.annotations = []
self.description = ''
function_name_pattern = re.compile(r'^([a-z]\w*)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
signal_name_pattern = re.compile(r'^([A-Z]\w+::[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
property_name_pattern = re.compile(r'^([A-Z]\w+:[a-z0-9-]+)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
+enum_name_pattern = re.compile(r'^([A-Z]\w+)\s*:?(\s*\(.*\)\s*){0,2}\s*$')
return_pattern = re.compile(r'^@?(returns:|return\s+value:)(.*\n?)$', re.IGNORECASE)
deprecated_pattern = re.compile(r'^(deprecated\s*:\s*.*\n?)$', re.IGNORECASE)
rename_to_pattern = re.compile(r'^(rename\s+to)\s*:\s*(.*\n?)$', re.IGNORECASE)
# are grouped in a list for easy determination of block identifiers (in
# skip_to_identifier). The function_name_pattern should be tested for last
# because it always matches signal and property identifiers.
-identifier_patterns = [ signal_name_pattern, property_name_pattern, function_name_pattern ]
+identifier_patterns = [ signal_name_pattern, property_name_pattern, enum_name_pattern, function_name_pattern ]
# This pattern is to match return sections that forget to have a colon (':')
# after the initial 'Return' phrase. It is not included by default in the list
no_colon_return_pattern = re.compile(r'^@?(returns|return\s+value)\s*(.*\n?)$', re.IGNORECASE)
since_pattern = re.compile(r'^(since\s*:\s*.*\n?)$', re.IGNORECASE)
+# This pattern is to match since sections that forget to have a colon (':')
+# after the initial 'Since' phrase. It is not included by default in the list
+# of final sections below because some function descriptions contain
+# 'Since ...' and the process_description() function would stop at that
+# line, thinking it is a since section.
+no_colon_since_pattern = re.compile(r'^Since\s+[.0-9]+\n?$')
+
# These patterns normally will be encountered after the description. Knowing
# the order of their appearance is difficult so this list is used to test when
# one begins and the other ends when processing the rest of the sections after
line = process_params(fp, line, cur_doc)
line = process_description(fp, line, cur_doc)
line = process_final_sections(fp, line, cur_doc)
- # Add the current doc block to the dictionary of doc blocks.
- doc_dict[cur_doc.name] = cur_doc
+
+ # Add the current doc block to the dictionary of doc blocks. If
+ # this block was initially recognized as an 'enum' block in
+ # skip_to_identifier(), the process_params() function will mark the
+ # block as invalid if enum members are not all caps. In that case
+ # do not add the block.
+ if cur_doc.get_type() != 'invalid':
+ doc_dict[cur_doc.name] = cur_doc
# Given a list of annotations as string of the form
# '(annotation1) (annotation2) ...' return a list of annotations of the form
# Given the first line of a comment block (the '/**'), see if the next
# non-blank line is the identifier of the comment block. Stop processing if
# the end of the block or eof is reached. Store the identifier (if there is
-# one) and its type ('function', 'signal' or 'property') in the given GtkDoc.
-# Return the line where the identifier is found or the line that stops the
-# processing (if eof or the end of the comment block is found first).
+# one) and its type ('function', 'signal' or 'property', 'enum') in the given
+# GtkDoc. Return the line where the identifier is found or the line that stops
+# the processing (if eof or the end of the comment block is found first).
def skip_to_identifier(fp, line, cur_doc):
# Skip the initial comment block line ('/**') if not eof.
if line: line = fp.readline()
cur_doc.set_type('signal')
elif pattern == property_name_pattern:
cur_doc.set_type('property')
+ elif pattern == enum_name_pattern:
+ cur_doc.set_type('enum')
elif pattern == function_name_pattern:
cur_doc.set_type('function')
return line
if line: line = fp.readline()
line = skip_to_nonblank(fp, line)
if not line or comment_end_pattern.match(line):
+ # If there are no parameters and this block has been recognized as an
+ # enum block, then mark it as invalid.
+ if cur_doc.get_type() == 'enum':
+ cur_doc.set_type('invalid')
return line
# Remove initial ' * ' in first non-empty comment block line.
# param section is not reached (which could be triggered by anything that
# doesn't match a '@param:..." line, even the end of the comment block).
match = param_pattern.match(line)
+
+ # Mark the cur_doc type as invalid if no parameters are found.
+ if not match and cur_doc.get_type() == 'enum':
+ cur_doc.set_type('invalid')
+
while line and match:
+ name = match.group(1)
description = match.group(2)
+ # Set the cur_doc type as 'invalid' if the enum member names are not
+ # all caps.
+ if not name.isupper() and cur_doc.get_type() == 'enum':
+ cur_doc.set_type('invalid')
+
# First extract the annotations from the description and save them.
annotations = []
annotation_match = annotations_pattern.match(description)
# See if the return has been included as part of the parameter
# section and make sure that lines are added to the GtkDoc return if
# so.
- if match.group(1).lower() == "returns":
+ if name.lower() == "returns":
cur_doc.add_return(description, annotations)
append_func = cur_doc.append_to_return
# If not, just add it as a regular parameter.
else:
- cur_doc.add_param(match.group(1), description, annotations)
+ cur_doc.add_param(name, description, annotations)
# Now read lines and append them until next parameter, beginning of
# description (an empty line), the end of the comment block or eof.
return line
# If not, append lines to description in the doc comment block.
- cur_doc.append_to_description(line)
+ # But if --no-since is specified, skip a no_colon_since_pattern line.
+ if no_since and \
+ no_colon_since_pattern.match(line) and prev_line == '\n':
+ pass
+ else:
+ cur_doc.append_to_description(line)
prev_line = line
line = fp.readline()
# sections) process the final sections ('Returns:', 'Since:', etc.) until the
# end of the comment block or eof. Return the line that ends the processing.
def process_final_sections(fp, line, cur_doc):
+ # Temporarily append the no_colon_since_pattern to the final section
+ # patterns now that the description has been processed. It will be
+ # removed at the end of this function so that future descriptions
+ # that begin with 'Since ...' are not interpreted as a since section.
+ final_section_patterns.append(no_colon_since_pattern)
+
while line and not comment_end_pattern.match(line):
# Remove leading ' * ' from current non-empty comment line.
line = comment_line_lead_pattern.sub('', line)
cur_doc.add_annotation((match.group(1),
match.group(2)))
else:
- # For all others ('Since:' and 'Deprecated:') just append
- # the line to the description for now.
- # But if --no-since is specified, don't append it.
- if no_since and pattern == since_pattern:
+ # For all others ('Since:', 'Since ' and 'Deprecated:')
+ # just append the line to the description for now.
+ # But if --no-since is specified, skip a Since line.
+ if no_since and (pattern == since_pattern or \
+ pattern == no_colon_since_pattern):
pass
else:
cur_doc.append_to_description(line)
# Get the next line to continue processing.
line = fp.readline()
+ # Remove the no_colon_since_pattern (which was temporarily added at
+ # the beginning of this function) from the list of final section patterns.
+ final_section_patterns.pop()
+
return line
def parse_dir(dir, doc_dict):
path = os.path.join(dir, file)
if os.path.isdir(path):
parse_dir(path, doc_dict)
- if len(file) > 2 and file[-2:] == '.c':
+ if len(file) > 2 and (file[-2:] == '.c' or file[-2:] == '.h'):
sys.stderr.write("Processing " + path + '\n')
parse_file(open(path, 'r'), doc_dict)
sys.stderr.write('usage: docextract_to_xml.py ' +
'[-s /src/dir | --source-dir=/src/dir] ' +
'[-a | --with-annotations] [-p | --with-properties] ' +
- '[-i | --no-signals ] [-n | --no-since]\n')
+ '[-n | --no-since] [-i | --no-signals ] [-e | --no-enums ]\n')
sys.exit(1)
# Translates special texts to &... HTML acceptable format. Also replace
escaped_text = string.replace(escaped_text, '*', '*')
escaped_text = string.replace(escaped_text, '%', '%')
escaped_text = string.replace(escaped_text, '@', '@')
+ escaped_text = string.replace(escaped_text, ':', ':')
escaped_text = string.replace(escaped_text, '#', '#')
escaped_text = string.replace(escaped_text, ' ', ' ')
escaped_text = string.replace(escaped_text, '&solidus;', '/')
if __name__ == '__main__':
try:
- opts, args = getopt.getopt(sys.argv[1:], "d:s:o:apin",
+ opts, args = getopt.getopt(sys.argv[1:], "d:s:o:apnie",
["source-dir=", "with-annotations",
- "with-properties", "no-signals",
- "no-since"])
+ "with-properties", "no-since",
+ "no-signals", "no-enums"])
except getopt.error, e:
sys.stderr.write('docextract_to_xml.py: %s\n' % e)
usage()
with_annotations = False
with_signals = True
with_properties = False
+ with_enums = True
for opt, arg in opts:
if opt in ('-s', '--source-dir'):
source_dirs.append(arg)
with_annotations = True
if opt in ('-p', '--with-properties'):
with_properties = True
- if opt in ('-i', '--no-signals'):
- with_signals = False
if opt in ('-n', '--no-since'):
docextract.no_since = True
+ if opt in ('-i', '--no-signals'):
+ with_signals = False
+ if opt in ('-e', '--no-enums'):
+ with_enums = False
if len(args) != 0:
usage()
# Likewise for properties.
elif block_type == 'property' and not with_properties:
continue
+ # Likewise for enums.
+ elif block_type == 'enum' and not with_enums:
+ continue
print "<" + block_type + " name=\"" + escape_text(name) + "\">"
print "</parameters>"
- # Show the return-type (also if not dealing with a property):
- if with_annotations:
- print "<return>"
- print "<return_description>" + escape_text(value.ret[0]) + \
- "</return_description>"
- print_annotations(value.ret[1])
- print "</return>"
- else:
- print "<return>" + escape_text(value.ret[0]) + "</return>"
+ if block_type != 'property' and block_type != 'enum':
+ # Show the return-type (also if not dealing with a property or
+ # enum):
+ if with_annotations:
+ print "<return>"
+ print "<return_description>" + escape_text(value.ret[0]) + \
+ "</return_description>"
+ print_annotations(value.ret[1])
+ print "</return>"
+ else:
+ print "<return>" + escape_text(value.ret[0]) + "</return>"
if with_annotations:
print_annotations(value.get_annotations())
int main(int, char**)
{
- g_type_init ();
+ // g_type_init() is deprecated as of 2.36.
+ // g_type_init();
std::cout << get_defs(G_TYPE_ASYNC_RESULT)
<< get_defs(G_TYPE_ACTION)
<< get_defs(G_TYPE_SOCKET_CLIENT)
<< get_defs(G_TYPE_SOCKET_CONNECTION)
<< get_defs(G_TYPE_TCP_CONNECTION)
+ << get_defs(G_TYPE_TLS_BACKEND)
+ << get_defs(G_TYPE_TLS_CERTIFICATE)
+ << get_defs(G_TYPE_TLS_CLIENT_CONNECTION)
+ << get_defs(G_TYPE_TLS_CONNECTION)
+ << get_defs(G_TYPE_TLS_DATABASE)
+ << get_defs(G_TYPE_TLS_FILE_DATABASE)
+ << get_defs(G_TYPE_TLS_INTERACTION)
+ << get_defs(G_TYPE_TLS_PASSWORD)
+ << get_defs(G_TYPE_TLS_SERVER_CONNECTION)
#ifndef G_OS_WIN32
<< get_defs(G_TYPE_UNIX_CONNECTION)
#endif
int main()
{
- g_type_init();
+ // g_type_init() is deprecated as of 2.36.
+ // g_type_init();
std::cout << get_defs( G_TYPE_DATE )
<< get_defs( G_TYPE_IO_CHANNEL )
_CONV_ENUM(G,MountUnmountFlags)
_CONV_ENUM(G,OutputStreamSpliceFlags)
_CONV_ENUM(G,PasswordSave)
+_CONV_ENUM(G,ResolverRecordType)
_CONV_ENUM(G,SettingsBindFlags)
_CONV_ENUM(G,SocketFamily)
_CONV_ENUM(G,SocketMsgFlags)
_CONV_ENUM(G,SocketProtocol)
_CONV_ENUM(G,SocketType)
+_CONV_ENUM(G,TlsCertificateFlags)
+_CONV_ENUM(G,TlsDatabaseVerifyFlags)
+_CONV_ENUM(G,TlsDatabaseLookupFlags)
+_CONV_ENUM(G,TlsInteractionResult)
+_CONV_ENUM(G,TlsPasswordFlags)
+_CONV_ENUM(G,TlsRehandshakeMode)
_CONV_ENUM(G,UnixSocketAddressType)
_CONV_ENUM(G,ZlibCompressorFormat)
#SocketConnectable
_CONVERSION(`const Glib::RefPtr<SocketConnectable>&',`GSocketConnectable*',__CONVERT_CONST_REFPTR_TO_P)
+_CONVERSION(`const Glib::RefPtr<const SocketConnectable>&', `GSocketConnectable*', `const_cast<GSocketConnectable*>(Glib::unwrap($3))')
+_CONVERSION(`GSocketConnectable*',`Glib::RefPtr<SocketConnectable>',`Glib::wrap($3)')
#SocketConnection
_CONVERSION(`GSocketConnection*',`Glib::RefPtr<SocketConnection>',`Glib::wrap($3)')
#TimeZoneMonitor
_CONVERSION(`GTimeZoneMonitor*',`Glib::RefPtr<TimeZoneMonitor>',`Glib::wrap($3)')
+#TlsCertificate
+_CONVERSION(`GTlsCertificate*', `Glib::RefPtr<TlsCertificate>', `Glib::wrap($3)')
+_CONVERSION(`const Glib::RefPtr<const TlsCertificate>&', `GTlsCertificate*', `const_cast<GTlsCertificate*>(Glib::unwrap($3))')
+_CONVERSION(`const Glib::RefPtr<TlsCertificate>&',`GTlsCertificate*',`Glib::unwrap($3)')
+
+#TlsDatabase
+_CONVERSION(`GTlsDatabase*',`Glib::RefPtr<TlsDatabase>',`Glib::wrap($3)')
+_CONVERSION(`const Glib::RefPtr<TlsDatabase>&',`GTlsDatabase*',`Glib::unwrap($3)')
+
+#TlsInteraction
+_CONVERSION(`const Glib::RefPtr<TlsInteraction>&',`GTlsInteraction*',`Glib::unwrap($3)')
+_CONVERSION(`GTlsInteraction*',`Glib::RefPtr<TlsInteraction>',`Glib::wrap($3)')
+
+#TlsPassword
+_CONVERSION(`const Glib::RefPtr<TlsPassword>&',`GTlsPassword*',`Glib::unwrap($3)')
+
#UnixFDList
_CONVERSION(`GUnixFDList*',`Glib::RefPtr<UnixFDList>',`Glib::wrap($3)')
_CONVERSION(`const Glib::RefPtr<UnixFDList>&',`GUnixFDList*',`Glib::unwrap($3)')
dnl VariantType
_CONVERSION(`const VariantType&',`const GVariantType*',`($3).gobj()')
_CONVERSION(`const Glib::VariantType&',`const GVariantType*',`($3).gobj()')
-_CONVERSION(`const GVariantType*',`VariantType',`Glib::wrap(const_cast<GVariantType*>($3), true)')
-_CONVERSION(`GVariantType*',`VariantType',`Glib::wrap(($3), true)')
+_CONVERSION(`GVariantType*',`VariantType',`Glib::wrap($3)')
dnl Miscellaneous
_CONVERSION(`gint64&',`gint64*',`&($3)')
-
dnl
dnl _ENUM(cpp_type, c_type, value_suffix, `element_list', `flags', `optional_refdoc_comment', 'get_type_function_name')
dnl
')dnl endif
dnl
dnl
-/**$6
+/** $6
* @ingroup __MODULE_CANONICAL__`'Enums
m4_ifelse($3,Flags,`dnl
* @par Bitwise operators:
_POP()
')dnl endif !NO_GTYPE
')dnl enddef _ENUM
-
dnl
dnl method
-dnl $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18
-dnl _METHOD(cppname,cname,cpprettype,crettype,arglist,cdeclarations,cargs,cinitializations,const,refreturn,errthrow,deprecated,constversion,ifdef,arglist_without_types,out_param,out_param_cpptype,wrap_line)
+dnl $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $20 $21
+dnl _METHOD(cppname,cname,cpprettype,crettype,arglist,cdeclarations,cargs,cinitializations,const,refreturn,errthrow,deprecated,constversion,ifdef,arglist_without_types,out_param,out_param_cpptype,slot_type,slot_name,no_slot_copy,wrap_line)
define(`_METHOD',`dnl
_PUSH(SECTION_CC)
ifelse(`$12',,,`_DEPRECATE_IFDEF_START
{
ifelse(`$13',,dnl
`ifelse(`$10'`$11',,dnl If it is not errthrow or refreturn
+dnl If a slot type has been specified insert a slot copy declaration.
+`ifelse(`$18',,,dnl
+dnl See if the slot should or should not be copied
+`ifelse(`$20',,dnl
+` // Create a copy of the slot.
+ $18* slot_copy = new $18($19); ',dnl
+dnl
+` // Use the original slot (not a copy).
+ $18* slot_copy = const_cast<$18*>(&$19);')
+
+')`'dnl
dnl Insert the declarations for C output parameters
-`ifelse(`$6',,,`$6
+ifelse(`$6',,,`$6
')`'dnl
ifelse(`$16',,dnl If no C++ output parameter is specified
`ifelse(`$3',void,dnl If the C function returns voids:
')dnl
')'dnl End if it returns voids.
dnl A C++ output parameter is specified:
-,` _INITIALIZE($17,$4,`$16',`$2`'(ifelse(`$9',1,const_cast<__CNAME__*>(gobj()),gobj())`'ifelse(`$7',,,`, ')$7)',$18);
+,` _INITIALIZE($17,$4,`$16',`$2`'(ifelse(`$9',1,const_cast<__CNAME__*>(gobj()),gobj())`'ifelse(`$7',,,`, ')$7)',$21);
dnl
dnl Insert the initializations for the C output parameters
ifelse(`$8',,,`$8
dnl If is errthrow or refreturn
`ifelse(`$11',,,` GError* gerror = 0;
')dnl
+dnl If a slot type has been specified insert a slot copy declaration.
+ifelse(`$18',,,dnl
+dnl See if the slot should or should not be copied
+`ifelse(`$20',,dnl
+` // Create a copy of the slot.
+ $18* slot_copy = new $18($19); ',dnl
+dnl
+` // Use the original slot (not a copy).
+ $18* slot_copy = const_cast<$18*>(&$19);')
+
+')`'dnl
dnl Insert the declarations for C output parameters
ifelse(`$6',,,`$6
')`'dnl
` ifelse(`$3',void,,``$3' retvalue = ')_CONVERT($4,`$3',`$2`'(ifelse(`$9',1,const_cast<__CNAME__*>(gobj()),gobj())`'ifelse(`$7',,,`, ')$7)');
'dnl
,dnl A C++ output parameter is specified:
-` _INITIALIZE($17,$4,`$16',`$2`'(ifelse(`$9',1,const_cast<__CNAME__*>(gobj()),gobj())`'ifelse(`$7',,,`, ')$7)',$18);
+` _INITIALIZE($17,$4,`$16',`$2`'(ifelse(`$9',1,const_cast<__CNAME__*>(gobj()),gobj())`'ifelse(`$7',,,`, ')$7)',$21);
'dnl
)dnl
ifelse(`$11',,,`dnl
dnl
dnl static method
-dnl $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15
-dnl _STATIC_METHOD(cppname,cname,cpprettype,crettype,arglist,cdeclarations,cargs,cinitializations,refreturn,errthrow,deprecated,ifdef,out_param,out_param_type,wrap_line)
+dnl $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18
+dnl _STATIC_METHOD(cppname,cname,cpprettype,crettype,arglist,cdeclarations,cargs,cinitializations,refreturn,errthrow,deprecated,ifdef,out_param,out_param_type,slot_type,slot_name,no_slot_copy,wrap_line)
define(`_STATIC_METHOD',`dnl
_PUSH(SECTION_CC)
ifelse(`$11',,,`_DEPRECATE_IFDEF_START
$3 __CPPNAME__::$1($5)
{
ifelse(`$9'`$10',,dnl
+dnl If a slot type has been specified insert a slot copy declaration.
+ifelse(`$15',,,dnl
+dnl See if the slot should or should not be copied
+`ifelse(`$17',,dnl
+` // Create a copy of the slot.
+ $15* slot_copy = new $15($16); ',dnl
+dnl
+` // Use the original slot (not a copy).
+ $15* slot_copy = const_cast<$15*>(&$16);')
+
+')`'dnl
dnl Insert declarations for C the output parameters
ifelse(`$6',,,`$6
')`'dnl
dnl Store the return if there are C output parameters
ifelse(`$6',,`return ',``$3' retval = '))_CONVERT($4,`$3',`$2`'($7)');'dnl
dnl A C++ output parameter is specified so initialize it from C return
-,` _INITIALIZE($14,$4,`$13',`$2`'($7)',$15);'dnl
+,` _INITIALIZE($14,$4,`$13',`$2`'($7)',$18);'dnl
)
dnl Insert the initializations for the C output parameters if there are any
ifelse(`$8',,,`$8
')')dnl
',dnl End if a C++ output parameter is specified.
`ifelse(`$10',,,` GError* gerror = 0;')
+dnl If a slot type has been specified insert a slot copy declaration.
+ifelse(`$15',,,dnl
+dnl See if the slot should or should not be copied
+`ifelse(`$17',,dnl
+` // Create a copy of the slot.
+ $15* slot_copy = new $15($16); ',dnl
+dnl
+` // Use the original slot (not a copy).
+ $15* slot_copy = const_cast<$15*>(&$16);')
+
+')`'dnl
dnl Insert the declarations for the C output parameters
ifelse(`$6',,,`$6
')`'dnl
ifelse(`$13',,dnl If no C++ output parameter is specified:
ifelse(`$3',void,,``$3' retvalue = ')_CONVERT($4,`$3',`$2`'($7)');dnl
dnl A C++ output parameter is specified:
-,` _INITIALIZE($14,$4,`$13',`$2`'($7)',$15);'dnl
+,` _INITIALIZE($14,$4,`$13',`$2`'($7)',$18);'dnl
)dnl
ifelse(`$10',,,`
if(gerror)
dnl $1 $2 $3 $4 $5 $6
dnl _PROPERTY_PROXY(name, name_underscored, cpp_type, proxy_suffix, deprecated, docs)
-dnl proxy_suffix could be "_WriteOnly" or "_ReadOnly"
+dnl proxy_suffix could be "", "_WriteOnly" or "_ReadOnly"
dnl The method will be const if the propertyproxy is _ReadOnly.
dnl
define(`_PROPERTY_PROXY',`dnl
/** $6
*
* You rarely need to use properties because there are get_ and set_ methods for almost all of them.
- * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
- * the value of the property changes.
+ * @return A PropertyProxy$4 that allows you to dnl
+ifelse($4,_ReadOnly,get,`ifelse($4,_WriteOnly,set,get or set)') the value of the property,
+ * or receive notification when the value of the property changes.
*/
__PROXY_TYPE__ property_$2`'() ifelse($4,_ReadOnly, const,);
#endif //#GLIBMM_PROPERTIES_ENABLED
dnl $11 = ifdef)
define(`_SIGNAL_PROXY',`
-$10
ifelse(`$11',,,`#ifdef $11'
)dnl
ifelse(`$9',,,`_DEPRECATE_IFDEF_START
')dnl
+$10
Glib::SignalProxy`'_NUM($6)< $5`'_COMMA_PREFIX($6) > signal_$4`'();
ifelse(`$9',,,`_DEPRECATE_IFDEF_END
')dnl
dnl $1 $2 $3 $4
dnl _VFUNC_PCC(cppname,gtkname,cpprettype,crettype,
dnl $5 $6 $7 $8 $9 $10 $11
-dnl `<cargs and names>',`<cnames>',`<cpparg names>',firstarg, refreturn_ctype, ifdef, errthrow)
+dnl `<cargs and names>',`<cnames>',`<cpparg names>',firstarg, refreturn_ctype, ifdef, errthrow,
+dnl $12 $13
+dnl slot_type, c_data_param_name)
dnl
dnl Note: _get_current_wrapper_inline() could be used throughout for performance instead of _get_current_wrapper(),
dnl and is_derived_() instead of is_derived_(),
)dnl
$4 __CPPNAME__`'_Class::$2_vfunc_callback`'($5)
{
+ifelse(`$13',,,dnl
+` const $12* slot = static_cast<$12*>($13);
+
+')dnl
dnl First, do a simple cast to ObjectBase. We will have to do a dynamic_cast
dnl eventually, but it is not necessary to check whether we need to call
dnl the vfunc.
// Call the original underlying C function:
if(base && base->$2)
{
- ifelse($4,void,,`$4 result = ')(*base->$2)`'($6);
+ ifelse($4,void,,`$4 retval = ')(*base->$2)`'($6);
ifelse($11,errthrow,`dnl
if(*error)
::Glib::Error::throw_exception(*error);
')dnl
-ifelse($4,void,,` return result;
+ifelse($4,void,,` return retval;
')dnl
}
')dnl
_POP()')
-# $1 $2 $3 $4 $5 $6 $7 $8 $9 $10
-# _VFUNC_CC(vfunc_name, gtkname, cpp_rettype, c_rettype, `<cppargs>', `<carg_names>', is_const, refreturn, $ifdef, $errthrow)
+# $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13
+# _VFUNC_CC(vfunc_name, gtkname, cpp_rettype, c_rettype, `<cppargs>', `<carg_names>', is_const, refreturn, $ifdef, $errthrow, $slot_type, $slot_name, $no_slot_copy)
#
define(`_VFUNC_CC',`dnl
_PUSH(SECTION_CC_VFUNCS)
)dnl
$3 __NAMESPACE__::__CPPNAME__::$1`'($5) ifelse($7,1,const,)
{
+dnl If a slot type has been specified, insert code to create a copy of it.
+ifelse(`$11',,,dnl
+dnl See if the slot should or should not be copied
+`ifelse(`$13',,dnl
+` // Create a copy of the slot.
+ $11* slot_copy = new $11($12); ',dnl
+dnl
+` // Use the original slot (not a copy).
+ $11* slot_copy = const_cast<$11*>(&$12);')
+
+')dnl
BaseClassType *const base = static_cast<BaseClassType*>(
ifdef(`__BOOL_IS_INTERFACE__',`dnl
_IFACE_PARENT_FROM_OBJECT(gobject_)dnl
}
',`dnl
ifelse($8,refreturn,`dnl Assume Glib::wrap() is correct if refreturn is requested.
- $3 result(Glib::wrap((*base->$2)`'(ifelse(`$7',1,const_cast<__CNAME__*>(gobj()),gobj())`'_COMMA_PREFIX($6)), true));
+ $3 retval(Glib::wrap((*base->$2)`'(ifelse(`$7',1,const_cast<__CNAME__*>(gobj()),gobj())`'_COMMA_PREFIX($6)), true));
',`dnl
- $3 result(_CONVERT($4,$3,`(*base->$2)`'(ifelse(`$7',1,const_cast<__CNAME__*>(gobj()),gobj())`'_COMMA_PREFIX($6))'));
+ $3 retval(_CONVERT($4,$3,`(*base->$2)`'(ifelse(`$7',1,const_cast<__CNAME__*>(gobj()),gobj())`'_COMMA_PREFIX($6))'));
')dnl
ifelse($10,errthrow,`dnl
if(gerror)
::Glib::Error::throw_exception(gerror);
')dnl
- return result;
+ return retval;
}
typedef $3 RType;
$tag = lc($tag);
- if($tag eq "function" or $tag eq "signal")
+ if($tag eq "function" or $tag eq "signal" or $tag eq "enum")
{
if(defined $DocsParser::objCurrentFunction)
{
- $objParser->xpcroak("\nClose a function tag before you open another one.");
+ $objParser->xpcroak(
+ "\nClose a function, signal or enum tag before you open another one.");
}
my $functionName = $attr{name};
$tag = lc($tag);
- if($tag eq "function" or $tag eq "signal")
+ if($tag eq "function" or $tag eq "signal" or $tag eq "enum")
{
# Store the Function structure in the array:
my $functionName = $$DocsParser::objCurrentFunction{name};
}
-# $strCommentBlock lookup_documentation($strFunctionName, $deprecation_docs)
-sub lookup_documentation($$)
+# $text lookup_enum_description($enum_name)
+# Looks up the description of enum and returns it after converting it from
+# C to C++ format.
+sub lookup_enum_description($)
{
- my ($functionName, $deprecation_docs) = @_;
+ my ($enum_name) = @_;
+
+ my $objFunction = $DocsParser::hasharrayFunctions{$enum_name};
+ if(!$objFunction)
+ {
+ #print "DocsParser.pm: Warning: enum not found: $enum_name\n";
+ return ""
+ }
+
+ my $text = $$objFunction{description};
+
+ if(length($text) eq 0)
+ {
+ print "DocsParser.pm: Warning: No C docs for: \"$enum_name\"\n";
+ return "";
+ }
+
+ DocsParser::convert_docs_to_cpp($objFunction, \$text);
+ DocsParser::add_m4_quotes(\$text);
+
+ # Escape the space after "i.e." or "e.g." in the brief description.
+ $text =~ s/^([^.]*\b(?:i\.e\.|e\.g\.))\s/$1\\ /;
+
+ remove_example_code($enum_name, \$text);
+
+ return $text;
+}
+
+# $strCommentBlock lookup_enum_value_documentation($enum_name, $c_val_name)
+# Returns a Doxygen comment block for the enum value.
+sub lookup_enum_value_documentation($$)
+{
+ my ($enum_name, $c_val_name) = @_;
+
+ # Assume that there is no description.
+ my $desc = "";
+
+ my $obj_function = $DocsParser::hasharrayFunctions{$enum_name};
+
+ if($obj_function)
+ {
+ my $param_descriptions = \$$obj_function{param_descriptions};
+ $desc = $$param_descriptions->{$c_val_name};
+ }
+
+ if(!$desc or length($desc) eq 0)
+ {
+ return "";
+ }
+
+ DocsParser::convert_docs_to_cpp($obj_function, \$desc);
+ DocsParser::add_m4_quotes(\$desc);
+
+ # Escape the space after "i.e." or "e.g." in the brief description.
+ $desc =~ s/^([^.]*\b(?:i\.e\.|e\.g\.))\s/$1\\ /;
+
+ remove_example_code($enum_name, \$desc);
+
+ # Convert to Doxygen-style comment.
+ $desc =~ s/\n/\n${DocsParser::commentMiddleStart}/g;
+ $desc = $DocsParser::commentStart . $desc;
+ $desc .= "\n${DocsParser::commentEnd}\n";
+
+ return $desc;
+}
+
+# $strCommentBlock lookup_documentation($strFunctionName, $deprecation_docs, $objCppfunc)
+# The final objCppfunc parameter is optional. If passed, it is used to
+# decide if the final C parameter should be omitted if the C++ method
+# has a slot parameter.
+sub lookup_documentation($$;$)
+{
+ my ($functionName, $deprecation_docs, $objCppfunc) = @_;
my $objFunction = $DocsParser::hasharrayFunctions{$functionName};
if(!$objFunction)
$text .= "\n\@deprecated $deprecation_docs";
}
- DocsParser::append_parameter_docs($objFunction, \$text);
+ DocsParser::append_parameter_docs($objFunction, \$text, $objCppfunc);
DocsParser::append_return_docs($objFunction, \$text);
DocsParser::add_m4_quotes(\$text);
# Escape the space after "i.e." or "e.g." in the brief description.
$text =~ s/^([^.]*\b(?:i\.e\.|e\.g\.))\s/$1\\ /;
- # Remove C example code.
- my $example_removals =
- ($text =~ s"<informalexample>.*?</informalexample>"[C example ellipted]"sg);
- $example_removals +=
- ($text =~ s"<programlisting>.*?</programlisting>"\n[C example ellipted]"sg);
- $example_removals += ($text =~ s"\|\[.*?]\|"\n[C example ellipted]"sg);
-
- print STDERR "gmmproc: $functionName(): Example code discarded.\n"
- if ($example_removals);
+ remove_example_code($functionName, \$text);
# Convert to Doxygen-style comment.
$text =~ s/\n/\n${DocsParser::commentMiddleStart}/g;
return $text;
}
+# void remove_example_code($obj_name, \$text)
+# Removes example code from the text of docs (passed by reference).
+sub remove_example_code($$)
+{
+ my ($obj_name, $text) = @_;
+
+ # Remove C example code.
+ my $example_removals =
+ ($$text =~ s"<informalexample>.*?</informalexample>"[C example ellipted]"sg);
+ $example_removals +=
+ ($$text =~ s"<programlisting>.*?</programlisting>"\n[C example ellipted]"sg);
+ $example_removals += ($$text =~ s"\|\[.*?]\|"\n[C example ellipted]"sg);
+
+ print STDERR "gmmproc: $obj_name: Example code discarded.\n"
+ if ($example_removals);
+}
+
sub add_m4_quotes($)
{
my ($text) = @_;
$$text = "`" . $$text . "'";
}
-sub append_parameter_docs($$)
+# The final objCppfunc is optional. If passed, it is used to determine
+# if the final C parameter should be omitted if the C++ method has a
+# slot parameter.
+sub append_parameter_docs($$;$)
{
- my ($obj_function, $text) = @_;
+ my ($obj_function, $text, $objCppfunc) = @_;
my @param_names = @{$$obj_function{param_names}};
my $param_descriptions = \$$obj_function{param_descriptions};
# Also skip first param if this is a signal.
shift(@param_names) if ($$obj_function{name} =~ /\w+::/);
+ # Skip the last param if there is a slot because it would be a
+ # gpointer user_data parameter.
+ pop(@param_names) if (defined($objCppfunc) && $$objCppfunc{slot_name});
+
foreach my $param (@param_names)
{
if ($param ne "error" ) #We wrap GErrors as exceptions, so ignore these.
{
my $desc = $$param_descriptions->{$param};
+ # Deal with callback parameters converting the docs to a slot
+ # compatible format.
+ if ($param eq "callback")
+ {
+ $param = "slot";
+ $$text =~ s/\@a callback/\@a slot/g;
+ }
+
$param =~ s/([a-zA-Z0-9]*(_[a-zA-Z0-9]+)*)_?/$1/g;
DocsParser::convert_docs_to_cpp($obj_function, \$desc);
if(length($desc) > 0)
for($$text)
{
# Replace format tags.
- s"<(/?)emphasis>"<$1em>"g;
- s"<(/?)literal>"<$1tt>"g;
- s"<(/?)constant>"<$1tt>"g;
- s"<(/?)function>"<$1tt>"g;
+ s"<(/?)(?:emphasis|replaceable)>"<$1em>"g;
+ s"<(/?)(?:constant|envar|filename|function|guimenuitem|literal|option|structfield|varname)>"<$1tt>"g;
# Some argument names are suffixed by "_" -- strip this.
# gtk-doc uses @thearg, but doxygen uses @a thearg.
s" ?\@([a-zA-Z0-9]*(_[a-zA-Z0-9]+)*)_?\b" \@a $1"g;
- # Don't convert doxygen's @throws and @param, so these can be used in the
- # docs_override.xml:
- s" \@a (throws|param)" \@$1"g;
- s"^Note ?\d?: "\@note "mg;
+ # Don't convert Doxygen's $throw, @throws and @param, so these can be used
+ # in the docs_override.xml.
+ s" \@a (throws?|param)\b" \@$1"g;
+ s"^Note ?\d?: "\@note "mg;
s"</?programlisting>""g;
-
s"<!>""g;
# Remove all link tags.
s"</?u?link[^&]*?>""g;
- # Remove all para tags (from tmpl sgml files).
- s"</?para>""g;
+ # Remove all para tags and simpara tags (simple paragraph).
+ s"</?(sim)?para>""g;
- # Convert <itemizedlist> tags to Doxygen format.
- s"</?itemizedlist>\n?""g;
- s"<listitem>(.*?)(\n?)</listitem>(\n?)"- $1\n"sg;
+ # Convert <simplelist>, <itemizedlist> and <variablelist> to something that
+ # Doxygen understands.
+ s"<simplelist>\n?(.*?)</simplelist>\n?"&DocsParser::convert_simplelist($1)"esg;
+ s"<itemizedlist>\n?(.*?)</itemizedlist>\n?"&DocsParser::convert_itemizedlist($1)"esg;
+ s"<variablelist>\n?(.*?)</variablelist>\n?"&DocsParser::convert_variablelist($1)"esg;
- # Use our Doxygen @newin alias:
- s/\bSince:\s*(\d+)\.(\d+)\.(\d+)\b/\@newin{$1,$2,$3}/g;
- s/\bSince:\s*(\d+)\.(\d+)\b/\@newin{$1,$2}/g;
+ # Use our Doxygen @newin alias.
+ # If Since is not followed by a colon, substitute @newin only if it's
+ # in a sentence of its own at the end of the string.
+ s/\bSince:\s*(\d+)\.(\d+)\.(\d+)\b\.?/\@newin{$1,$2,$3}/g;
+ s/\bSince:\s*(\d+)\.(\d+)\b\.?/\@newin{$1,$2}/g;
+ s/(\.\s+)Since\s+(\d+)\.(\d+)\.(\d+)\.?$/$1\@newin{$2,$3,$4}/;
+ s/(\.\s+)Since\s+(\d+)\.(\d+)\.?$/$1\@newin{$2,$3}/;
s"\b->\b"->"g;
s"#?\bg(int|short|long)\b"<tt>$1</tt>"g;
s"#?\bgu(int|short|long)\b"<tt>unsigned $1</tt>"g;
- # For Gtk::TextIter.
- s"(\\[rn])\b"<tt>\\$1</tt>"g;
+ # Escape all backslashes, except in \throw, \throws and \param, which can
+ # be Doxygen commands in the docs_override.xml.
+ s"\\"\\\\"g;
+ s"\\\\(throws?|param)\b"\\$1"g
}
}
+# Convert <simplelist> tags to a list of newline-separated elements.
+sub convert_simplelist($)
+{
+ my ($text) = @_;
+
+ $text =~ s"<member>(.*?)(\n?)</member>(\n?)"$1<br>\n"sg;
+ return "<br>\n" . $text . "<br>\n";
+}
+
+# Convert <itemizedlist> tags to Doxygen format.
+sub convert_itemizedlist($)
+{
+ my ($text) = @_;
+
+ $text =~ s"<listitem>(.*?)(\n?)</listitem>(\n?)"- $1\n"sg;
+ return $text;
+}
+
+# Convert <variablelist> tags to an HTML definition list.
+sub convert_variablelist($)
+{
+ my ($text) = @_;
+
+ $text =~ s"</?varlistentry>\n?""g;
+ $text =~ s"<(/?)term>"<$1dt>"g;
+ $text =~ s"<(/?)listitem>"<$1dd>"g;
+ return "<dl>\n" . $text . "</dl>\n";
+}
sub substitute_identifiers($$)
{
s/\bNo::/NO_/g;
s/\bG:://g; #Rename G::Something to Something. Doesn't seem to work. murrayc.
+ # Substitute callback types to slot types.
+ s/(\b\w+)Callback/Slot$1/g;
+
# Replace C function names with C++ counterparts.
s/\b([a-z]+_[a-z][a-z\d_]+) ?\(\)/&DocsParser::substitute_function($doc_func, $1)/eg;
}
use strict;
use warnings;
+use DocsParser;
BEGIN {
use Exporter ();
#
# string array elem_names;
# string array elem_values;
+# string c_prefix;
#
# bool mark;
# }
$$self{mark} = 0;
$$self{flags} = 0;
+ $$self{c_prefix} = "";
$$self{elem_names} = [];
$$self{elem_values} = [];
{
# cut off the module prefix, e.g. GTK_
s/^$common_prefix// foreach (@$elem_names);
+
+ # Save the common prefix.
+ $$self{c_prefix} = $common_prefix;
}
$$self{elem_names} = $elem_names;
my $name = $$elem_names[$i];
my $value = $$elem_values[$i];
+ my $docs =
+ DocsParser::lookup_enum_value_documentation("$$self{c_type}",
+ "$$self{c_prefix}$name");
+
for(my $ii = 0; $ii < scalar(@subst_in); ++$ii)
{
$name =~ s/${subst_in[$ii]}/${subst_out[$ii]}/;
$value =~ s/${subst_in[$ii]}/${subst_out[$ii]}/;
}
+ # Skip this element, if its name has been deleted.
+ next if($name eq "");
+
+ if($docs ne "")
+ {
+ # Make sure the docs is indented the right number of spaces.
+ # (First remove initial spaces in first line and then the rest
+ # and then indent the lines).
+ $docs =~ s/^\s+//;
+ $docs =~ s/\n\s+/\n/g;
+ $docs =~ s/\n(\s*\*)/\n${indent} $1/g;
+ $docs = "${indent}${docs}";
+ }
+
+ $elements .= ",\n" if($elements ne "");
+ $elements .= $docs;
$elements .= "${indent}${name}";
$elements .= " = ${value}" if($value ne "");
- $elements .= ",\n" if($i < $num_elements - 1);
}
return $elements;
# Determine if the param is optional, an output param or if a C param
# name should be mapped to the current C++ index (if name ends with
# {c_name>>?}). (A '.' for the name means use the C++ as the C name).
- # '@' - Means that it is an output parameter.
+ # '>>' - Means that it is an output parameter.
# '?' - Means that it is an optional parameter.
- if ($name =~ /\{\s*(\w+|\.)?\s*(>>)?\s*(\??)\s*\}$/)
+ if ($name =~ /\{(.*)\}$/)
{
- $flags = FLAG_PARAM_OPTIONAL if($3);
- $flags |= FLAG_PARAM_OUTPUT if($2);
- $mapping = $1 if($1);
- $name =~ s/\{\s*(\w+|\.)?\s*(>>)?\s*\??\s*\}$//;
- $mapping = $name if($mapping eq ".");
+ # Get the options.
+ my $options = $1;
+
+ # Remove the options from the name.
+ $name =~ s/\{.*\}$//;
+
+ # Check if param should be optional or an output param.
+ $flags = FLAG_PARAM_OPTIONAL if($options =~ /\?/);
+ $flags |= FLAG_PARAM_OUTPUT if($options =~ />>/);
+
+ # Check if it should be mapped to a C param.
+ if ($options =~ /(\w+|\.)/)
+ {
+ $mapping = $1;
+ $mapping = $name if($mapping eq ".");
+ }
}
push(@$param_types, $type);
}
$type = string_trim($type);
-
+
# Determine if the param is optional, an output param or if a C param
# name should be mapped to the current C++ index (if name ends with
# {c_name>>?}). (A '.' for the name means use the C++ as the C name).
- if ($name =~ /\{\s*(\w+|\.)?\s*(>>)?\s*(\??)\s*\}$/)
+ # '>>' - Means that it is an output parameter.
+ # '?' - Means that it is an optional parameter.
+ if ($name =~ /\{(.*)\}$/)
{
- $flags = FLAG_PARAM_OPTIONAL if($3);
- $flags |= FLAG_PARAM_OUTPUT if($2);
- $mapping = $1 if($1);
- $name =~ s/\{\s*(\w+|\.)?\s*(>>)?\??\s*\}$//;
- $mapping = $name if($mapping eq ".");
+ # Get the options.
+ my $options = $1;
+
+ # Remove the options from the name.
+ $name =~ s/\{.*\}$//;
+
+ # Check if param should be optional or an output param.
+ $flags = FLAG_PARAM_OPTIONAL if($options =~ /\?/);
+ $flags |= FLAG_PARAM_OUTPUT if($options =~ />>/);
+
+ # Check if it should be mapped to a C param.
+ if ($options =~ /(\w+|\.)/)
+ {
+ $mapping = $1;
+ $mapping = $name if($mapping eq ".");
+ }
}
push(@$param_types, $type);
# );
# $self->append($str);
+ $self->ifdef($ifdef);
+
# Prepend a Doxygen @throws directive to the declaration if the virtual
# function throws an error.
if($$objCDefsFunc{throw_any_errors})
$cppVfuncDecl .= " const";
}
- $self->ifdef($ifdef);
$self->append(" $cppVfuncDecl;\n");
$self->endif($ifdef);
$custom_vfunc, $custom_vfunc_callback, $ifdef) = @_;
my $cname = $$objCFunc{name};
-
+
my $errthrow = "";
if($$objCFunc{throw_any_errors})
{
my ($conversions, $declarations, $initializations) =
convert_args_cpp_to_c($objCppfunc, $objCFunc, 0, $line_num, $errthrow);
- my $str = sprintf("_VFUNC_CC(%s,%s,%s,%s,\`%s\',\`%s\',%s,%s,%s,%s)dnl\n",
+ my $no_slot_copy = "";
+ $no_slot_copy = "no_slot_copy" if ($$objCppfunc{no_slot_copy});
+
+ my $str = sprintf("_VFUNC_CC(%s,%s,%s,%s,\`%s\',\`%s\',%s,%s,%s,%s,%s,%s,%s)dnl\n",
$$objCppfunc{name},
$cname,
$$objCppfunc{rettype},
$objCppfunc->get_is_const(),
$refreturn,
$ifdef,
- $errthrow);
+ $errthrow,
+ $$objCppfunc{slot_type},
+ $$objCppfunc{slot_name},
+ $no_slot_copy);
$self->append($str);
}
my $refreturn_ctype = "";
$refreturn_ctype = "refreturn_ctype" if($$objCFunc{rettype_needs_ref});
- my $str = sprintf("_VFUNC_PCC(%s,%s,%s,%s,\`%s\',\`%s\',\`%s\',%s,%s,%s,%s)dnl\n",
+ # Get the conversions.
+ my $conversions =
+ convert_args_c_to_cpp($objCFunc, $objCppfunc, $line_num);
+
+ my $str = sprintf("_VFUNC_PCC(%s,%s,%s,%s,\`%s\',\`%s\',\`%s\',%s,%s,%s,%s,%s,%s)dnl\n",
$$objCppfunc{name},
$cname,
$$objCppfunc{rettype},
$$objCFunc{rettype},
$objCFunc->args_types_and_names(),
$objCFunc->args_names_only(),
- convert_args_c_to_cpp($objCFunc, $objCppfunc, $line_num),
+ $conversions,
${$objCFunc->get_param_names()}[0],
$refreturn_ctype,
$ifdef,
- $errthrow);
+ $errthrow,
+ $$objCppfunc{slot_type},
+ $$objCppfunc{c_data_param_name});
$self->append($str);
}
$self->append("\n_DEPRECATE_IFDEF_START");
}
+ $self->ifdef($ifdef);
+
if($arg_list == 0)
{
# Doxygen documentation before the method declaration:
$self->append("\n\n /// A $$objCppfunc{name}() convenience overload.\n");
}
- $self->ifdef($ifdef);
-
$self->append(" " . $objCppfunc->get_declaration($arg_list));
$self->endif($ifdef);
-
if($deprecated ne "")
{
$self->append("\n_DEPRECATE_IFDEF_END\n");
convert_args_cpp_to_c($objCppfunc, $objCDefsFunc, 1, $line_num,
$errthrow, $arg_list); #1 means it's static, so it has 'object'.
- $str = sprintf("_STATIC_METHOD(%s,%s,\`%s\',%s,\`%s\',\`%s\',\`%s\',\`%s\',%s,%s,%s,%s,%s,%s,%s)dnl\n",
+ my $no_slot_copy = "";
+ my $slot_type = "";
+ my $slot_name = "";
+
+ # A slot may be optional so if it is signaled by
+ # convert_args_cpp_to_c() to not be included, then don't.
+ if ($$objCppfunc{include_slot})
+ {
+ $slot_type = $$objCppfunc{slot_type};
+ $slot_name = $$objCppfunc{slot_name};
+ $no_slot_copy = "no_slot_copy" if ($$objCppfunc{no_slot_copy});
+ }
+
+ $str = sprintf("_STATIC_METHOD(%s,%s,\`%s\',%s,\`%s\',\`%s\',\`%s\',\`%s\',%s,%s,%s,%s,%s,%s,`%s',`%s',`%s',%s)dnl\n",
$$objCppfunc{name},
$$objCDefsFunc{c_name},
$$objCppfunc{rettype},
$ifdef,
$output_var_name,
$output_var_type,
+ $slot_type,
+ $slot_name,
+ $no_slot_copy,
$line_num
);
} else {
convert_args_cpp_to_c($objCppfunc, $objCDefsFunc, 0, $line_num,
$errthrow, $arg_list);
- $str = sprintf("_METHOD(%s,%s,\`%s\',%s,\`%s\',\`%s\',\`%s\',\`%s\',%s,%s,%s,%s,%s,\`%s\',%s,%s,%s,%s)dnl\n",
+ my $no_slot_copy = "";
+ my $slot_type = "";
+ my $slot_name = "";
+
+ # A slot may be optional so if it is signaled by
+ # convert_args_cpp_to_c() to not be included, then don't.
+ if ($$objCppfunc{include_slot})
+ {
+ $slot_type = $$objCppfunc{slot_type};
+ $slot_name = $$objCppfunc{slot_name};
+ $no_slot_copy = "no_slot_copy" if ($$objCppfunc{no_slot_copy});
+ }
+
+ $str = sprintf("_METHOD(%s,%s,\`%s\',%s,\`%s\',\`%s\',\`%s\',\`%s\',%s,%s,%s,%s,%s,\`%s\',%s,%s,%s,`%s',`%s',`%s',%s)dnl\n",
$$objCppfunc{name},
$$objCDefsFunc{c_name},
$$objCppfunc{rettype},
$ifdef,
$output_var_name,
$output_var_type,
+ $slot_type,
+ $slot_name,
+ $no_slot_copy,
$line_num
);
}
#TODO: Add explicit.
$self->append(" explicit " . $objCppfunc->get_declaration($arg_list) . "\n");
+ my $errthrow = "";
+ if($$objCDefsFunc{throw_any_errors})
+ {
+ $errthrow = "errthrow";
+ }
+
#Implementation:
my $str = sprintf("_CTOR_IMPL(%s,%s,\`%s\',\`%s\')dnl\n",
$$objCppfunc{name},
$$objCDefsFunc{c_name},
$objCppfunc->args_types_and_names($arg_list),
- get_ctor_properties($objCppfunc, $objCDefsFunc, $line_num, $arg_list)
+ get_ctor_properties($objCppfunc, $objCDefsFunc, $line_num, $errthrow, $arg_list)
);
$self->append($str);
my $value_suffix = "Enum";
$value_suffix = "Flags" if($$objEnum{flags});
+ # Get the existing enum description from the parsed docs.
+ my $description = DocsParser::lookup_enum_description("$c_type");
+
+ # Prepend the Doxygen marker ' * ' to all but the first line.
+ $description =~ s/\n/\n * /g;
+
+ # Make sure indentation of passed in comment is correct.
+ $comment =~ s/\n\s*\*/\n */g;
+
+ # Merge the passed in comment to the existing enum documentation.
+ $comment = $comment . "\n * " . $description;
+
my $str = sprintf("_ENUM(%s,%s,%s,\`%s\',\`%s\',\`%s\')dnl\n",
$cpp_type,
$c_type,
{
$self->append("\n_DEPRECATE_IFDEF_START\n");
}
-
+
my $str = sprintf("_PROPERTY_PROXY(%s,%s,%s,%s,%s,`%s')dnl\n",
$name,
$name_underscored,
);
$self->append($str);
}
-
+
if($deprecated ne "")
{
$self->append("\n_DEPRECATE_IFDEF_END");
$$cpp_param_mappings{@$c_param_names[$num_c_args_expected]} = $cpp_index;
}
+ # If the method has a slot temporarily decrement the C arg count when
+ # comparing the C++ and C argument count because the C function would
+ # have a final 'gpointer data' parameter.
+ $num_c_args_expected-- if ($$objCppfunc{slot_name});
+
if ( $num_cpp_args != $num_c_args_expected )
{
Output::error( "convert_args_cpp_to_c(): Incorrect number of arguments. (%d != %d)\n",
return ("", "", "");
}
+ # Reincrement the expected C argument count if there is a slot.
+ $num_c_args_expected++ if ($$objCppfunc{slot_name});
+
# If there is an output parameter it must be processed so re-increment (now)
# the number of C++ arguments.
$num_cpp_args++ if($has_output_param);
# Get the desired argument list combination.
my $possible_arg_list = $$objCppfunc{possible_args_list}[$index];
+ # Tells if slot code should be included or not based on if a slot
+ # parameter is optional.
+ $$objCppfunc{include_slot} = 0;
+
# Loop through the parameters:
my $i;
my $cpp_param_max = $num_cpp_args;
# Remove a possible final '*' from the output parameter type because it
# will be passed by C reference (&name).
$cOutputParamType =~ s/\*$//;
-
+
# Only initialize pointers to zero. Otherwise, use the default
# constructor of the type.
my $initialization = "";
next;
}
+ # If dealing with a slot.
+ if ($$objCppfunc{slot_name} eq $cppParamName)
+ {
+ if ($$objCppfunc{slot_callback})
+ {
+ # The conversion for the slot is the address of the callback.
+ push(@conversions, "&" . $$objCppfunc{slot_callback});
+ }
+ else
+ {
+ Output::error(
+ "convert_args_cpp_to_c(): Missing a slot callback. " .
+ "Specify it with the 'slot_callback' option.\n",);
+ $objCppfunc->dump();
+ $objCDefsFunc->dump();
+ return ("", "", "");
+ }
+
+ # Get the slot type without the const and the & and store it so
+ # it can be passed to the m4 _*METHOD macros.
+ $cppParamType =~ /^const\s+(.*)&/;
+ $$objCppfunc{slot_type} = $1;
+
+ # Signal that the slot code should be included.
+ $$objCppfunc{include_slot} = 1;
+
+ next;
+ }
+
if ($cppParamType ne $cParamType) #If a type conversion is needed.
{
}
}
+ # Append the final slot copy parameter to the C function if the method
+ # has a slot. The m4 macros assume that that parameter name is
+ # "slot_copy". The m4 macros will either copy the slot to the
+ # "slot_copy variable or set it to the address of the slot itself if
+ # the slot should not be copied.
+ if ($$objCppfunc{slot_name})
+ {
+ if ($$objCppfunc{include_slot})
+ {
+ push(@conversions, "slot_copy");
+ }
+ else
+ {
+ push(@conversions, "0")
+ }
+ }
+
return ( join(", ", @conversions), join("\n", @declarations),
join("\n ", @initializations) );
}
{
my ($objCDefsFunc, $objCppfunc, $wrap_line_number) = @_;
+ my $cpp_param_names = $$objCppfunc{param_names};
my $cpp_param_types = $$objCppfunc{param_types};
my $c_param_types = $$objCDefsFunc{param_types};
my $c_param_names = $$objCDefsFunc{param_names};
+ # This variable stores the C++ parameter mappings from the C++
+ # index to the C param name if the mappings exist.
+ my %cpp_index_param_mappings;
+
+ @cpp_index_param_mappings{values $$objCppfunc{param_mappings}}
+ = keys $$objCppfunc{param_mappings};
+
my @result;
my $num_c_args = scalar(@{$c_param_types});
-
- # If the the function has been marked as a function that throws errors (Glib::Error)
- # don't count the last GError** argument.
+
+ # If the the function has been marked as a function that throws errors
+ # (Glib::Error) don't count the last GError** argument.
$num_c_args-- if($$objCDefsFunc{throw_any_errors});
my $num_cpp_args = scalar(@{$cpp_param_types});
+
+ # If the method has a slot temporarily increment the C++ arg count when
+ # comparing the C++ and C argument count because the C function would
+ # have a final 'gpointer data' parameter and the C++ method would not.
+ $num_cpp_args++ if ($$objCppfunc{slot_name});
if ( ($num_cpp_args + 1) != $num_c_args )
{
return "";
}
+ # Re-decrement the expected C++ argument count if there is a slot.
+ $num_cpp_args-- if ($$objCppfunc{slot_name});
- # Loop through the c parameters:
- my $i;
- my $c_param_max = $num_c_args;
+ # Loop through the C++ parameters:
+ my $i;
+ my $cpp_param_max = $num_cpp_args;
- for ($i = 1; $i < $c_param_max; $i++)
- {
- #index of C parameter:
- my $iCppParam = $i - 1;
+ for ($i = 0; $i < $cpp_param_max; $i++)
+ {
+ my $cParamName = "";
+ my $c_index = 0;
- my $cppParamType = $$cpp_param_types[$iCppParam];
- $cppParamType =~ s/ &/&/g; #Remove space between type and &.
- $cppParamType =~ s/ \*/*/g; #Remove space between type and *
+ if (defined $cpp_index_param_mappings{$i})
+ {
+ # If a mapping exists from the current index to a C param name,
+ # use that C param for the conversion.
+ $cParamName = $cpp_index_param_mappings{$i};
- my $cParamName = $$c_param_names[$i];
- my $cParamType = $$c_param_types[$i];
+ # Get the C index based on the C param name.
+ ++$c_index until $$c_param_names[$c_index] eq $cParamName;
+ }
+ else
+ {
+ # If no mapping exists, the C index is the C++ index + 1 (to skip
+ # The 'self' argument of the C function).
+ $c_index = $i + 1;
+ $cParamName = $$c_param_names[$c_index];
+ }
- if ($cParamType ne $cppParamType) #If a type conversion is needed.
- {
- push(@result, sprintf("_CONVERT(%s,%s,%s,%s)\n",
- $cParamType,
- $cppParamType,
- $cParamName,
- $wrap_line_number) );
+ my $cParamType = $$c_param_types[$c_index];
+
+ my $cppParamName = $$cpp_param_names[$i];
+ my $cppParamType = $$cpp_param_types[$i];
+ $cppParamType =~ s/ &/&/g; #Remove space between type and &.
+ $cppParamType =~ s/ \*/*/g; #Remove space between type and *
+
+ if ($$objCppfunc{slot_name})
+ {
+ # If the current parameter is the slot parameter insert the
+ # derefenced name of the variable containing the slot which is
+ # assumed to be '*slot'. The m4 macro is responsible for ensuring
+ # that the variable is declared and the slot in the 'user_data' C
+ # param is placed in the variable.
+ if ($$objCppfunc{slot_name} eq $cppParamName)
+ {
+ push(@result, "*slot");
+
+ # Get the slot type without the const and the '&' and store it so
+ # it can be passed to the m4 macro.
+ $cppParamType =~ /^const\s+(.*)&/;
+
+ # If the type does not contain
+ # any '::' then assume that it is in the library standard namespace
+ # by prepending '__NAMESPACE__::' to it which the m4 macros will
+ # translate to the library namespace.
+ my $plainCppParamType = $1;
+ $plainCppParamType = "__NAMESPACE__::" . $plainCppParamType
+ if (!($plainCppParamType =~ /::/));
+
+ $$objCppfunc{slot_type} = $plainCppParamType;
+
+ # Store the name of the C data parameter so it can be passed
+ # to the m4 macro so it can extract the slot.
+ $$objCppfunc{c_data_param_name} = $$c_param_names[$num_c_args - 1];
+
+ next;
+ }
+ }
+
+ if ($cParamType ne $cppParamType) #If a type conversion is needed.
+ {
+ push(@result, sprintf("_CONVERT(%s,%s,%s,%s)\n",
+ $cParamType,
+ $cppParamType,
+ $cParamName,
+ $wrap_line_number) );
}
else
{
}
-# generates the XXX in g_object_new(get_type(), XXX): A list of property names and values.
-# Uses the cpp arg name as the property name.
-# The optional index specifies which arg list out of the possible combination
-# of arguments based on whether any arguments are optional. index = 0 ==> all
-# the arguments.
-# $string get_ctor_properties($objCppfunc, $objCDefsFunc, $wrap_line_number, $index = 0)
-sub get_ctor_properties($$$$$)
+# generates the XXX in g_object_new(get_type(), XXX): A list of property names
+# and values. Uses the cpp arg name as the property name.
+#
+# - The optional index specifies which arg list out of the possible combination
+# of arguments based on whether any arguments are optional. index = 0 ==> all
+# the arguments.
+#
+# - The errthrow parameter tells if the C new function has a final GError**
+# parameter. That parameter is ignored since it will not form part of the
+# property list.
+#
+# $string get_ctor_properties($objCppfunc, $objCDefsFunc, $wrap_line_number, $errthrow, $index = 0)
+sub get_ctor_properties($$$$$$)
{
- my ($objCppfunc, $objCDefsFunc, $wrap_line_number, $index) = @_;
+ my ($objCppfunc, $objCDefsFunc, $wrap_line_number, $errthrow, $index) = @_;
$index = 0 unless defined $index;
my $num_args = scalar(@{$c_param_types});
+ # If the C function has a final GError** parameter, ignore it.
+ $num_args-- if ($errthrow eq "errthrow");
+
my $num_cpp_args = scalar(@{$cpp_param_types});
if ( $num_cpp_args != $num_args )
{
{
$ifdef = $1;
}
+ # The "slot_name" option tells gmmproc the name of the parameter
+ # that is a slot in the method if there is one.
+ elsif($argRef =~ /^slot_name\s+(\w+)/)
+ {
+ $$objCppfunc{slot_name} = $1;
+ }
+ # The "slot_callback" option tells gmmproc the name of the
+ # callback function that should be passed to the C function if the
+ # method has a slot.
+ elsif($argRef =~ /^slot_callback\s+(\w+)/)
+ {
+ $$objCppfunc{slot_callback} = $1;
+ }
+ # The "no_slot_copy" options tells gmmproc to pass the actual slot
+ # and not a copy of it to the C function in the data parameter.
+ if($argRef eq "no_slot_copy")
+ {
+ $$objCppfunc{no_slot_copy} = 1;
+ }
}
if ($commentblock ne '')
}
else
{
- $commentblock = DocsParser::lookup_documentation($argCFunctionName, $deprecation_docs);
+ $commentblock = DocsParser::lookup_documentation($argCFunctionName,
+ $deprecation_docs, $objCppfunc);
}
$objOutputter->output_wrap_meth($filename, $line_num, $objCppfunc, $objCfunc, $argCppMethodDecl, $commentblock, $ifdef);
}
}
+ # Handle options (presently only "errthrow" is recognized).
+ $$objCfunc{throw_any_errors} = 0;
+ while($#args >= 2)
+ {
+ my $argRef = string_trim(pop @args);
+ if($argRef eq "errthrow")
+ {
+ $$objCfunc{throw_any_errors} = 1;
+ }
+ else
+ {
+ print STDERR "$filename:$line_num:_WRAP_CTOR: Invalid option '$argRef'.\n";
+ return;
+ }
+ }
+
$objOutputter->output_wrap_ctor($filename, $line_num, $objCppfunc, $objCfunc, $argCppMethodDecl);
}
my $custom_vfunc_callback = 0;
my $ifdef = "";
my $errthrow = 0;
+ my $slot_name = "";
+ my $slot_callback = "";
+ my $no_slot_copy = 0;
while($#args >= 2) # If optional arguments are there.
{
{
$ifdef = $1;
}
+ # The "slot_name" option tells gmmproc the name of the parameter
+ # that is a slot in the virtual function if there is one.
+ elsif($argRef =~ /^slot_name\s+(\w+)/)
+ {
+ $slot_name = $1;
+ }
+ # The "slot_callback" option tells gmmproc the name of the
+ # callback function that should be passed to the C function if the
+ # virtual function has a slot.
+ elsif($argRef =~ /^slot_callback\s+(\w+)/)
+ {
+ $slot_callback = $1;
+ }
+ # The "no_slot_copy" options tells gmmproc to pass the actual slot
+ # and not a copy of it to the C function in the data parameter.
+ elsif($argRef eq "no_slot_copy")
+ {
+ $no_slot_copy = 1;
+ }
}
$self->output_wrap_vfunc($argCppDecl, $argCName, $$self{filename}, $$self{line_num},
$refreturn, $refreturn_ctype, $custom_vfunc,
- $custom_vfunc_callback, $ifdef, $errthrow);
+ $custom_vfunc_callback, $ifdef, $errthrow,
+ $slot_name, $slot_callback, $no_slot_copy);
}
sub on_wrap_enum($)
my $filename = $$self{filename};
my $line_num = $$self{line_num};
-
+
#TODO: Reduce duplication with on_wrap_method():
my $argDeprecated = "";
my $deprecation_docs = "";
while($#args >= 2) # If the optional arguments are there.
{
my $argRef = string_trim(pop @args);
-
+
if($argRef =~ /^deprecated(.*)/) #If deprecated is at the start.
{
$argDeprecated = "deprecated";
}
}
}
-
+
$objOutputter->output_wrap_property($filename, $line_num, $argPropertyName, $argCppType, $$self{c_class}, $argDeprecated, $deprecation_docs);
}
}
}
-# void output_wrap($CppDecl, $vfunc_name, $filename, $line_num, $refreturn, $refreturn_ctype,
-# $custom_vfunc, $custom_vfunc_callback, $ifdef, $errthrow)
-sub output_wrap_vfunc($$$$$$$$$)
+# void output_wrap_vfunc($CppDecl, $vfunc_name, $filename, $line_num,
+# $refreturn, $refreturn_ctype,
+# $custom_vfunc, $custom_vfunc_callback, $ifdef, $errthrow,
+# $slot_name, $slot_callback, $no_slot_copy)
+sub output_wrap_vfunc($$$$$$$$$$$$)
{
my ($self, $CppDecl, $vfunc_name, $filename, $line_num, $refreturn, $refreturn_ctype,
- $custom_vfunc, $custom_vfunc_callback, $ifdef, $errthrow) = @_;
+ $custom_vfunc, $custom_vfunc_callback, $ifdef, $errthrow,
+ $slot_name, $slot_callback, $no_slot_copy) = @_;
#Some checks:
return if ($self->output_wrap_check($CppDecl, $vfunc_name, $filename, $line_num, '_WRAP_VFUNC'));
$$objCppVfunc{rettype_needs_ref} = $refreturn;
$$objCppVfunc{name} .= "_vfunc"; #All vfuncs should have the "_vfunc" suffix, and a separate easily-named invoker method.
+
+ # Store the slot information in the vfunc if specified.
+ $$objCppVfunc{slot_name} = $slot_name if ($slot_name);
+ $$objCppVfunc{slot_callback} = $slot_callback if ($slot_callback);
+ $$objCppVfunc{no_slot_copy} = $no_slot_copy if ($no_slot_copy);
$$objCVfunc{rettype_needs_ref} = $refreturn_ctype;
$$objCVfunc{throw_any_errors} = 1 if($errthrow);
projects / platform / upstream / glibmm.git / commitdiff