glibmm: Glib Namespace Reference

glibmm 2.78.0

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Glib Namespace Reference

## Namespaces
namespace | Ascii
namespace | Base64
namespace | Container_Helpers
namespace | Markup
namespace | Traits
namespace | Unicode

## Classes
class | ArrayHandler
| A utility for converting between std::vector and plain C arrays. More...
class | ArrayHandler< bool >
class | Binding
| Bind two object properties. More...
class | ByteArray
| ByteArray - Arrays of bytes. More...
class | Bytes
| A simple refcounted data type representing an immutable byte sequence from an unspecified origin. More...
class | Checksum
| Computes the checksum for data. More...
class | ConvertError
| Exception class for charset conversion errors. More...
class | Date
| Julian calendar date. More...
class | DateTime
| DateTime - A structure representing Date and Time. More...
class | DBusHandle
| Class for D-Bus handles in Glib::Variant. More...
class | DBusObjectPathString
| String class for D-Bus object paths in Glib::Variant. More...
class | DBusSignatureString
| String class for D-Bus signatures in Glib::Variant. More...
class | Dir
| Utility class representing an open directory. More...
class | DirIterator
| The iterator type of Glib::Dir. More...
class | Dispatcher
| Signal class for inter-thread communication. More...
class | Environ
| A convenience class for manipulating a copy of the environment variables. More...
class | Error
class | ExtraClassInit
| A convenience class for named custom types. More...
class | FileError
| Exception class for file-related errors. More...
class | IConv
| Thin iconv() wrapper. More...
class | IdleSource
class | Interface
class | IOChannel
| IOChannel aims to provide portable I/O support for files, pipes and sockets, and to integrate them with the GLib main event loop. More...
class | IOChannelError
| Exception class for IOChannel errors. More...
class | IOSource
class | KeyFile
| 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. More...
class | KeyFileError
| Exception class for KeyFile errors. More...
class | ListHandler
| A utility for converting between std::vector and GList. More...
class | MainContext
| Main context. More...
class | MainLoop
class | MarkupError
| Exception class for markup parsing errors. More...
class | MatchInfo
| MatchInfo - MatchInfo is used to retrieve information about the regular expression match which created it. More...
class | Module
| Dynamic loading of modules. More...
class | NodeTree
| 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. More...
class | Object
class | ObjectBase
| Glib::ObjectBase is a common base class for Objects and Interfaces. More...
class | OptionContext
| An OptionContext defines and parses commandline options, using OptionGroups and option entries . More...
class | OptionEntry
| An OptionEntry defines a single option. More...
class | OptionError
| Exception class for options. More...
class | OptionGroup
| An OptionGroup defines the options in a single group. More...
class | PatternSpec
class | PollFD
class | Property
| A Glib::Object property. More...
class | Property_ReadOnly
| See Property. More...
class | Property_WriteOnly
| See Property. More...
class | PropertyBase
| This is the base class for Glib::Object properties. More...
class | PropertyProxy
| A PropertyProxy can be used to get and set the value of an object's property. More...
class | PropertyProxy_Base
class | PropertyProxy_ReadOnly
| See PropertyProxy(). More...
class | PropertyProxy_WriteOnly
| See PropertyProxy(). More...
class | Quark
class | QueryQuark
| Quarks are unique IDs in Glib for strings for use in hash table lookups. More...
class | Rand
class | Regex
| Perl-compatible regular expressions - matches strings against regular expressions. More...
class | RegexError
| Exception class for Regex More...
class | ShellError
| Exception class for shell utility errors. More...
class | SignalChildWatch
class | SignalIdle
class | SignalIO
class | SignalProxy< R(T...)>
| Proxy for signals with any number of arguments. More...
class | SignalProxy< void(T...)>
| Proxy for signals with any number of arguments. More...
class | SignalProxyBase
class | SignalProxyDetailed< R(T...)>
| Proxy for signals with any number of arguments and possibly a detailed name. More...
class | SignalProxyDetailed< void(T...)>
| Proxy for signals with any number of arguments and possibly a detailed name. More...
class | SignalProxyDetailedBase
| The SignalProxy provides an API similar to sigc::signal that can be used to connect sigc::slots to glib signals. More...
class | SignalProxyNormal
| The SignalProxy provides an API similar to sigc::signal that can be used to connect sigc::slots to glib signals. More...
class | SignalProxyProperty
| Use the connect() method, with sigc::ptr_fun() or sigc::mem_fun() to connect signals to signal handlers. More...
class | SignalTimeout
class | SListHandler
| A utility for converting between std::vector and GSList. More...
class | Source
class | SpawnError
| Exception class for errors occuring when spawning processes. More...
class | StdStringView
| Helper class to avoid unnecessary string copying in function calls. More...
class | TimeoutSource
class | Timer
| Portable stop watch interface. More...
class | TimeZone
| TimeZone - A structure representing a time zone. More...
class | ustring
| Glib::ustring has much the same interface as std::string, but contains Unicode characters encoded as UTF-8. More...
class | ustring_Iterator
| The iterator type of Glib::ustring. More...
class | UStringView
| Helper class to avoid unnecessary string copying in function calls. More...
class | Value
| Generic value implementation for custom types. More...
class | Value< bool >
class | Value< const T *, Enable >
| Specialization for pointers to const instances of any type. More...
class | Value< double >
class | Value< float >
class | Value< Glib::RefPtr< Glib::Bytes > >
class | Value< Glib::ustring >
| Specialization for UTF-8 strings. More...
class | Value< int >
class | Value< long >
class | Value< long long >
class | Value< signed char >
class | Value< std::string >
| Specialization for strings. More...
class | Value< std::vector< Glib::ustring > >
| Specialization for vectors of UTF-8 strings. More...
class | Value< std::vector< std::string > >
| Specialization for vectors of strings. More...
class | Value< T *, Enable >
| Specialization for pointers to instances of any type. More...
class | Value< unsigned char >
class | Value< unsigned int >
class | Value< unsigned long >
class | Value< unsigned long long >
class | Value< void * >
class | Value_Boxed
class | Value_Enum
| Base class of Glib::Value<T> specializations for enum types. More...
class | Value_Flags
| Base class of Glib::Value<T> specializations for flags types. More...
class | Value_Pointer
class | Value_RefPtrBoxed
class | ValueBase
class | ValueBase_Boxed
class | ValueBase_Enum
class | ValueBase_Flags
class | ValueBase_Object
class | ValueBase_String
class | ValueBase_Variant
class | Variant
| Template class used for the specialization of the Variant<> classes. More...
class | Variant< bool >
| Specialization of Glib::Variant containing a bool type. More...
class | Variant< DBusHandle >
| Specialization of Glib::Variant containing a DBusHandle type. More...
class | Variant< double >
| Specialization of Glib::Variant containing a double type. More...
class | Variant< gint16 >
| Specialization of Glib::Variant containing a gint16 type. More...
class | Variant< gint32 >
| Specialization of Glib::Variant containing a gint32 type. More...
class | Variant< Glib::DBusObjectPathString >
| Specialization of Variant containing a Glib::DBusObjectPathString, for variants of type object path. More...
class | Variant< Glib::DBusSignatureString >
| Specialization of Variant containing a Glib::DBusSignatureString, for variants of type signature. More...
class | Variant< Glib::ustring >
| Specialization of Variant containing a Glib::ustring, for variants of type string, object path, or signature. More...
class | Variant< guint16 >
| Specialization of Glib::Variant containing a guint16 type. More...
class | Variant< guint32 >
| Specialization of Glib::Variant containing a guint32 type. More...
class | Variant< long >
| Specialization of Glib::Variant containing a long type. More...
class | Variant< long long >
| Specialization of Glib::Variant containing a long long type. More...
class | Variant< std::map< K, V > >
| Specialization of Variant containing a dictionary (a map of (key, value) elements). More...
class | Variant< std::pair< K, V > >
| Specialization of Variant containing a dictionary entry.
class | Variant< std::string >
| Specialization of Variant containing a std::string, for variants of type bytestring, string, object path, or signature. More...
class | Variant< std::tuple< Types... > >
| Specialization of Variant containing a tuple. More...
class | Variant< std::vector< Glib::DBusObjectPathString > >
| Specialization of Variant containing an array of D-Bus object paths. More...
class | Variant< std::vector< Glib::ustring > >
| Specialization of Variant containing an array of UTF-8 capable strings. More...
class | Variant< std::vector< std::string > >
| Specialization of Variant containing an array of non-UTF-8 strings (byte string arrays). More...
class | Variant< std::vector< T > >
| Specialization of Variant containing an array of items. More...
class | Variant< unsigned char >
| Specialization of Glib::Variant containing a unsigned char type. More...
class | Variant< unsigned long >
| Specialization of Glib::Variant containing a unsigned long type. More...
class | Variant< unsigned long long >
| Specialization of Glib::Variant containing a unsigned long long type. More...
class | Variant< Variant< T > >
| Specialization of Variant containing a Variant<T>. More...
class | Variant< VariantBase >
| Specialization of Variant containing a VariantBase. More...
class | VariantBase
| This is the base class for all Variant types. More...
class | VariantContainerBase
| The base class for multiple-item Variants, such as Variants containing tuples or arrays, and also for maybe-typed (that is, nullable) Variant types. More...
class | VariantDict
| VariantDict is a mutable interface to Variant dictionaries. More...
class | VariantIter
| VariantIter - An opaque data structure used to iterate through VariantContainerBase containers such as arrays. More...
class | VariantParseError
| Exception class for Variant parse errors. More...
class | VariantStringBase
| Base class from which string variant classes derive. More...
class | VariantType
| VariantType - The VariantBase type system. More...

