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 ,   AKSARA ,   AKSARA_PRE_BASE ,   AKSARA_START ,   VIRAMA_FINAL ,   VIRAMA }
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.
std::wstring	wide_from_utf8 (const Glib::ustring &utf8_string)
	Converts from utf-8 encoding to wide character strings.
Glib::ustring	wide_to_utf8 (const std::wstring &wide_string)
	Converts from a wide character string to a utf-8 encoding.
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, ‘Mbit’ 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();

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:
AKSARA	Aksara (AK). Since: 2.80 G_UNICODE_BREAK_AKSARA_PRE_BASE (AP). Since: 2.80 G_UNICODE_BREAK_AKSARA_START (AS). Since: 2.80 G_UNICODE_BREAK_VIRAMA_FINAL (VF). Since: 2.80 G_UNICODE_BREAK_VIRAMA (VI). Since glibmm 2.80:
AKSARA_PRE_BASE
AKSARA_START
VIRAMA_FINAL
VIRAMA

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