## Typedefs
template<class T_CppObject >
using | RefPtr = std::shared_ptr< T_CppObject >
| RefPtr<> is a reference-counting shared smartpointer.
using | TimeSpan = GTimeSpan
| A value representing an interval of time, in microseconds.
using | Pid = GPid
using | SlotSpawnChildSetup = sigc::slot< void()>
| For instance, void on_child_setup();.

## Enumerations
enum | OwnershipType { OWNERSHIP_NONE = 0 , OWNERSHIP_SHALLOW , OWNERSHIP_DEEP }
enum | { PRIORITY_HIGH = -100 , PRIORITY_DEFAULT = 0 , PRIORITY_HIGH_IDLE = 100 , PRIORITY_DEFAULT_IDLE = 200 , PRIORITY_LOW = 300 }
enum class | MainContextFlags { NONE = 0x0 , OWNERLESS_POLLING = 0x1 }
enum class | ParamFlags { READABLE = 1 << 0 , WRITABLE = 1 << 1 , READWRITE = 0x3 , CONSTRUCT = 1 << 2 , CONSTRUCT_ONLY = 1 << 3 , LAX_VALIDATION = 1 << 4 , STATIC_NAME = 1 << 5 , PRIVATE = 0x20 , STATIC_NICK = 1 << 6 , STATIC_BLURB = 1 << 7 , EXPLICIT_NOTIFY = 1 << 30 , DEPRECATED = (gint)(1u << 31) }
enum class | FileTest { IS_REGULAR = 1 << 0 , IS_SYMLINK = 1 << 1 , IS_DIR = 1 << 2 , IS_EXECUTABLE = 1 << 3 , EXISTS = 1 << 4 }
enum class | SeekType { CUR , SET , END }
enum class | IOStatus { ERROR , NORMAL , ENDOFFILE , AGAIN }
enum class | IOFlags { NONE = 0x0 , APPEND = 1 << 0 , NONBLOCK = 1 << 1 , IS_READABLE = 1 << 2 , IS_WRITABLE = 1 << 3 , IS_WRITEABLE = 1 << 3 , IS_SEEKABLE = 1 << 4 , MASK = (1 << 5) - 1 , GET_MASK = 0x1f , SET_MASK = 0x3 }
enum class | IOCondition { IO_IN = G_IO_IN , IO_OUT = G_IO_OUT , IO_PRI = G_IO_PRI , IO_ERR = G_IO_ERR , IO_HUP = G_IO_HUP , IO_NVAL = G_IO_NVAL }
| A bitwise combination representing an I/O condition to watch for on an event source. More...
enum class | UserDirectory { DESKTOP , DOCUMENTS , DOWNLOAD , MUSIC , PICTURES , PUBLIC_SHARE , TEMPLATES , VIDEOS , N_DIRECTORIES }
enum class | FormatSizeFlags { DEFAULT = 0x0 , LONG_FORMAT = 1 << 0 , IEC_UNITS = 1 << 1 , BITS = 1 << 2 , ONLY_VALUE = 1 << 3 , ONLY_UNIT = 1 << 4 }
enum class | SpawnFlags { DEFAULT = 0x0 , LEAVE_DESCRIPTORS_OPEN = 1 << 0 , DO_NOT_REAP_CHILD = 1 << 1 , SEARCH_PATH = 1 << 2 , STDOUT_TO_DEV_NULL = 1 << 3 , STDERR_TO_DEV_NULL = 1 << 4 , CHILD_INHERITS_STDIN = 1 << 5 , FILE_AND_ARGV_ZERO = 1 << 6 , SEARCH_PATH_FROM_ENVP = 1 << 7 , CLOEXEC_PIPES = 1 << 8 , CHILD_INHERITS_STDOUT = 1 << 9 , CHILD_INHERITS_STDERR = 1 << 10 , STDIN_FROM_DEV_NULL = 1 << 11 }
enum class | TimeType { STANDARD , DAYLIGHT , UNIVERSAL }
enum class | UnicodeType { CONTROL , FORMAT , UNASSIGNED , PRIVATE_USE , SURROGATE , LOWERCASE_LETTER , MODIFIER_LETTER , OTHER_LETTER , TITLECASE_LETTER , UPPERCASE_LETTER , SPACING_MARK , ENCLOSING_MARK , NON_SPACING_MARK , DECIMAL_NUMBER , LETTER_NUMBER , OTHER_NUMBER , CONNECT_PUNCTUATION , DASH_PUNCTUATION , CLOSE_PUNCTUATION , FINAL_PUNCTUATION , INITIAL_PUNCTUATION , OTHER_PUNCTUATION , OPEN_PUNCTUATION , CURRENCY_SYMBOL , MODIFIER_SYMBOL , MATH_SYMBOL , OTHER_SYMBOL , LINE_SEPARATOR , PARAGRAPH_SEPARATOR , SPACE_SEPARATOR }
enum class | UnicodeBreakType { MANDATORY , CARRIAGE_RETURN , LINE_FEED , COMBINING_MARK , SURROGATE , ZERO_WIDTH_SPACE , INSEPARABLE , NON_BREAKING_GLUE , CONTINGENT , SPACE , AFTER , BEFORE , BEFORE_AND_AFTER , HYPHEN , NON_STARTER , OPEN_PUNCTUATION , CLOSE_PUNCTUATION , QUOTATION , EXCLAMATION , IDEOGRAPHIC , NUMERIC , INFIX_SEPARATOR , SYMBOL , ALPHABETIC , PREFIX , POSTFIX , COMPLEX_CONTEXT , AMBIGUOUS , UNKNOWN , NEXT_LINE , WORD_JOINER , HANGUL_L_JAMO , HANGUL_V_JAMO , HANGUL_T_JAMO , HANGUL_LV_SYLLABLE , HANGUL_LVT_SYLLABLE , CLOSE_PARANTHESIS , CLOSE_PARENTHESIS = CLOSE_PARANTHESIS , CONDITIONAL_JAPANESE_STARTER , HEBREW_LETTER , REGIONAL_INDICATOR , EMOJI_BASE , EMOJI_MODIFIER , ZERO_WIDTH_JOINER }
enum class | AsciiType { AsciiType::ALNUM = 1 << 0 , AsciiType::ALPHA = 1 << 1 , AsciiType::CNTRL = 1 << 2 , AsciiType::DIGIT = 1 << 3 , AsciiType::GRAPH = 1 << 4 , AsciiType::LOWER = 1 << 5 , AsciiType::PRINT = 1 << 6 , AsciiType::PUNCT = 1 << 7 , AsciiType::SPACE = 1 << 8 , AsciiType::UPPER = 1 << 9 , AsciiType::XDIGIT = 1 << 10 }
enum class | NormalizeMode { DEFAULT , NFD = DEFAULT , DEFAULT_COMPOSE , NFC = DEFAULT_COMPOSE , ALL , NFKD = ALL , ALL_COMPOSE , NFKC = ALL_COMPOSE }

## Functions
template<class T_CppObject >
RefPtr< T_CppObject > | make_refptr_for_instance (T_CppObject *object)
| Create a RefPtr<> to an instance of any class that has reference() and unreference() methods, and whose destructor is noexcept (the default for destructors).
sigc::connection | add_exception_handler (const sigc::slot< void()> &slot)
| Specify a slot to be called when an exception is thrown by a signal handler.
void | init ()
| Initialize glibmm.
void | set_init_to_users_preferred_locale (bool state=true)
| Instruct Glib::init() which global locale to set.
bool | get_init_to_users_preferred_locale ()
| Get the state, set with set_init_to_users_preferred_locale().
RefPtr< ObjectBase > | wrap_interface (GObject *object, bool take_copy=false)
SignalTimeout | signal_timeout ()
| Convenience timeout signal.
SignalIdle | signal_idle ()
| Convenience idle signal.
SignalIO | signal_io ()
| Convenience I/O signal.
SignalChildWatch | signal_child_watch ()
| Convenience child watch signal.
bool | str_has_prefix (const std::string & str, const std::string & prefix)
| Looks whether the string str begins with prefix.
bool | str_has_suffix (const std::string & str, const std::string & suffix)
| Looks whether the string str ends with suffix.
std::string | strescape (const std::string &source)
| Escapes all special characters in the string.
std::string | strescape (const std::string &source, const std::string & exceptions)
| Escapes all special characters in the string.
std::string | strcompress (const std::string &source)
| Replaces all escaped characters with their one byte equivalent.
Glib::ustring | strerror (int errnum)
| Returns a string corresponding to the given error code, e.g. `"no such process"`.
Glib::ustring | strsignal (int signum)
| Returns a string describing the given signal, e.g. `"Segmentation fault"`.
void | usleep (unsigned long microseconds)
| Pauses the current thread for the given number of microseconds.
gunichar | get_unichar_from_std_iterator (std::string::const_iterator pos)
| Extract a UCS-4 character from UTF-8 data.
template<class T >
T::BaseObjectType * | unwrap (T *ptr)
| Get the underlying C instance from the C++ instance.
template<class T >
const T::BaseObjectType * | unwrap (const T *ptr)
| Get the underlying C instance from the C++ instance.
template<class T >
T::BaseObjectType * | unwrap (const Glib::RefPtr< T > &ptr)
| Get the underlying C instance from the C++ instance.
template<class T >
const T::BaseObjectType * | unwrap (const Glib::RefPtr< const T > &ptr)
| Get the underlying C instance from the C++ instance.
template<class T >
T::BaseObjectType * | unwrap_copy (const T &obj)
| Get the underlying C instance from the C++ instance and acquire a reference or copy.
template<class T >
T::BaseObjectType * | unwrap_copy (const Glib::RefPtr< T > &ptr)
| Get the underlying C instance from the C++ instance and acquire a reference.
template<class T >
const T::BaseObjectType * | unwrap_copy (const Glib::RefPtr< const T > &ptr)
| Get the underlying C instance from the C++ instance and acquire a reference.
bool | get_charset ()
| Get the charset used by the current locale.
bool | get_charset (std::string &charset)
| Get the charset used by the current locale.
std::string | convert (const std::string & str, const std::string &to_codeset, const std::string &from_codeset)
| Convert from one encoding to another.
std::string | convert_with_fallback (const std::string & str, const std::string &to_codeset, const std::string &from_codeset)
| Converts a string from one character set to another, possibly including fallback sequences for characters not representable in the output.
std::string | convert_with_fallback (const std::string & str, const std::string &to_codeset, const std::string &from_codeset, const Glib::ustring &fallback)
| Converts a string from one character set to another, possibly including fallback sequences for characters not representable in the output.
Glib::ustring | locale_to_utf8 (const std::string &opsys_string)
| Convert from the current locale's encoding to UTF-8.
std::string | locale_from_utf8 (const Glib::ustring &utf8_string)
| Convert from UTF-8 to the current locale's encoding.
Glib::ustring | filename_to_utf8 (const std::string &opsys_string)
| Converts a string which is in the encoding used for filenames into a UTF-8 string.
std::string | filename_from_utf8 (const Glib::ustring &utf8_string)
| Converts a string from UTF-8 to the encoding used for filenames.
std::string | filename_from_uri (const Glib::ustring &uri, Glib::ustring &hostname)
| Converts an escaped UTF-8 encoded URI to a local filename in the encoding used for filenames.
std::string | filename_from_uri (const Glib::ustring &uri)
| Converts an escaped UTF-8 encoded URI to a local filename in the encoding used for filenames.
Glib::ustring | filename_to_uri (const std::string &filename, const Glib::ustring &hostname)
| Converts an absolute filename to an escaped UTF-8 encoded URI.
Glib::ustring | filename_to_uri (const std::string &filename)
| Converts an absolute filename to an escaped UTF-8 encoded URI.
Glib::ustring | filename_display_basename (const std::string &filename)
| Returns the display basename for the particular filename, guaranteed to be valid UTF-8.
Glib::ustring | filename_display_name (const std::string &filename)
| Converts a filename into a valid UTF-8 string.
MainContextFlags | operator| (MainContextFlags lhs, MainContextFlags rhs)
MainContextFlags | operator& (MainContextFlags lhs, MainContextFlags rhs)
MainContextFlags | operator^ (MainContextFlags lhs, MainContextFlags rhs)
MainContextFlags | operator~ (MainContextFlags flags)
MainContextFlags & | operator|= (MainContextFlags &lhs, MainContextFlags rhs)
MainContextFlags & | operator&= (MainContextFlags &lhs, MainContextFlags rhs)
MainContextFlags & | operator^= (MainContextFlags &lhs, MainContextFlags rhs)
ParamFlags | operator| (ParamFlags lhs, ParamFlags rhs)
ParamFlags | operator& (ParamFlags lhs, ParamFlags rhs)
ParamFlags | operator^ (ParamFlags lhs, ParamFlags rhs)
ParamFlags | operator~ (ParamFlags flags)
ParamFlags & | operator|= (ParamFlags &lhs, ParamFlags rhs)
ParamFlags & | operator&= (ParamFlags &lhs, ParamFlags rhs)
ParamFlags & | operator^= (ParamFlags &lhs, ParamFlags rhs)
FileTest | operator| (FileTest lhs, FileTest rhs)
FileTest | operator& (FileTest lhs, FileTest rhs)
FileTest | operator^ (FileTest lhs, FileTest rhs)
FileTest | operator~ (FileTest flags)
FileTest & | operator|= (FileTest &lhs, FileTest rhs)
FileTest & | operator&= (FileTest &lhs, FileTest rhs)
FileTest & | operator^= (FileTest &lhs, FileTest rhs)
bool | file_test (const std::string &filename, FileTest test)
| Returns `true` if any of the tests in the bitfield test are true.
int | mkstemp (std::string &filename_template)
| Opens a temporary file.
int | file_open_tmp (std::string &name_used, const std::string & prefix)
| Opens a file for writing in the preferred directory for temporary files (as returned by Glib::get_tmp_dir()).
int | file_open_tmp (std::string &name_used)
| Opens a file for writing in the preferred directory for temporary files (as returned by Glib::get_tmp_dir()).
std::string | file_get_contents (const std::string &filename)
| Reads an entire file into a string, with good error checking.
void | file_set_contents (const std::string &filename, const gchar *contents, gssize length)
| Writes all of contents to a file named filename, with good error checking.
void | file_set_contents (const std::string &filename, const std::string &contents)
| A variant of file_set_contents which accepts a standard C++ string.
IOFlags | operator| (IOFlags lhs, IOFlags rhs)
IOFlags | operator& (IOFlags lhs, IOFlags rhs)
IOFlags | operator^ (IOFlags lhs, IOFlags rhs)
IOFlags | operator~ (IOFlags flags)
IOFlags & | operator|= (IOFlags &lhs, IOFlags rhs)
IOFlags & | operator&= (IOFlags &lhs, IOFlags rhs)
IOFlags & | operator^= (IOFlags &lhs, IOFlags rhs)
IOCondition | operator| (IOCondition lhs, IOCondition rhs)
IOCondition | operator& (IOCondition lhs, IOCondition rhs)
IOCondition | operator^ (IOCondition lhs, IOCondition rhs)
IOCondition | operator~ (IOCondition flags)
IOCondition & | operator|= (IOCondition &lhs, IOCondition rhs)
IOCondition & | operator&= (IOCondition &lhs, IOCondition rhs)
IOCondition & | operator^= (IOCondition &lhs, IOCondition rhs)
Glib::RefPtr< IOChannel > | wrap (GIOChannel *gobject, bool take_copy=false)
KeyFile::Flags | operator| (KeyFile::Flags lhs, KeyFile::Flags rhs)
KeyFile::Flags | operator& (KeyFile::Flags lhs, KeyFile::Flags rhs)
KeyFile::Flags | operator^ (KeyFile::Flags lhs, KeyFile::Flags rhs)
KeyFile::Flags | operator~ (KeyFile::Flags flags)
KeyFile::Flags & | operator|= (KeyFile::Flags &lhs, KeyFile::Flags rhs)
KeyFile::Flags & | operator&= (KeyFile::Flags &lhs, KeyFile::Flags rhs)
KeyFile::Flags & | operator^= (KeyFile::Flags &lhs, KeyFile::Flags rhs)
FormatSizeFlags | operator| (FormatSizeFlags lhs, FormatSizeFlags rhs)
FormatSizeFlags | operator& (FormatSizeFlags lhs, FormatSizeFlags rhs)
FormatSizeFlags | operator^ (FormatSizeFlags lhs, FormatSizeFlags rhs)
FormatSizeFlags | operator~ (FormatSizeFlags flags)
FormatSizeFlags & | operator|= (FormatSizeFlags &lhs, FormatSizeFlags rhs)
FormatSizeFlags & | operator&= (FormatSizeFlags &lhs, FormatSizeFlags rhs)
FormatSizeFlags & | operator^= (FormatSizeFlags &lhs, FormatSizeFlags rhs)
Glib::ustring | get_application_name ()
| Gets a human-readable name for the application, as set by Glib::set_application_name().
void | set_application_name (UStringView application_name)
| Sets a human-readable name for the application.
std::string | get_prgname ()
| Gets the name of the program.
void | set_prgname (StdStringView prgname)
| Sets the name of the program.
std::string | getenv (StdStringView variable, bool &found)
| Returns the value of an environment variable.
std::string | getenv (StdStringView variable)
| Returns the value of an environment variable.
bool | setenv (StdStringView variable, StdStringView value, bool overwrite=true)
| Sets an environment variable.
void | unsetenv (StdStringView variable)
| Removes an environment variable from the environment.
std::vector< std::string > | listenv ()
| Gets the names of all variables set in the environment.
std::string | get_user_name ()
| Gets the user name of the current user.
std::string | get_real_name ()
| Gets the real name of the current user.
Glib::ustring | get_host_name ()
| Return a name for the machine.
std::string | get_home_dir ()
| Gets the current user's home directory.
std::string | get_tmp_dir ()
| Gets the directory to use for temporary files.
std::string | get_current_dir ()
| Gets the current directory.
std::string | get_user_special_dir (UserDirectory directory)
| Returns the full path of a special directory using its logical id.
std::string | get_user_data_dir ()
| Returns a base directory in which to access application data such as icons that is customized for a particular user.
std::string | get_user_config_dir ()
| Returns a base directory in which to store user-specific application configuration information such as user preferences and settings.
std::vector< std::string > | get_system_data_dirs ()
| Returns an ordered list of base directories in which to access system-wide application data.
std::vector< std::string > | get_system_config_dirs ()
| Returns an ordered list of base directories in which to access system-wide configuration information.
std::string | get_user_cache_dir ()
| Returns a base directory in which to store non-essential, cached data specific to particular user.
std::string | get_user_runtime_dir ()
| Returns a directory that is unique to the current user on the local system.
bool | path_is_absolute (StdStringView filename)
| Returns `true` if the given filename is an absolute file name, i.e. it contains a full path from the root directory such as `"/usr/local"` on UNIX or `"C:\\windows"` on Windows systems.
std::string | path_skip_root (StdStringView filename)
| Returns the remaining part of filename after the root component, i.e. after the `"/"` on UNIX or `"C:\\"` on Windows.
std::string | path_get_basename (StdStringView filename)
| Gets the name of the file without any leading directory components.
std::string | path_get_dirname (StdStringView filename)
| Gets the directory components of a file name.
std::string | canonicalize_filename (StdStringView filename, StdStringView relative_to=nullptr)
| Gets the canonical file name from filename.
std::string | build_filename (const std::vector< std::string > &elements)
| Creates a filename from a series of elements using the correct separator for filenames.
template<typename... Strings>
std::string | build_filename (const Strings &... strings)
| Creates a filename from one or more elements using the correct separator for filenames.
std::string | build_path (const std::string &separator, const std::vector< std::string > &elements)
| Creates a path from a series of elements using separator as the separator between elements.
std::string | find_program_in_path (StdStringView program)
| Locates the first executable named program in the user's path, in the same way that `execvp()` would locate it.
Glib::ustring | format_size (guint64 size, FormatSizeFlags flags=FormatSizeFlags::DEFAULT)
| Formats a size (for example the size of a file) into a human readable string.
Module::Flags | operator| (Module::Flags lhs, Module::Flags rhs)
Module::Flags | operator& (Module::Flags lhs, Module::Flags rhs)
Module::Flags | operator^ (Module::Flags lhs, Module::Flags rhs)
Module::Flags | operator~ (Module::Flags flags)
Module::Flags & | operator|= (Module::Flags &lhs, Module::Flags rhs)
Module::Flags & | operator&= (Module::Flags &lhs, Module::Flags rhs)
Module::Flags & | operator^= (Module::Flags &lhs, Module::Flags rhs)
OptionEntry::Flags | operator| (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
OptionEntry::Flags | operator& (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
OptionEntry::Flags | operator^ (OptionEntry::Flags lhs, OptionEntry::Flags rhs)
OptionEntry::Flags | operator~ (OptionEntry::Flags flags)
OptionEntry::Flags & | operator|= (OptionEntry::Flags &lhs, OptionEntry::Flags rhs)
OptionEntry::Flags & | operator&= (OptionEntry::Flags &lhs, OptionEntry::Flags rhs)
OptionEntry::Flags & | operator^= (OptionEntry::Flags &lhs, OptionEntry::Flags rhs)
Regex::CompileFlags | operator| (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
Regex::CompileFlags | operator& (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
Regex::CompileFlags | operator^ (Regex::CompileFlags lhs, Regex::CompileFlags rhs)
Regex::CompileFlags | operator~ (Regex::CompileFlags flags)
Regex::CompileFlags & | operator|= (Regex::CompileFlags &lhs, Regex::CompileFlags rhs)
Regex::CompileFlags & | operator&= (Regex::CompileFlags &lhs, Regex::CompileFlags rhs)
Regex::CompileFlags & | operator^= (Regex::CompileFlags &lhs, Regex::CompileFlags rhs)
Regex::MatchFlags | operator| (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
Regex::MatchFlags | operator& (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
Regex::MatchFlags | operator^ (Regex::MatchFlags lhs, Regex::MatchFlags rhs)
Regex::MatchFlags | operator~ (Regex::MatchFlags flags)
Regex::MatchFlags & | operator|= (Regex::MatchFlags &lhs, Regex::MatchFlags rhs)
Regex::MatchFlags & | operator&= (Regex::MatchFlags &lhs, Regex::MatchFlags rhs)
Regex::MatchFlags & | operator^= (Regex::MatchFlags &lhs, Regex::MatchFlags rhs)
std::vector< std::string > | shell_parse_argv (const std::string &command_line)
| Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported).
std::string | shell_quote (const std::string &unquoted_string)
| Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean unquoted_string.
std::string | shell_unquote (const std::string &quoted_string)
| Unquotes a string as the shell (/bin/sh) would.
SpawnFlags | operator| (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags | operator& (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags | operator^ (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags | operator~ (SpawnFlags flags)
SpawnFlags & | operator|= (SpawnFlags &lhs, SpawnFlags rhs)
SpawnFlags & | operator&= (SpawnFlags &lhs, SpawnFlags rhs)
SpawnFlags & | operator^= (SpawnFlags &lhs, SpawnFlags rhs)
void | spawn_async_with_pipes (const std::string &working_directory, const std::vector< std::string > &argv, const std::vector< std::string > & envp, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, Pid *child_pid=nullptr, int *standard_input=nullptr, int *standard_output=nullptr, int *standard_error=nullptr)
| Executes a child program asynchronously (your program will not block waiting for the child to exit).
void | spawn_async_with_pipes (const std::string &working_directory, const std::vector< std::string > &argv, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, Pid *child_pid=nullptr, int *standard_input=nullptr, int *standard_output=nullptr, int *standard_error=nullptr)
| Like the main spawn_async_with_pipes() method, but inheriting the parent's environment.
void | spawn_async (const std::string &working_directory, const std::vector< std::string > &argv, const std::vector< std::string > & envp, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, Pid *child_pid=nullptr)
| See spawn_async_with_pipes() for a full description.
void | spawn_async (const std::string &working_directory, const std::vector< std::string > &argv, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, Pid *child_pid=nullptr)
| Like the main spawn_async() method, but inheriting the parent's environment.
void | spawn_sync (const std::string &working_directory, const std::vector< std::string > &argv, const std::vector< std::string > & envp, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, std::string *standard_output=nullptr, std::string *standard_error=nullptr, int *wait_status=nullptr)
| Executes a child synchronously (waits for the child to exit before returning).
void | spawn_sync (const std::string &working_directory, const std::vector< std::string > &argv, SpawnFlags flags=SpawnFlags::DEFAULT, const SlotSpawnChildSetup &child_setup={}, std::string *standard_output=nullptr, std::string *standard_error=nullptr, int *wait_status=nullptr)
| Like the main spawn_sync() method, but inheriting the parent's environment.
void | spawn_command_line_async (const std::string &command_line)
| A simple version of spawn_async() that parses a command line with shell_parse_argv() and passes it to spawn_async().
void | spawn_command_line_sync (const std::string &command_line, std::string *standard_output=nullptr, std::string *standard_error=nullptr, int *wait_status=nullptr)
| A simple version of spawn_sync() with little-used parameters removed, taking a command line instead of an argument vector.
void | spawn_close_pid (Pid pid)
| On some platforms, notably WIN32, the Pid type represents a resource which must be closed to prevent resource leaking.
AsciiType | operator| (AsciiType lhs, AsciiType rhs)
AsciiType | operator& (AsciiType lhs, AsciiType rhs)
AsciiType | operator^ (AsciiType lhs, AsciiType rhs)
AsciiType | operator~ (AsciiType flags)
AsciiType & | operator|= (AsciiType &lhs, AsciiType rhs)
AsciiType & | operator&= (AsciiType &lhs, AsciiType rhs)
AsciiType & | operator^= (AsciiType &lhs, AsciiType rhs)
std::string | uri_unescape_string (const std::string &escaped_string, const std::string &illegal_characters={})
| Unescapes a whole escaped string.
std::string | uri_parse_scheme (const std::string &uri)
| Gets the scheme portion of a URI.
std::string | uri_escape_string (const std::string &unescaped, const std::string &reserved_chars_allowed={}, bool allow_utf8=true)
| Escapes a string for use in a URI.
Glib::RefPtr< Gio::Drive > | wrap (GDrive *object, bool take_copy)
Glib::RefPtr< Gio::File > | wrap (GFile *object, bool take_copy)
Glib::RefPtr< Gio::Mount > | wrap (GMount *object, bool take_copy)
Glib::RefPtr< Gio::Volume > | wrap (GVolume *object, bool take_copy)

## Variables
const VariantType | VARIANT_TYPE_BOOL
const VariantType | VARIANT_TYPE_BYTE
const VariantType | VARIANT_TYPE_INT16
const VariantType | VARIANT_TYPE_UINT16
const VariantType | VARIANT_TYPE_INT32
const VariantType | VARIANT_TYPE_UINT32
const VariantType | VARIANT_TYPE_INT64
const VariantType | VARIANT_TYPE_UINT64
const VariantType | VARIANT_TYPE_DOUBLE
const VariantType | VARIANT_TYPE_STRING
const VariantType | VARIANT_TYPE_OBJECT_PATH
const VariantType | VARIANT_TYPE_SIGNATURE
const VariantType | VARIANT_TYPE_VARIANT
const VariantType | VARIANT_TYPE_HANDLE
const VariantType | VARIANT_TYPE_UNIT
const VariantType | VARIANT_TYPE_ANY
const VariantType | VARIANT_TYPE_BASIC
const VariantType | VARIANT_TYPE_MAYBE
const VariantType | VARIANT_TYPE_ARRAY
const VariantType | VARIANT_TYPE_TUPLE
const VariantType | VARIANT_TYPE_DICT_ENTRY
const VariantType | VARIANT_TYPE_DICTIONARY
const VariantType | VARIANT_TYPE_STRING_ARRAY
const VariantType | VARIANT_TYPE_OBJECT_PATH_ARRAY
const VariantType | VARIANT_TYPE_BYTESTRING
const VariantType | VARIANT_TYPE_BYTESTRING_ARRAY

## Typedef Documentation

## ◆ Pid

using Glib::Pid = typedef GPid

## ◆ TimeSpan

using Glib::TimeSpan = typedef GTimeSpan

A value representing an interval of time, in microseconds.

As GTimeSpan, its underlying type is gint64.

## Enumeration Type Documentation

## ◆ anonymous enum

anonymous enum

Enumerator
PRIORITY_HIGH | Use this for high priority event sources. It is not used within GLib or GTK+.
PRIORITY_DEFAULT | Use this for default priority event sources. In glibmm this priority is used by default when installing timeout handlers with SignalTimeout::connect(). In GDK this priority is used for events from the X server.
PRIORITY_HIGH_IDLE | Use this for high priority idle functions. GTK+ uses `PRIORITY_HIGH_IDLE + 10` for resizing operations, and `PRIORITY_HIGH_IDLE + 20` for redrawing operations. (This is done to ensure that any pending resizes are processed before any pending redraws, so that widgets are not redrawn twice unnecessarily.)
PRIORITY_DEFAULT_IDLE | Use this for default priority idle functions. In glibmm this priority is used by default when installing idle handlers with SignalIdle::connect().
PRIORITY_LOW | Use this for very low priority background tasks. It is not used within GLib or GTK+.

## ◆ FileTest

enum class Glib::FileTest
| strong

Enumerator
IS_REGULAR | `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.
IS_SYMLINK | `true` if the file is a symlink.
IS_DIR | `true` if the file is a directory.
IS_EXECUTABLE | `true` if the file is executable.
EXISTS | `true` if the file exists. It may or may not be a regular file.

## ◆ FormatSizeFlags

enum class Glib::FormatSizeFlags
| strong

Enumerator
DEFAULT | Behave the same as g_format_size(). Standardize differences that do not affect the text content, such as the above-mentioned accent representation. No flags, default behaviour.
LONG_FORMAT | Include the exact number of bytes as part of the returned string. For example, "45.6 kB (45,612 bytes)".
IEC_UNITS | 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.
BITS | Set the size as a quantity in bits, rather than bytes, and return units in bits. For example, ‘Mb’ rather than ‘MB’.
ONLY_VALUE | Return only value, without unit; this should not be used together with G_FORMAT_SIZE_LONG_FORMAT nor G_FORMAT_SIZE_ONLY_UNIT. Since glibmm 2.74:
ONLY_UNIT | Return only unit, without value; this should not be used together with G_FORMAT_SIZE_LONG_FORMAT nor G_FORMAT_SIZE_ONLY_VALUE. Since glibmm 2.74:

## ◆ IOCondition

enum class Glib::IOCondition
| strong

A bitwise combination representing an I/O condition to watch for on an event source.

The flags correspond to those used by the `poll()` system call on UNIX (see `man 2 poll`). To test for individual flags, do something like this:

if ((condition & Glib::IOCondition::IO_OUT) == Glib::IOCondition::IO_OUT)
do_some_output();
Glib::IOCondition::IO_OUT
@ IO_OUT
Data can be written (without blocking).

Enumerator
IO_IN | There is data to read.
IO_OUT | Data can be written (without blocking).
IO_PRI | There is urgent data to read.
IO_ERR | Error condition.
IO_HUP | Hung up (the connection has been broken, usually for pipes and sockets).
IO_NVAL | Invalid request. The file descriptor is not open.

## ◆ IOFlags

enum class Glib::IOFlags
| strong

Enumerator
NONE |
APPEND | Turns on append mode, corresponds to O_APPEND (see the documentation of the UNIX open() syscall).
NONBLOCK | Turns on nonblocking mode, corresponds to O_NONBLOCK/O_NDELAY (see the documentation of the UNIX open() syscall).
IS_READABLE | Indicates that the io channel is readable. This flag cannot be changed.
IS_WRITABLE | Indicates that the io channel is writable. This flag cannot be changed.
IS_WRITEABLE | A misspelled version of G_IO_FLAG_IS_WRITABLE that existed before the spelling was fixed in GLib 2.30. It is kept here for compatibility reasons. Deprecated since 2.30.
IS_SEEKABLE | 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.
MASK | The mask that specifies all the valid flags.
GET_MASK | The mask of the flags that are returned from g_io_channel_get_flags().
SET_MASK | The mask of the flags that the user can modify with g_io_channel_set_flags().

## ◆ IOStatus

enum class Glib::IOStatus
| strong

Enumerator
ERROR | An error occurred.
NORMAL | Success.
ENDOFFILE | End of file.
AGAIN | Resource temporarily unavailable.

## ◆ MainContextFlags

enum class Glib::MainContextFlags
| strong

Enumerator
NONE | Default behaviour. No special flags set. Since glibmm 2.74:
OWNERLESS_POLLING | Assume that polling for events will free the thread to process other jobs. That's useful if you're using `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in other event loops.

## ◆ NormalizeMode

enum class Glib::NormalizeMode
| strong

Enumerator
DEFAULT |
NFD | Another name for Glib::NormalizeMode::DEFAULT.
DEFAULT_COMPOSE | Like Glib::NormalizeMode::DEFAULT, but with composed forms rather than a maximally decomposed form.
NFC | Another name for Glib::NormalizeMode::DEFAULT_COMPOSE.
ALL | Beyond Glib::NormalizeMode::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.
NFKD | Another name for Glib::NormalizeMode::ALL.
ALL_COMPOSE | Like Glib::NormalizeMode::ALL, but with composed forms rather than a maximally decomposed form.
NFKC | Another name for Glib::NormalizeMode::ALL_COMPOSE.

## ◆ ParamFlags

enum class Glib::ParamFlags
| strong

Enumerator
READABLE | The parameter is readable.
WRITABLE | The parameter is writable.
READWRITE | Alias for Glib::ParamFlags::READABLE | Glib::ParamFlags::WRITABLE.
CONSTRUCT | The parameter will be set upon object construction.
CONSTRUCT_ONLY | The parameter can only be set upon object construction.
LAX_VALIDATION | Upon parameter conversion (see g_param_value_convert()) strict validation is not required.
STATIC_NAME | The string used as name when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since glibmm 2.8:
PRIVATE | Internal.
STATIC_NICK | The string used as nick when constructing the parameter is guaranteed to remain valid and unmmodified for the lifetime of the parameter. Since glibmm 2.8:
STATIC_BLURB | The string used as blurb when constructing the parameter is guaranteed to remain valid and unmodified for the lifetime of the parameter. Since glibmm 2.8:
EXPLICIT_NOTIFY | Calls to g_object_set_property() for this property will not automatically result in a "notify" signal being emitted: the implementation must call g_object_notify() themselves in case the property actually changes. Since glibmm 2.42:
DEPRECATED | 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 glibmm 2.26:

## ◆ SeekType

enum class Glib::SeekType
| strong

Enumerator
CUR | The current position in the file.
SET | The start of the file.
END | The end of the file.

## ◆ SpawnFlags

enum class Glib::SpawnFlags
| strong

Enumerator
DEFAULT |
LEAVE_DESCRIPTORS_OPEN | The parent's open file descriptors will be inherited by the child; otherwise all descriptors except stdin, stdout and stderr will be closed before calling exec() in the child.
DO_NOT_REAP_CHILD | The child will not be automatically reaped; you must use g_child_watch_add() yourself (or call waitpid() or handle `SIGCHLD` yourself), or the child will become a zombie.
SEARCH_PATH | `argv[0]` need not be an absolute path, it will be looked for in the user's `PATH`.
STDOUT_TO_DEV_NULL | The child's standard output will be discarded, instead of going to the same location as the parent's standard output.
STDERR_TO_DEV_NULL | The child's standard error will be discarded.
CHILD_INHERITS_STDIN | The child will inherit the parent's standard input (by default, the child's standard input is attached to `/dev/null`).
FILE_AND_ARGV_ZERO | The first element of `argv` 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 `argv[0]` as the file to execute, and passes all of `argv` to the child.
SEARCH_PATH_FROM_ENVP | If `argv[0]` is not an absolute path, it will be looked for in the `PATH` from the passed child environment. Since glibmm 2.34:
CLOEXEC_PIPES | Create all pipes with the `O_CLOEXEC` flag set. Since glibmm 2.40:
CHILD_INHERITS_STDOUT | The child will inherit the parent's standard output. Since glibmm 2.74:
CHILD_INHERITS_STDERR | The child will inherit the parent's standard error. Since glibmm 2.74:
STDIN_FROM_DEV_NULL | The child's standard input is attached to `/dev/null`. Since glibmm 2.74:

## ◆ TimeType

enum class Glib::TimeType
| strong

Enumerator
STANDARD | The time is in local standard time.
DAYLIGHT | The time is in local daylight time.
UNIVERSAL | The time is in UTC.

## ◆ UnicodeBreakType

enum class Glib::UnicodeBreakType
| strong

Enumerator
MANDATORY | Mandatory Break (BK).
CARRIAGE_RETURN | Carriage Return (CR).
LINE_FEED | Line Feed (LF).
COMBINING_MARK | Attached Characters and Combining Marks (CM).
SURROGATE |
ZERO_WIDTH_SPACE | Zero Width Space (ZW).
INSEPARABLE | Inseparable (IN).
NON_BREAKING_GLUE | Non-breaking ("Glue") (GL).
CONTINGENT | Contingent Break Opportunity (CB).
SPACE | Space (SP).
AFTER | Break Opportunity After (BA).
BEFORE | Break Opportunity Before (BB).
BEFORE_AND_AFTER | Break Opportunity Before and After (B2).
HYPHEN | Hyphen (HY).
NON_STARTER | Nonstarter (NS).
OPEN_PUNCTUATION |
CLOSE_PUNCTUATION |
QUOTATION | Ambiguous Quotation (QU).
EXCLAMATION | Exclamation/Interrogation (EX).
IDEOGRAPHIC | Ideographic (ID).
NUMERIC | Numeric (NU).
INFIX_SEPARATOR | Infix Separator (Numeric) (IS).
SYMBOL | Symbols Allowing Break After (SY).
ALPHABETIC | Ordinary Alphabetic and Symbol Characters (AL).
PREFIX | Prefix (Numeric) (PR).
POSTFIX | Postfix (Numeric) (PO).
COMPLEX_CONTEXT | Complex Content Dependent (South East Asian) (SA).
AMBIGUOUS | Ambiguous (Alphabetic or Ideographic) (AI).
UNKNOWN | Unknown (XX).
NEXT_LINE | Next Line (NL).
WORD_JOINER | Word Joiner (WJ).
HANGUL_L_JAMO | Hangul L Jamo (JL).
HANGUL_V_JAMO | Hangul V Jamo (JV).
HANGUL_T_JAMO | Hangul T Jamo (JT).
HANGUL_LV_SYLLABLE | Hangul LV Syllable (H2).
HANGUL_LVT_SYLLABLE | Hangul LVT Syllable (H3).
CLOSE_PARANTHESIS | Closing Parenthesis (CP). Since glibmm 2.28: Deprecated: 2.70: Use Glib::UnicodeBreakType::CLOSE_PARENTHESIS instead.
CLOSE_PARENTHESIS | Closing Parenthesis (CP). Since glibmm 2.70:
CONDITIONAL_JAPANESE_STARTER | Conditional Japanese Starter (CJ). Since glibmm 2.32:
HEBREW_LETTER | Hebrew Letter (HL). Since glibmm 2.32:
REGIONAL_INDICATOR | Regional Indicator (RI). Since glibmm 2.36:
EMOJI_BASE | Emoji Base (EB). Since glibmm 2.50:
EMOJI_MODIFIER | Emoji Modifier (EM). Since glibmm 2.50:
ZERO_WIDTH_JOINER | Zero Width Joiner (ZWJ). Since glibmm 2.50:

## ◆ UnicodeType

enum class Glib::UnicodeType
| strong

Enumerator
CONTROL | General category "Other, Control" (Cc).
FORMAT | General category "Other, Format" (Cf).
UNASSIGNED | General category "Other, Not Assigned" (Cn).
PRIVATE_USE | General category "Other, Private Use" (Co).
SURROGATE | General category "Other, Surrogate" (Cs). Surrogates (SG).
LOWERCASE_LETTER | General category "Letter, Lowercase" (Ll).
MODIFIER_LETTER | General category "Letter, Modifier" (Lm).
OTHER_LETTER | General category "Letter, Other" (Lo).
TITLECASE_LETTER | General category "Letter, Titlecase" (Lt).
UPPERCASE_LETTER | General category "Letter, Uppercase" (Lu).
SPACING_MARK | General category "Mark, Spacing" (Mc).
ENCLOSING_MARK | General category "Mark, Enclosing" (Me).
NON_SPACING_MARK | General category "Mark, Nonspacing" (Mn).
DECIMAL_NUMBER | General category "Number, Decimal Digit" (Nd).
LETTER_NUMBER | General category "Number, Letter" (Nl).
OTHER_NUMBER | General category "Number, Other" (No).
CONNECT_PUNCTUATION | General category "Punctuation, Connector" (Pc).
DASH_PUNCTUATION | General category "Punctuation, Dash" (Pd).
CLOSE_PUNCTUATION | General category "Punctuation, Close" (Pe). Closing Punctuation (CL).
FINAL_PUNCTUATION | General category "Punctuation, Final quote" (Pf).
INITIAL_PUNCTUATION | General category "Punctuation, Initial quote" (Pi).
OTHER_PUNCTUATION | General category "Punctuation, Other" (Po).
OPEN_PUNCTUATION | General category "Punctuation, Open" (Ps). Opening Punctuation (OP).
CURRENCY_SYMBOL | General category "Symbol, Currency" (Sc).
MODIFIER_SYMBOL | General category "Symbol, Modifier" (Sk).
MATH_SYMBOL | General category "Symbol, Math" (Sm).
OTHER_SYMBOL | General category "Symbol, Other" (So).
LINE_SEPARATOR | General category "Separator, Line" (Zl).
PARAGRAPH_SEPARATOR | General category "Separator, Paragraph" (Zp).
SPACE_SEPARATOR | General category "Separator, Space" (Zs).

## ◆ UserDirectory

enum class Glib::UserDirectory
| strong

Enumerator
DESKTOP | The user's Desktop directory.
DOCUMENTS | The user's Documents directory.
DOWNLOAD | The user's Downloads directory.
MUSIC | The user's Music directory.
PICTURES | The user's Pictures directory.
PUBLIC_SHARE | The user's shared directory.
TEMPLATES | The user's Templates directory.
VIDEOS | The user's Movies directory.
N_DIRECTORIES | The number of enum values.

## Function Documentation

## ◆ add_exception_handler()

sigc::connection Glib::add_exception_handler | ( | const sigc::slot< void()> & | slot | ) |

Specify a slot to be called when an exception is thrown by a signal handler.

## ◆ file_set_contents() [1/2]

void Glib::file_set_contents | ( | const std::string & | filename,
|  | const gchar * | contents,
|  | gssize | length
| ) |  |

Writes all of contents to a file named filename, with good error checking.

Parameters

  filename | name of a file to write contents to, in the GLib file name encoding
  contents | string to write to the file
  length | length of contents, or -1 if contents is a nul-terminated string

If a file called filename already exists it will be overwritten.

This write is atomic in the sense that it is first written to a temporary file which is then renamed to the final name. Notes:

1. On Unix, if filename already exists hard links to 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, the link itself will be replaced, not the linked file.
2. On Windows renaming a file will not remove an existing file with the new name, so on Windows there is a race condition between the existing file being removed and the temporary file being renamed.
3. 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.

If the call was not successful, an exception is thrown. Possible error codes are those in the FileError enumeration.

Since glibmm 2.22:

## ◆ file_set_contents() [2/2]

void Glib::file_set_contents | ( | const std::string & | filename,
|  | const std::string & | contents
| ) |  |

A variant of file_set_contents which accepts a standard C++ string.

Since glibmm 2.22:

## ◆ get_init_to_users_preferred_locale()

bool Glib::get_init_to_users_preferred_locale | ( |  | ) |

Get the state, set with set_init_to_users_preferred_locale().

Returns
  The state, set with set_init_to_users_preferred_locale(); `true` if set_init_to_users_preferred_locale() has not been called.

Since glibmm 2.58:

## ◆ get_unichar_from_std_iterator()

gunichar Glib::get_unichar_from_std_iterator | ( | std::string::const_iterator | pos | ) |

Extract a UCS-4 character from UTF-8 data.

Convert a single UTF-8 (multibyte) character starting at `pos` to a UCS-4 wide character. This may read up to 6 bytes after the start position, depending on the UTF-8 character width. You have to make sure the source contains at least one valid UTF-8 character.

This is mainly used by the implementation of Glib::ustring::iterator, but it might be useful as utility function if you prefer using std::string even for UTF-8 encoding.

## ◆ init()

void Glib::init | ( |  | ) |

Initialize glibmm.

Call it before you use other parts of glibmm. You may call it more than once. Calls after the first one have no effect. Glib::init() sets the global locale as specified by set_init_to_users_preferred_locale().

You do not need to call Glib::init() if you are using Gtk::Application or Gio::init(), because they call Glib::init() for you.

See also
  set_init_to_users_preferred_locale()

Examples
  thread/dispatcher.cc.

## ◆ make_refptr_for_instance()

template <class T_CppObject >

RefPtr< T_CppObject > Glib::make_refptr_for_instance | ( | T_CppObject * | object | ) |

Create a RefPtr<> to an instance of any class that has reference() and unreference() methods, and whose destructor is noexcept (the default for destructors).

In gtkmm, that is anything derived from Glib::ObjectBase, such as Gdk::Pixbuf.

Normal application code should not need to use this. However, this is necessary when implementing create() methods for derived Glib::ObjectBase-derived (not Gtk::Widget-derived) classes, such as derived Gtk::TreeModels.

## ◆ set_init_to_users_preferred_locale()

void Glib::set_init_to_users_preferred_locale | ( | bool | state = `true` | ) |

Instruct Glib::init() which global locale to set.

To have the intended effect, this function must be called before init() is called. Not calling it has the same effect as calling it with state = `true`.

Note the confusing difference between C locale and "C" locale. The C locale is the locale used by C code, set by std::setlocale(LC_ALL, locale_name). The "C" locale is the classic locale, set by std::setlocale(LC_ALL, "C") or std::locale::global(std::locale::classic()). It's the default global locale in a C or C++ program.

In a mixed C and C++ program, like a program using glibmm, having the C global locale differ from std::locale::global() is error prone. Glib::init() tries to avoid that.

Parameters

  state | If `true`, init() will set the C and C++ global locale to the user's preferred locale (std::locale::global(std::locale(""))). The user's preferred locale is set in the program's environment, usually with the LANG environment variable. If `false`, init() will set the C++ global locale to the C global locale (std::locale::global(std::locale(std::setlocale(LC_ALL, nullptr)))).

Since glibmm 2.58:

## ◆ unwrap() [1/4]

template <class T >

const T::BaseObjectType * Glib::unwrap | ( | const Glib::RefPtr< const T > & | ptr | ) |
| inline

Get the underlying C instance from the C++ instance.

This is just like calling gobj(), but it does its own check for a NULL pointer.

## ◆ unwrap() [2/4]

template <class T >

T::BaseObjectType * Glib::unwrap | ( | const Glib::RefPtr< T > & | ptr | ) |
| inline

Get the underlying C instance from the C++ instance.

This is just like calling gobj(), but it does its own check for a NULL pointer.

## ◆ unwrap() [3/4]

template <class T >

const T::BaseObjectType * Glib::unwrap | ( | const T * | ptr | ) |
| inline

Get the underlying C instance from the C++ instance.

This is just like calling gobj(), but it does its own check for a NULL pointer.

## ◆ unwrap() [4/4]

template <class T >

T::BaseObjectType * Glib::unwrap | ( | T * | ptr | ) |
| inline

Get the underlying C instance from the C++ instance.

This is just like calling gobj(), but it does its own check for a NULL pointer.

## ◆ unwrap_copy() [1/3]

template <class T >

const T::BaseObjectType * Glib::unwrap_copy | ( | const Glib::RefPtr< const T > & | ptr | ) |
| inline

Get the underlying C instance from the C++ instance and acquire a reference.

This is just like calling gobj_copy(), but it does its own check for a NULL pointer.

## ◆ unwrap_copy() [2/3]

template <class T >

T::BaseObjectType * Glib::unwrap_copy | ( | const Glib::RefPtr< T > & | ptr | ) |
| inline

Get the underlying C instance from the C++ instance and acquire a reference.

This is just like calling gobj_copy(), but it does its own check for a NULL pointer.

## ◆ unwrap_copy() [3/3]

template <class T >

T::BaseObjectType * Glib::unwrap_copy | ( | const T & | obj | ) |
| inline

Get the underlying C instance from the C++ instance and acquire a reference or copy.

This is just like calling gobj_copy(), but it does its own check for a NULL pointer to the underlying C instance.

## ◆ usleep()

void Glib::usleep | ( | unsigned long | microseconds | ) |

Pauses the current thread for the given number of microseconds.

Examples
  thread/dispatcher.cc.

## ◆ wrap() [1/5]

Glib::RefPtr< Gio::Drive > Glib::wrap | ( | GDrive * | object,
|  | bool | take_copy
| ) |  |
| related

## ◆ wrap() [2/5]

Glib::RefPtr< Gio::File > Glib::wrap | ( | GFile * | object,
|  | bool | take_copy
| ) |  |
| related

## ◆ wrap() [3/5]

Glib::RefPtr< IOChannel > Glib::wrap | ( | GIOChannel * | gobject,
|  | bool | take_copy = `false`
| ) |  |

## ◆ wrap() [4/5]

Glib::RefPtr< Gio::Mount > Glib::wrap | ( | GMount * | object,
|  | bool | take_copy
| ) |  |
| related

## ◆ wrap() [5/5]

Glib::RefPtr< Gio::Volume > Glib::wrap | ( | GVolume * | object,
|  | bool | take_copy
| ) |  |
| related

## ◆ wrap_interface()

RefPtr< ObjectBase > Glib::wrap_interface | ( | GObject * | object,
|  | bool | take_copy = `false`
| ) |  |

## Variable Documentation

## ◆ VARIANT_TYPE_ANY

const VariantType Glib::VARIANT_TYPE_ANY
| extern

## ◆ VARIANT_TYPE_ARRAY

const VariantType Glib::VARIANT_TYPE_ARRAY
| extern

## ◆ VARIANT_TYPE_BASIC

const VariantType Glib::VARIANT_TYPE_BASIC
| extern

## ◆ VARIANT_TYPE_BOOL

const VariantType Glib::VARIANT_TYPE_BOOL
| extern

## ◆ VARIANT_TYPE_BYTE

const VariantType Glib::VARIANT_TYPE_BYTE
| extern

## ◆ VARIANT_TYPE_BYTESTRING

const VariantType Glib::VARIANT_TYPE_BYTESTRING
| extern

## ◆ VARIANT_TYPE_BYTESTRING_ARRAY

const VariantType Glib::VARIANT_TYPE_BYTESTRING_ARRAY
| extern

## ◆ VARIANT_TYPE_DICT_ENTRY

const VariantType Glib::VARIANT_TYPE_DICT_ENTRY
| extern

## ◆ VARIANT_TYPE_DICTIONARY

const VariantType Glib::VARIANT_TYPE_DICTIONARY
| extern

## ◆ VARIANT_TYPE_DOUBLE

const VariantType Glib::VARIANT_TYPE_DOUBLE
| extern

## ◆ VARIANT_TYPE_HANDLE

const VariantType Glib::VARIANT_TYPE_HANDLE
| extern

## ◆ VARIANT_TYPE_INT16

const VariantType Glib::VARIANT_TYPE_INT16
| extern

## ◆ VARIANT_TYPE_INT32

const VariantType Glib::VARIANT_TYPE_INT32
| extern

## ◆ VARIANT_TYPE_INT64

const VariantType Glib::VARIANT_TYPE_INT64
| extern

## ◆ VARIANT_TYPE_MAYBE

const VariantType Glib::VARIANT_TYPE_MAYBE
| extern

## ◆ VARIANT_TYPE_OBJECT_PATH

const VariantType Glib::VARIANT_TYPE_OBJECT_PATH
| extern

## ◆ VARIANT_TYPE_OBJECT_PATH_ARRAY

const VariantType Glib::VARIANT_TYPE_OBJECT_PATH_ARRAY
| extern

## ◆ VARIANT_TYPE_SIGNATURE

const VariantType Glib::VARIANT_TYPE_SIGNATURE
| extern

## ◆ VARIANT_TYPE_STRING

const VariantType Glib::VARIANT_TYPE_STRING
| extern

## ◆ VARIANT_TYPE_STRING_ARRAY

const VariantType Glib::VARIANT_TYPE_STRING_ARRAY
| extern

## ◆ VARIANT_TYPE_TUPLE

const VariantType Glib::VARIANT_TYPE_TUPLE
| extern

## ◆ VARIANT_TYPE_UINT16

const VariantType Glib::VARIANT_TYPE_UINT16
| extern

## ◆ VARIANT_TYPE_UINT32

const VariantType Glib::VARIANT_TYPE_UINT32
| extern

## ◆ VARIANT_TYPE_UINT64

const VariantType Glib::VARIANT_TYPE_UINT64
| extern

## ◆ VARIANT_TYPE_UNIT

const VariantType Glib::VARIANT_TYPE_UNIT
| extern

## ◆ VARIANT_TYPE_VARIANT

const VariantType Glib::VARIANT_TYPE_VARIANT
| extern