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

Namespaces

namespace  Ascii
 
namespace  Base64
 
namespace  Container_Helpers
 
namespace  Markup
 
namespace  Threads
 
namespace  Unicode
 

Classes

class  ArrayHandle
 This is an intermediate type. More...
 
class  ArrayHandle< bool, Container_Helpers::TypeTraits< bool > >
 
class  ArrayHandler
 A utility for converting between std::vector and plain C arrays. More...
 
class  ArrayHandler< bool >
 
class  BalancedTree
 Balanced Binary Trees — a sorted collection of key/value pairs optimized for searching and traversing in order. More...
 
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  Cond
 An opaque data structure to represent a condition. 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  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  Error
 
class  Exception
 
class  ExtraClassInit
 A convenience class for named custom types. More...
 
class  FileError
 Exception class for file-related errors. More...
 
class  HelperList
 
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  ListHandle
 This is an intermediate type. 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 These functions provide a portable way to dynamically load object files (commonly known as 'plug-ins'). More...
 
class  Mutex
 Represents a mutex (mutual exclusion). 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  Private
 Thread-local data pointer. More...
 
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  RecMutex
 
class  RefPtr
 RefPtr<> is a reference-counting shared smartpointer. More...
 
class  Regex
 Perl-compatible regular expressions - matches strings against regular expressions. More...
 
class  RegexError
 Exception class for Regex More...
 
class  RWLock
 
class  Sequence
 Utility class holding an iterator sequence. More...
 
class  ShellError
 Exception class for shell utility errors. More...
 
class  SignalChildWatch
 
class  SignalIdle
 
class  SignalIO
 
class  SignalProxy
 Proxy for signals with any number of arguments. More...
 
class  SignalProxyBase
 
class  SignalProxyDetailed
 The SignalProxy provides an API similar to sigc::signal that can be used to connect sigc::slots to glib signals. More...
 
class  SignalProxyDetailedAnyType
 Proxy for signals with any number of arguments and possibly a detailed name. 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  SListHandle
 This is an intermediate type. More...
 
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...
 
struct  StaticMutex
 Like Glib::Mutex, but can be defined at compile time. More...
 
struct  StaticPrivate
 Thread-local data pointer. More...
 
struct  StaticRecMutex
 Like Glib::RecMutex, but can be defined at compile time. More...
 
struct  StaticRWLock
 Like Glib::RWLock, but can be defined at compile time. More...
 
class  StdStringView
 Helper class to avoid unnecessary string copying in function calls. More...
 
class  StreamIOChannel
 
class  Thread
 Represents a running thread. More...
 
class  ThreadError
 Exception class for thread-related errors. More...
 
class  ThreadPool
 A pool of threads to execute work concurrently. More...
 
class  TimeoutSource
 
class  Timer
 Portable stop watch interface. More...
 
struct  TimeVal
 Glib::TimeVal is a wrapper around the glib structure GTimeVal. 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< char >
 
class  Value< const T * >
 Specialization for pointers to const instances of any type. More...
 
class  Value< double >
 
class  Value< float >
 
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 * >
 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  ValueArray
 A container structure to maintain an array of generic values. More...
 
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< 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< gint64 >
 Specialization of Glib::Variant containing a gint64 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< guint64 >
 Specialization of Glib::Variant containing a guint64 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< 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 VariantBase 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...
 
class  WeakRef
 WeakRef<> is a weak reference smartpointer. More...
 

Typedefs

using StringArrayHandle = ArrayHandle< Glib::ustring >
 If a method takes this as an argument, or has this as a return type, then you can use a standard container such as std::list<Glib::ustring> or std::vector<Glib::ustring>.
 
using SArray = Glib::ArrayHandle< Glib::ustring >
 
template<typename R >
using SignalProxy0 = SignalProxy< R >
 
template<typename R , typename T1 >
using SignalProxy1 = SignalProxy< R, T1 >
 
template<typename R , typename T1 , typename T2 >
using SignalProxy2 = SignalProxy< R, T1, T2 >
 
template<typename R , typename T1 , typename T2 , typename T3 >
using SignalProxy3 = SignalProxy< R, T1, T2, T3 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 >
using SignalProxy4 = SignalProxy< R, T1, T2, T3, T4 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
using SignalProxy5 = SignalProxy< R, T1, T2, T3, T4, T5 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
using SignalProxy6 = SignalProxy< R, T1, T2, T3, T4, T5, T6 >
 
template<typename R >
using SignalProxyDetailed0 = SignalProxyDetailedAnyType< R >
 
template<typename R , typename T1 >
using SignalProxyDetailed1 = SignalProxyDetailedAnyType< R, T1 >
 
template<typename R , typename T1 , typename T2 >
using SignalProxyDetailed2 = SignalProxyDetailedAnyType< R, T1, T2 >
 
template<typename R , typename T1 , typename T2 , typename T3 >
using SignalProxyDetailed3 = SignalProxyDetailedAnyType< R, T1, T2, T3 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 >
using SignalProxyDetailed4 = SignalProxyDetailedAnyType< R, T1, T2, T3, T4 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
using SignalProxyDetailed5 = SignalProxyDetailedAnyType< R, T1, T2, T3, T4, T5 >
 
template<typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
using SignalProxyDetailed6 = SignalProxyDetailedAnyType< R, T1, T2, T3, T4, T5, T6 >
 
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  BindingFlags {
  BINDING_DEFAULT = 0x0 ,
  BINDING_BIDIRECTIONAL = 1 << 0 ,
  BINDING_SYNC_CREATE = 1 << 1 ,
  BINDING_INVERT_BOOLEAN = 1 << 2
}
 
enum  ParamFlags {
  PARAM_READABLE = 1 << 0 ,
  PARAM_WRITABLE = 1 << 1 ,
  PARAM_READWRITE = 0x3 ,
  PARAM_CONSTRUCT = 1 << 2 ,
  PARAM_CONSTRUCT_ONLY = 1 << 3 ,
  PARAM_LAX_VALIDATION = 1 << 4 ,
  PARAM_STATIC_NAME = 1 << 5 ,
  PARAM_PRIVATE = 0x20 ,
  PARAM_STATIC_NICK = 1 << 6 ,
  PARAM_STATIC_BLURB = 1 << 7 ,
  PARAM_EXPLICIT_NOTIFY = 1 << 30 ,
  PARAM_DEPRECATED = (gint)(1u << 31)
}
 
enum  FileTest {
  FILE_TEST_IS_REGULAR = 1 << 0 ,
  FILE_TEST_IS_SYMLINK = 1 << 1 ,
  FILE_TEST_IS_DIR = 1 << 2 ,
  FILE_TEST_IS_EXECUTABLE = 1 << 3 ,
  FILE_TEST_EXISTS = 1 << 4
}
 
enum  SeekType {
  SEEK_TYPE_CUR ,
  SEEK_TYPE_SET ,
  SEEK_TYPE_END
}
 
enum  IOStatus {
  IO_STATUS_ERROR ,
  IO_STATUS_NORMAL ,
  IO_STATUS_EOF ,
  IO_STATUS_AGAIN
}
 
enum  IOFlags {
  IO_FLAG_APPEND = 1 << 0 ,
  IO_FLAG_NONBLOCK = 1 << 1 ,
  IO_FLAG_IS_READABLE = 1 << 2 ,
  IO_FLAG_IS_WRITABLE = 1 << 3 ,
  IO_FLAG_IS_WRITEABLE = 1 << 3 ,
  IO_FLAG_IS_SEEKABLE = 1 << 4 ,
  IO_FLAG_MASK = (1 << 5) - 1 ,
  IO_FLAG_GET_MASK = 0x1F ,
  IO_FLAG_SET_MASK = 0x3
}
 
enum  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
}
 
enum  KeyFileFlags {
  KEY_FILE_NONE = 0x0 ,
  KEY_FILE_KEEP_COMMENTS = 1 << 0 ,
  KEY_FILE_KEEP_TRANSLATIONS = 1 << 1
}
 
enum  UserDirectory {
  USER_DIRECTORY_DESKTOP ,
  USER_DIRECTORY_DOCUMENTS ,
  USER_DIRECTORY_DOWNLOAD ,
  USER_DIRECTORY_MUSIC ,
  USER_DIRECTORY_PICTURES ,
  USER_DIRECTORY_PUBLIC_SHARE ,
  USER_DIRECTORY_TEMPLATES ,
  USER_DIRECTORY_VIDEOS ,
  USER_N_DIRECTORIES
}
 
enum  FormatSizeFlags {
  FORMAT_SIZE_DEFAULT = 0x0 ,
  FORMAT_SIZE_LONG_FORMAT = 1 << 0 ,
  FORMAT_SIZE_IEC_UNITS = 1 << 1 ,
  FORMAT_SIZE_BITS = 1 << 2
}
 
enum  ModuleFlags {
  MODULE_BIND_LAZY = 1 << 0 ,
  MODULE_BIND_LOCAL = 1 << 1 ,
  MODULE_BIND_MASK = 0x03
}
 
enum  TraverseType {
  TRAVERSE_IN_ORDER = G_IN_ORDER ,
  TRAVERSE_PRE_ORDER = G_PRE_ORDER ,
  TRAVERSE_POST_ORDER = G_POST_ORDER ,
  TRAVERSE_LEVEL_ORDER = G_LEVEL_ORDER
}
 Specifies the type of traveral performed by methods such as NodeTree::_traverse() and NodeTree::find(). More...
 
enum  RegexCompileFlags {
  REGEX_CASELESS = 1 << 0 ,
  REGEX_MULTILINE = 1 << 1 ,
  REGEX_DOTALL = 1 << 2 ,
  REGEX_EXTENDED = 1 << 3 ,
  REGEX_ANCHORED = 1 << 4 ,
  REGEX_DOLLAR_ENDONLY = 1 << 5 ,
  REGEX_UNGREEDY = 1 << 9 ,
  REGEX_RAW = 1 << 11 ,
  REGEX_NO_AUTO_CAPTURE = 1 << 12 ,
  REGEX_OPTIMIZE = 1 << 13 ,
  REGEX_FIRSTLINE = 1 << 18 ,
  REGEX_DUPNAMES = 1 << 19 ,
  REGEX_NEWLINE_CR = 1 << 20 ,
  REGEX_NEWLINE_LF = 1 << 21 ,
  REGEX_NEWLINE_CRLF = 0x300000 ,
  REGEX_NEWLINE_ANYCRLF = 0x500000 ,
  REGEX_BSR_ANYCRLF = 1 << 23 ,
  REGEX_JAVASCRIPT_COMPAT = 1 << 25
}
 
enum  RegexMatchFlags {
  REGEX_MATCH_ANCHORED = 1 << 4 ,
  REGEX_MATCH_NOTBOL = 1 << 7 ,
  REGEX_MATCH_NOTEOL = 1 << 8 ,
  REGEX_MATCH_NOTEMPTY = 1 << 10 ,
  REGEX_MATCH_PARTIAL = 1 << 15 ,
  REGEX_MATCH_NEWLINE_CR = 1 << 20 ,
  REGEX_MATCH_NEWLINE_LF = 1 << 21 ,
  REGEX_MATCH_NEWLINE_CRLF = 0x300000 ,
  REGEX_MATCH_NEWLINE_ANY = 1 << 22 ,
  REGEX_MATCH_NEWLINE_ANYCRLF = 0x500000 ,
  REGEX_MATCH_BSR_ANYCRLF = 1 << 23 ,
  REGEX_MATCH_BSR_ANY = 1 << 24 ,
  REGEX_MATCH_PARTIAL_SOFT = 0x8000 ,
  REGEX_MATCH_PARTIAL_HARD = 1 << 27 ,
  REGEX_MATCH_NOTEMPTY_ATSTART = 1 << 28
}
 
enum  SpawnFlags {
  SPAWN_DEFAULT = 0x0 ,
  SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0 ,
  SPAWN_DO_NOT_REAP_CHILD = 1 << 1 ,
  SPAWN_SEARCH_PATH = 1 << 2 ,
  SPAWN_STDOUT_TO_DEV_NULL = 1 << 3 ,
  SPAWN_STDERR_TO_DEV_NULL = 1 << 4 ,
  SPAWN_CHILD_INHERITS_STDIN = 1 << 5 ,
  SPAWN_FILE_AND_ARGV_ZERO = 1 << 6 ,
  SPAWN_SEARCH_PATH_FROM_ENVP = 1 << 7 ,
  SPAWN_CLOEXEC_PIPES = 1 << 8
}
 
enum  ThreadPriority {
  THREAD_PRIORITY_LOW ,
  THREAD_PRIORITY_NORMAL ,
  THREAD_PRIORITY_HIGH ,
  THREAD_PRIORITY_URGENT
}
 
enum  NotLock { NOT_LOCK }
 
enum  TryLock { TRY_LOCK }
 
enum  TimeType {
  TIME_TYPE_STANDARD ,
  TIME_TYPE_DAYLIGHT ,
  TIME_TYPE_UNIVERSAL
}
 
enum  UnicodeType {
  UNICODE_CONTROL ,
  UNICODE_FORMAT ,
  UNICODE_UNASSIGNED ,
  UNICODE_PRIVATE_USE ,
  UNICODE_SURROGATE ,
  UNICODE_LOWERCASE_LETTER ,
  UNICODE_MODIFIER_LETTER ,
  UNICODE_OTHER_LETTER ,
  UNICODE_TITLECASE_LETTER ,
  UNICODE_UPPERCASE_LETTER ,
  UNICODE_SPACING_MARK ,
  UNICODE_ENCLOSING_MARK ,
  UNICODE_NON_SPACING_MARK ,
  UNICODE_DECIMAL_NUMBER ,
  UNICODE_LETTER_NUMBER ,
  UNICODE_OTHER_NUMBER ,
  UNICODE_CONNECT_PUNCTUATION ,
  UNICODE_DASH_PUNCTUATION ,
  UNICODE_CLOSE_PUNCTUATION ,
  UNICODE_FINAL_PUNCTUATION ,
  UNICODE_INITIAL_PUNCTUATION ,
  UNICODE_OTHER_PUNCTUATION ,
  UNICODE_OPEN_PUNCTUATION ,
  UNICODE_CURRENCY_SYMBOL ,
  UNICODE_MODIFIER_SYMBOL ,
  UNICODE_MATH_SYMBOL ,
  UNICODE_OTHER_SYMBOL ,
  UNICODE_LINE_SEPARATOR ,
  UNICODE_PARAGRAPH_SEPARATOR ,
  UNICODE_SPACE_SEPARATOR
}
 
enum  UnicodeBreakType {
  UNICODE_BREAK_MANDATORY ,
  UNICODE_BREAK_CARRIAGE_RETURN ,
  UNICODE_BREAK_LINE_FEED ,
  UNICODE_BREAK_COMBINING_MARK ,
  UNICODE_BREAK_SURROGATE ,
  UNICODE_BREAK_ZERO_WIDTH_SPACE ,
  UNICODE_BREAK_INSEPARABLE ,
  UNICODE_BREAK_NON_BREAKING_GLUE ,
  UNICODE_BREAK_CONTINGENT ,
  UNICODE_BREAK_SPACE ,
  UNICODE_BREAK_AFTER ,
  UNICODE_BREAK_BEFORE ,
  UNICODE_BREAK_BEFORE_AND_AFTER ,
  UNICODE_BREAK_HYPHEN ,
  UNICODE_BREAK_NON_STARTER ,
  UNICODE_BREAK_OPEN_PUNCTUATION ,
  UNICODE_BREAK_CLOSE_PUNCTUATION ,
  UNICODE_BREAK_QUOTATION ,
  UNICODE_BREAK_EXCLAMATION ,
  UNICODE_BREAK_IDEOGRAPHIC ,
  UNICODE_BREAK_NUMERIC ,
  UNICODE_BREAK_INFIX_SEPARATOR ,
  UNICODE_BREAK_SYMBOL ,
  UNICODE_BREAK_ALPHABETIC ,
  UNICODE_BREAK_PREFIX ,
  UNICODE_BREAK_POSTFIX ,
  UNICODE_BREAK_COMPLEX_CONTEXT ,
  UNICODE_BREAK_AMBIGUOUS ,
  UNICODE_BREAK_UNKNOWN ,
  UNICODE_BREAK_NEXT_LINE ,
  UNICODE_BREAK_WORD_JOINER ,
  UNICODE_BREAK_HANGUL_L_JAMO ,
  UNICODE_BREAK_HANGUL_V_JAMO ,
  UNICODE_BREAK_HANGUL_T_JAMO ,
  UNICODE_BREAK_HANGUL_LV_SYLLABLE ,
  UNICODE_BREAK_HANGUL_LVT_SYLLABLE ,
  UNICODE_BREAK_CLOSE_PARANTHESIS ,
  UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER ,
  UNICODE_BREAK_HEBREW_LETTER ,
  UNICODE_BREAK_REGIONAL_INDICATOR ,
  UNICODE_BREAK_EMOJI_BASE ,
  UNICODE_BREAK_EMOJI_MODIFIER ,
  UNICODE_BREAK_ZERO_WIDTH_JOINER
}
 
enum  AsciiType {
  ASCII_ALNUM = 1 << 0 ,
  ASCII_ALPHA = 1 << 1 ,
  ASCII_CNTRL = 1 << 2 ,
  ASCII_DIGIT = 1 << 3 ,
  ASCII_GRAPH = 1 << 4 ,
  ASCII_LOWER = 1 << 5 ,
  ASCII_PRINT = 1 << 6 ,
  ASCII_PUNCT = 1 << 7 ,
  ASCII_SPACE = 1 << 8 ,
  ASCII_UPPER = 1 << 9 ,
  ASCII_XDIGIT = 1 << 10
}
 
enum  NormalizeMode {
  NORMALIZE_DEFAULT ,
  NORMALIZE_NFD = NORMALIZE_DEFAULT ,
  NORMALIZE_DEFAULT_COMPOSE ,
  NORMALIZE_NFC = NORMALIZE_DEFAULT_COMPOSE ,
  NORMALIZE_ALL ,
  NORMALIZE_NFKD = NORMALIZE_ALL ,
  NORMALIZE_ALL_COMPOSE ,
  NORMALIZE_NFKC = NORMALIZE_ALL_COMPOSE
}
 

Functions

template<class Iterator >
Sequence< Iterator > sequence (Iterator pbegin, Iterator pend)
 Helper function to create a Glib::Sequence<> object, which in turn can be used to initialize a container handle.
 
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.
 
RefPtr< ObjectBasewrap_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)
 
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.
 
BindingFlags operator| (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags operator& (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags operator^ (BindingFlags lhs, BindingFlags rhs)
 
BindingFlags operator~ (BindingFlags flags)
 
BindingFlagsoperator|= (BindingFlags & lhs, BindingFlags rhs)
 
BindingFlagsoperator&= (BindingFlags & lhs, BindingFlags rhs)
 
BindingFlagsoperator^= (BindingFlags & lhs, BindingFlags rhs)
 
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.
 
ParamFlags operator| (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags operator& (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags operator^ (ParamFlags lhs, ParamFlags rhs)
 
ParamFlags operator~ (ParamFlags flags)
 
ParamFlagsoperator|= (ParamFlags & lhs, ParamFlags rhs)
 
ParamFlagsoperator&= (ParamFlags & lhs, ParamFlags rhs)
 
ParamFlagsoperator^= (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)
 
FileTestoperator|= (FileTest & lhs, FileTest rhs)
 
FileTestoperator&= (FileTest & lhs, FileTest rhs)
 
FileTestoperator^= (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)
 
IOFlagsoperator|= (IOFlags & lhs, IOFlags rhs)
 
IOFlagsoperator&= (IOFlags & lhs, IOFlags rhs)
 
IOFlagsoperator^= (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)
 
IOConditionoperator|= (IOCondition & lhs, IOCondition rhs)
 
IOConditionoperator&= (IOCondition & lhs, IOCondition rhs)
 
IOConditionoperator^= (IOCondition & lhs, IOCondition rhs)
 
Glib::RefPtr< IOChannelwrap (GIOChannel * gobject, bool take_copy=false)
 
KeyFileFlags operator| (KeyFileFlags lhs, KeyFileFlags rhs)
 
KeyFileFlags operator& (KeyFileFlags lhs, KeyFileFlags rhs)
 
KeyFileFlags operator^ (KeyFileFlags lhs, KeyFileFlags rhs)
 
KeyFileFlags operator~ (KeyFileFlags flags)
 
KeyFileFlagsoperator|= (KeyFileFlags & lhs, KeyFileFlags rhs)
 
KeyFileFlagsoperator&= (KeyFileFlags & lhs, KeyFileFlags rhs)
 
KeyFileFlagsoperator^= (KeyFileFlags & lhs, KeyFileFlags rhs)
 
FormatSizeFlags operator| (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags operator& (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags operator^ (FormatSizeFlags lhs, FormatSizeFlags rhs)
 
FormatSizeFlags operator~ (FormatSizeFlags flags)
 
FormatSizeFlagsoperator|= (FormatSizeFlags & lhs, FormatSizeFlags rhs)
 
FormatSizeFlagsoperator&= (FormatSizeFlags & lhs, FormatSizeFlags rhs)
 
FormatSizeFlagsoperator^= (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 (const Glib::ustring & application_name)
 Sets a human-readable name for the application.
 
std::string get_prgname ()
 Gets the name of the program.
 
void set_prgname (const std::string & prgname)
 Sets the name of the program.
 
std::string getenv (const std::string & variable, bool & found)
 Returns the value of an environment variable.
 
std::string getenv (const std::string & variable)
 Returns the value of an environment variable.
 
bool setenv (const std::string & variable, const std::string & value, bool overwrite=true)
 Sets an environment variable.
 
void unsetenv (const std::string & variable)
 Removes an environment variable from the environment.
 
Glib::ArrayHandle< std::stringlistenv ()
 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 (GUserDirectory directory)
 Returns the full path of a special directory using its logical id.
 
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::stringget_system_data_dirs ()
 Returns an ordered list of base directories in which to access system-wide application data.
 
std::vector< std::stringget_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 (const std::string & 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 (const std::string & 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 (const std::string & filename)
 Gets the name of the file without any leading directory components.
 
std::string path_get_dirname (const std::string & 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 Glib::ArrayHandle< std::string > & elements)
 Creates a filename from a series of elements using the correct separator for filenames.
 
template<typename String1 , typename String2 , typename... Strings>
std::string build_filename (const String1 & elem1, const String2 & elem2, const Strings &... strings)
 Creates a filename from two or more elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2)
 Creates a filename from two elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3)
 Creates a filename from three elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4)
 Creates a filename from four elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4, const std::string & elem5)
 Creates a filename from five elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4, const std::string & elem5, const std::string & elem6)
 Creates a filename from six elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4, const std::string & elem5, const std::string & elem6, const std::string & elem7)
 Creates a filename from seven elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4, const std::string & elem5, const std::string & elem6, const std::string & elem7, const std::string & elem8)
 Creates a filename from eight elements using the correct separator for filenames.
 
std::string build_filename (const std::string & elem1, const std::string & elem2, const std::string & elem3, const std::string & elem4, const std::string & elem5, const std::string & elem6, const std::string & elem7, const std::string & elem8, const std::string & elem9)
 Creates a filename from nine elements using the correct separator for filenames.
 
std::string build_path (const std::string & separator, const Glib::ArrayHandle< std::string > & elements)
 Creates a path from a series of elements using separator as the separator between elements.
 
std::string find_program_in_path (const std::string & 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=FORMAT_SIZE_DEFAULT)
 Formats a size (for example the size of a file) into a human readable string.
 
ModuleFlags operator| (ModuleFlags lhs, ModuleFlags rhs)
 
ModuleFlags operator& (ModuleFlags lhs, ModuleFlags rhs)
 
ModuleFlags operator^ (ModuleFlags lhs, ModuleFlags rhs)
 
ModuleFlags operator~ (ModuleFlags flags)
 
ModuleFlagsoperator|= (ModuleFlags & lhs, ModuleFlags rhs)
 
ModuleFlagsoperator&= (ModuleFlags & lhs, ModuleFlags rhs)
 
ModuleFlagsoperator^= (ModuleFlags & lhs, ModuleFlags rhs)
 
RegexCompileFlags operator| (RegexCompileFlags lhs, RegexCompileFlags rhs)
 
RegexCompileFlags operator& (RegexCompileFlags lhs, RegexCompileFlags rhs)
 
RegexCompileFlags operator^ (RegexCompileFlags lhs, RegexCompileFlags rhs)
 
RegexCompileFlags operator~ (RegexCompileFlags flags)
 
RegexCompileFlagsoperator|= (RegexCompileFlags & lhs, RegexCompileFlags rhs)
 
RegexCompileFlagsoperator&= (RegexCompileFlags & lhs, RegexCompileFlags rhs)
 
RegexCompileFlagsoperator^= (RegexCompileFlags & lhs, RegexCompileFlags rhs)
 
RegexMatchFlags operator| (RegexMatchFlags lhs, RegexMatchFlags rhs)
 
RegexMatchFlags operator& (RegexMatchFlags lhs, RegexMatchFlags rhs)
 
RegexMatchFlags operator^ (RegexMatchFlags lhs, RegexMatchFlags rhs)
 
RegexMatchFlags operator~ (RegexMatchFlags flags)
 
RegexMatchFlagsoperator|= (RegexMatchFlags & lhs, RegexMatchFlags rhs)
 
RegexMatchFlagsoperator&= (RegexMatchFlags & lhs, RegexMatchFlags rhs)
 
RegexMatchFlagsoperator^= (RegexMatchFlags & lhs, RegexMatchFlags rhs)
 
Glib::ArrayHandle< std::stringshell_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)
 
SpawnFlagsoperator|= (SpawnFlags & lhs, SpawnFlags rhs)
 
SpawnFlagsoperator&= (SpawnFlags & lhs, SpawnFlags rhs)
 
SpawnFlagsoperator^= (SpawnFlags & lhs, SpawnFlags rhs)
 
void spawn_async_with_pipes (const std::string & working_directory, const Glib::ArrayHandle< std::string > & argv, const Glib::ArrayHandle< std::string > & envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), 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 Glib::ArrayHandle< std::string > & argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), 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 Glib::ArrayHandle< std::string > & argv, const Glib::ArrayHandle< std::string > & envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), Pid * child_pid=nullptr)
 See spawn_async_with_pipes() for a full description.
 
void spawn_async (const std::string & working_directory, const Glib::ArrayHandle< std::string > & argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), 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 Glib::ArrayHandle< std::string > & argv, const Glib::ArrayHandle< std::string > & envp, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), std::string * standard_output=nullptr, std::string * standard_error=nullptr, int * exit_status=nullptr)
 Executes a child synchronously (waits for the child to exit before returning).
 
void spawn_sync (const std::string & working_directory, const Glib::ArrayHandle< std::string > & argv, SpawnFlags flags=SPAWN_DEFAULT, const SlotSpawnChildSetup & child_setup=SlotSpawnChildSetup(), std::string * standard_output=nullptr, std::string * standard_error=nullptr, int * exit_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 * exit_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.
 
void thread_init (GThreadFunctions * vtable=nullptr)
 Initializes the GLib thread system.
 
bool thread_supported ()
 Returns whether the thread system is initialized.
 
AsciiType operator| (AsciiType lhs, AsciiType rhs)
 
AsciiType operator& (AsciiType lhs, AsciiType rhs)
 
AsciiType operator^ (AsciiType lhs, AsciiType rhs)
 
AsciiType operator~ (AsciiType flags)
 
AsciiTypeoperator|= (AsciiType & lhs, AsciiType rhs)
 
AsciiTypeoperator&= (AsciiType & lhs, AsciiType rhs)
 
AsciiTypeoperator^= (AsciiType & lhs, AsciiType rhs)
 
std::string uri_unescape_string (const std::string & escaped_string, const std::string & illegal_characters=std::string())
 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=std::string(), bool allow_utf8=true)
 Escapes a string for use in a URI.
 
template<>
Variant< Glib::ustringVariantBase::cast_dynamic< Variant< Glib::ustring > > (const VariantBase & v)
 
template<>
Variant< std::stringVariantBase::cast_dynamic< Variant< std::string > > (const VariantBase & v)
 
Glib::RefPtr< Gio::Drivewrap (GDrive * object, bool take_copy)
 
Glib::RefPtr< Gio::Filewrap (GFile * object, bool take_copy)
 
Glib::RefPtr< Gio::Mountwrap (GMount * object, bool take_copy)
 
Glib::RefPtr< Gio::Volumewrap (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

◆ SArray

Deprecated:
Use a std::vector instead.

◆ SignalProxy0

template <typename R >
using Glib::SignalProxy0 = typedef SignalProxy<R>

◆ SignalProxy1

template <typename R , typename T1 >
using Glib::SignalProxy1 = typedef SignalProxy<R, T1>

◆ SignalProxy2

template <typename R , typename T1 , typename T2 >
using Glib::SignalProxy2 = typedef SignalProxy<R, T1, T2>

◆ SignalProxy3

template <typename R , typename T1 , typename T2 , typename T3 >
using Glib::SignalProxy3 = typedef SignalProxy<R, T1, T2, T3>

◆ SignalProxy4

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 >
using Glib::SignalProxy4 = typedef SignalProxy<R, T1, T2, T3, T4>

◆ SignalProxy5

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
using Glib::SignalProxy5 = typedef SignalProxy<R, T1, T2, T3, T4, T5>

◆ SignalProxy6

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
using Glib::SignalProxy6 = typedef SignalProxy<R, T1, T2, T3, T4, T5, T6>

◆ SignalProxyDetailed0

template <typename R >
using Glib::SignalProxyDetailed0 = typedef SignalProxyDetailedAnyType<R>

◆ SignalProxyDetailed1

template <typename R , typename T1 >
using Glib::SignalProxyDetailed1 = typedef SignalProxyDetailedAnyType<R, T1>

◆ SignalProxyDetailed2

template <typename R , typename T1 , typename T2 >
using Glib::SignalProxyDetailed2 = typedef SignalProxyDetailedAnyType<R, T1, T2>

◆ SignalProxyDetailed3

template <typename R , typename T1 , typename T2 , typename T3 >
using Glib::SignalProxyDetailed3 = typedef SignalProxyDetailedAnyType<R, T1, T2, T3>

◆ SignalProxyDetailed4

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 >
using Glib::SignalProxyDetailed4 = typedef SignalProxyDetailedAnyType<R, T1, T2, T3, T4>

◆ SignalProxyDetailed5

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
using Glib::SignalProxyDetailed5 = typedef SignalProxyDetailedAnyType<R, T1, T2, T3, T4, T5>

◆ SignalProxyDetailed6

template <typename R , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
using Glib::SignalProxyDetailed6 = typedef SignalProxyDetailedAnyType<R, T1, T2, T3, T4, T5, T6>

◆ 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+.

◆ BindingFlags

Enumerator
BINDING_DEFAULT 

The default binding; if the source property changes, the target property is updated with its value.

BINDING_BIDIRECTIONAL 

Bidirectional binding; if either the property of the source or the property of the target changes, the other is updated.

BINDING_SYNC_CREATE 

Synchronize the values of the source and target properties when creating the binding; the direction of the synchronization is always from the source to the target.

BINDING_INVERT_BOOLEAN 

If the two properties being bound are booleans, setting one to true will result in the other being set to false and vice versa.

This flag will only work for boolean properties, and cannot be used when passing custom transformation functions to g_object_bind_property_full().

◆ FileTest

Enumerator
FILE_TEST_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.

FILE_TEST_IS_SYMLINK 

true if the file is a symlink.

FILE_TEST_IS_DIR 

true if the file is a directory.

FILE_TEST_IS_EXECUTABLE 

true if the file is executable.

FILE_TEST_EXISTS 

true if the file exists.

It may or may not be a regular file.

◆ FormatSizeFlags

Enumerator
FORMAT_SIZE_DEFAULT 

Behave the same as g_format_size().

FORMAT_SIZE_LONG_FORMAT 

Include the exact number of bytes as part of the returned string.

For example, "45.6 kB (45,612 bytes)".

FORMAT_SIZE_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.

FORMAT_SIZE_BITS 

Set the size as a quantity in bits, rather than bytes, and return units in bits.

For example, ‘Mb’ rather than ‘MB’.

◆ IOCondition

Enumerator
IO_IN 

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::IO_OUT) != 0)
do_some_output();
@ IO_OUT
Data can be written (without blocking).
Definition iochannel.h:239

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

Enumerator
IO_FLAG_APPEND 

Turns on append mode, corresponds to O_APPEND (see the documentation of the UNIX open() syscall).

IO_FLAG_NONBLOCK 

Turns on nonblocking mode, corresponds to O_NONBLOCK/O_NDELAY (see the documentation of the UNIX open() syscall).

IO_FLAG_IS_READABLE 

Indicates that the io channel is readable.

This flag cannot be changed.

IO_FLAG_IS_WRITABLE 

Indicates that the io channel is writable.

This flag cannot be changed.

IO_FLAG_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.

IO_FLAG_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.

IO_FLAG_MASK 

The mask that specifies all the valid flags.

IO_FLAG_GET_MASK 

The mask of the flags that are returned from g_io_channel_get_flags().

IO_FLAG_SET_MASK 

The mask of the flags that the user can modify with g_io_channel_set_flags().

◆ IOStatus

Enumerator
IO_STATUS_ERROR 

An error occurred.

IO_STATUS_NORMAL 

Success.

IO_STATUS_EOF 

End of file.

IO_STATUS_AGAIN 

Resource temporarily unavailable.

◆ KeyFileFlags

Enumerator
KEY_FILE_NONE 

No flags, default behaviour.

KEY_FILE_KEEP_COMMENTS 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise all comments will be lost when the key file is written back.

KEY_FILE_KEEP_TRANSLATIONS 

Use this flag if you plan to write the (possibly modified) contents of the key file back to a file; otherwise only the translations for the current language will be written back.

◆ ModuleFlags

Enumerator
MODULE_BIND_LAZY 

Specifies that symbols are only resolved when needed.

The default action is to bind all symbols when the module is loaded.

MODULE_BIND_LOCAL 

Specifies that symbols in the module should not be added to the global name space.

The default action on most platforms is to place symbols in the module in the global name space, which may cause conflicts with existing symbols.

MODULE_BIND_MASK 

Mask for all flags.

◆ NormalizeMode

Enumerator
NORMALIZE_DEFAULT 

Standardize differences that do not affect the text content, such as the above-mentioned accent representation.

NORMALIZE_NFD 

Another name for NORMALIZE_DEFAULT.

NORMALIZE_DEFAULT_COMPOSE 

Like NORMALIZE_DEFAULT, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFC 

Another name for NORMALIZE_DEFAULT_COMPOSE.

NORMALIZE_ALL 

Beyond NORMALIZE_DEFAULT also standardize the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE).

Formatting information may be lost but for most text operations such characters should be considered the same.

NORMALIZE_NFKD 

Another name for NORMALIZE_ALL.

NORMALIZE_ALL_COMPOSE 

Like NORMALIZE_ALL, but with composed forms rather than a maximally decomposed form.

NORMALIZE_NFKC 

Another name for NORMALIZE_ALL_COMPOSE.

◆ NotLock

Deprecated:
Use Glib::Threads::NotLock instead.
Enumerator
NOT_LOCK 

◆ ParamFlags

Enumerator
PARAM_READABLE 

The parameter is readable.

PARAM_WRITABLE 

The parameter is writable.

PARAM_READWRITE 

Alias for PARAM_READABLE | PARAM_WRITABLE.

PARAM_CONSTRUCT 

The parameter will be set upon object construction.

PARAM_CONSTRUCT_ONLY 

The parameter can only be set upon object construction.

PARAM_LAX_VALIDATION 

Upon parameter conversion (see g_param_value_convert()) strict validation is not required.

PARAM_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:
PARAM_PRIVATE 

Internal.

PARAM_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:
PARAM_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:
PARAM_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:
PARAM_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:

◆ RegexCompileFlags

Enumerator
REGEX_CASELESS 

Letters in the pattern match both upper- and lowercase letters.

This option can be changed within a pattern by a "(?i)" option setting.

REGEX_MULTILINE 

By default, GRegex treats the strings as consisting of a single line of characters (even if it actually contains newlines).

The "start of line" metacharacter ("^") matches only at the start of the string, while the "end of line" metacharacter ("$") matches only at the end of the string, or before a terminating newline (unless REGEX_DOLLAR_ENDONLY is set). When REGEX_MULTILINE is set, the "start of line" and "end of line" constructs match immediately following or immediately before any newline in the string, respectively, as well as at the very start and end. This can be changed within a pattern by a "(?m)" option setting.

REGEX_DOTALL 

A dot metacharacter (".") in the pattern matches all characters, including newlines.

Without it, newlines are excluded. This option can be changed within a pattern by a ("?s") option setting.

REGEX_EXTENDED 

Whitespace data characters in the pattern are totally ignored except when escaped or inside a character class.

Whitespace does not include the VT character (code 11). In addition, characters between an unescaped "#" outside a character class and the next newline character, inclusive, are also ignored. This can be changed within a pattern by a "(?x)" option setting.

REGEX_ANCHORED 

The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched.

This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter.

REGEX_DOLLAR_ENDONLY 

A dollar metacharacter ("$") in the pattern matches only at the end of the string.

Without this option, a dollar also matches immediately before the final character if it is a newline (but not before any other newlines). This option is ignored if REGEX_MULTILINE is set.

REGEX_UNGREEDY 

Inverts the "greediness" of the quantifiers so that they are not greedy by default, but become greedy if followed by "?".

It can also be set by a "(?U)" option setting within the pattern.

REGEX_RAW 

Usually strings must be valid UTF-8 strings, using this flag they are considered as a raw sequence of bytes.

REGEX_NO_AUTO_CAPTURE 

Disables the use of numbered capturing parentheses in the pattern.

Any opening parenthesis that is not followed by "?" behaves as if it were followed by "?:" but named parentheses can still be used for capturing (and they acquire numbers in the usual way).

REGEX_OPTIMIZE 

Optimize the regular expression.

If the pattern will be used many times, then it may be worth the effort to optimize it to improve the speed of matches.

REGEX_FIRSTLINE 

Limits an unanchored pattern to match before (or at) the first newline.

Since glibmm 2.34:
REGEX_DUPNAMES 

Names used to identify capturing subpatterns need not be unique.

This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched.

REGEX_NEWLINE_CR 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character is '\r'.

REGEX_NEWLINE_LF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character is '\n'.

REGEX_NEWLINE_CRLF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character sequence is '\r\n'.

REGEX_NEWLINE_ANYCRLF 

Usually any newline character or character sequence is recognized.

If this option is set, the only recognized newline character sequences are '\r', '\n', and '\r\n'.

Since glibmm 2.34:
REGEX_BSR_ANYCRLF 

Usually any newline character or character sequence is recognised.

If this option is set, then "\\R" only recognizes the newline characters '\r', '\n' and '\r\n'.

Since glibmm 2.34:
REGEX_JAVASCRIPT_COMPAT 

Changes behaviour so that it is compatible with JavaScript rather than PCRE.

Since glibmm 2.34:

◆ RegexMatchFlags

Enumerator
REGEX_MATCH_ANCHORED 

The pattern is forced to be "anchored", that is, it is constrained to match only at the first matching point in the string that is being searched.

This effect can also be achieved by appropriate constructs in the pattern itself such as the "^" metacharacter.

REGEX_MATCH_NOTBOL 

Specifies that first character of the string is not the beginning of a line, so the circumflex metacharacter should not match before it.

Setting this without REGEX_MULTILINE (at compile time) causes circumflex never to match. This option affects only the behaviour of the circumflex metacharacter, it does not affect "\\A".

REGEX_MATCH_NOTEOL 

Specifies that the end of the subject string is not the end of a line, so the dollar metacharacter should not match it nor (except in multiline mode) a newline immediately before it.

Setting this without REGEX_MULTILINE (at compile time) causes dollar never to match. This option affects only the behaviour of the dollar metacharacter, it does not affect "\\Z" or "\\z".

REGEX_MATCH_NOTEMPTY 

An empty string is not considered to be a valid match if this option is set.

If there are alternatives in the pattern, they are tried. If all the alternatives match the empty string, the entire match fails. For example, if the pattern "a?b?" is applied to a string not beginning with "a" or "b", it matches the empty string at the start of the string. With this flag set, this match is not valid, so GRegex searches further into the string for occurrences of "a" or "b".

REGEX_MATCH_PARTIAL 

Turns on the partial matching feature, for more documentation on partial matching see g_match_info_is_partial_match().

REGEX_MATCH_NEWLINE_CR 

Overrides the newline definition set when creating a new Regex, setting the '\r' character as line terminator.

REGEX_MATCH_NEWLINE_LF 

Overrides the newline definition set when creating a new Regex, setting the '\n' character as line terminator.

REGEX_MATCH_NEWLINE_CRLF 

Overrides the newline definition set when creating a new Regex, setting the '\r\n' characters sequence as line terminator.

REGEX_MATCH_NEWLINE_ANY 

Overrides the newline definition set when creating a new Regex, any Unicode newline sequence is recognised as a newline.

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

REGEX_MATCH_NEWLINE_ANYCRLF 

Overrides the newline definition set when creating a new Regex; any '\r', '\n', or '\r\n' character sequence is recognized as a newline.

Since glibmm 2.34:
REGEX_MATCH_BSR_ANYCRLF 

Overrides the newline definition for "\\R" set when creating a new Regex; only '\r', '\n', or '\r\n' character sequences are recognized as a newline by "\\R".

Since glibmm 2.34:
REGEX_MATCH_BSR_ANY 

Overrides the newline definition for "\\R" set when creating a new Regex; any Unicode newline character or character sequence are recognized as a newline by "\\R".

These are '\r', '\n' and '\rn', and the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR.

Since glibmm 2.34:
REGEX_MATCH_PARTIAL_SOFT 

An alias for REGEX_MATCH_PARTIAL.

Since glibmm 2.34:
REGEX_MATCH_PARTIAL_HARD 

Turns on the partial matching feature.

In contrast to to REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match is found, without continuing to search for a possible complete match. See g_match_info_is_partial_match() for more information.

Since glibmm 2.34:
REGEX_MATCH_NOTEMPTY_ATSTART 

Like REGEX_MATCH_NOTEMPTY, but only applied to the start of the matched string.

For anchored patterns this can only happen for pattern containing "\\K".

Since glibmm 2.34:

◆ SeekType

Enumerator
SEEK_TYPE_CUR 

The current position in the file.

SEEK_TYPE_SET 

The start of the file.

SEEK_TYPE_END 

The end of the file.

◆ SpawnFlags

Enumerator
SPAWN_DEFAULT 

No flags, default behaviour.

SPAWN_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.

SPAWN_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.

SPAWN_SEARCH_PATH 

argv[0] need not be an absolute path, it will be looked for in the user's PATH.

SPAWN_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.

SPAWN_STDERR_TO_DEV_NULL 

The child's standard error will be discarded.

SPAWN_CHILD_INHERITS_STDIN 

The child will inherit the parent's standard input (by default, the child's standard input is attached to /dev/null).

SPAWN_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.

SPAWN_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:
SPAWN_CLOEXEC_PIPES 

Create all pipes with the O_CLOEXEC flag set.

Since glibmm 2.40:

◆ ThreadPriority

Enumerator
THREAD_PRIORITY_LOW 
Deprecated:

Thread priorities no longer have any effect.

A priority lower than normal.

A priority lower than normal.

THREAD_PRIORITY_NORMAL 

The default priority.

The default priority.

THREAD_PRIORITY_HIGH 

A priority higher than normal.

A priority higher than normal.

THREAD_PRIORITY_URGENT 

The highest priority.

The highest priority.

◆ TimeType

Enumerator
TIME_TYPE_STANDARD 

The time is in local standard time.

TIME_TYPE_DAYLIGHT 

The time is in local daylight time.

TIME_TYPE_UNIVERSAL 

The time is in UTC.

◆ TryLock

Deprecated:
Use Glib::Threads::TryLock instead.
Enumerator
TRY_LOCK 

◆ UnicodeBreakType

Enumerator
UNICODE_BREAK_MANDATORY 

Mandatory Break (BK).

UNICODE_BREAK_CARRIAGE_RETURN 

Carriage Return (CR).

UNICODE_BREAK_LINE_FEED 

Line Feed (LF).

UNICODE_BREAK_COMBINING_MARK 

Attached Characters and Combining Marks (CM).

UNICODE_BREAK_SURROGATE 

Surrogates (SG).

UNICODE_BREAK_ZERO_WIDTH_SPACE 

Zero Width Space (ZW).

UNICODE_BREAK_INSEPARABLE 

Inseparable (IN).

UNICODE_BREAK_NON_BREAKING_GLUE 

Non-breaking ("Glue") (GL).

UNICODE_BREAK_CONTINGENT 

Contingent Break Opportunity (CB).

UNICODE_BREAK_SPACE 

Space (SP).

UNICODE_BREAK_AFTER 

Break Opportunity After (BA).

UNICODE_BREAK_BEFORE 

Break Opportunity Before (BB).

UNICODE_BREAK_BEFORE_AND_AFTER 

Break Opportunity Before and After (B2).

UNICODE_BREAK_HYPHEN 

Hyphen (HY).

UNICODE_BREAK_NON_STARTER 

Nonstarter (NS).

UNICODE_BREAK_OPEN_PUNCTUATION 

Opening Punctuation (OP).

UNICODE_BREAK_CLOSE_PUNCTUATION 

Closing Punctuation (CL).

UNICODE_BREAK_QUOTATION 

Ambiguous Quotation (QU).

UNICODE_BREAK_EXCLAMATION 

Exclamation/Interrogation (EX).

UNICODE_BREAK_IDEOGRAPHIC 

Ideographic (ID).

UNICODE_BREAK_NUMERIC 

Numeric (NU).

UNICODE_BREAK_INFIX_SEPARATOR 

Infix Separator (Numeric) (IS).

UNICODE_BREAK_SYMBOL 

Symbols Allowing Break After (SY).

UNICODE_BREAK_ALPHABETIC 

Ordinary Alphabetic and Symbol Characters (AL).

UNICODE_BREAK_PREFIX 

Prefix (Numeric) (PR).

UNICODE_BREAK_POSTFIX 

Postfix (Numeric) (PO).

UNICODE_BREAK_COMPLEX_CONTEXT 

Complex Content Dependent (South East Asian) (SA).

UNICODE_BREAK_AMBIGUOUS 

Ambiguous (Alphabetic or Ideographic) (AI).

UNICODE_BREAK_UNKNOWN 

Unknown (XX).

UNICODE_BREAK_NEXT_LINE 

Next Line (NL).

UNICODE_BREAK_WORD_JOINER 

Word Joiner (WJ).

UNICODE_BREAK_HANGUL_L_JAMO 

Hangul L Jamo (JL).

UNICODE_BREAK_HANGUL_V_JAMO 

Hangul V Jamo (JV).

UNICODE_BREAK_HANGUL_T_JAMO 

Hangul T Jamo (JT).

UNICODE_BREAK_HANGUL_LV_SYLLABLE 

Hangul LV Syllable (H2).

UNICODE_BREAK_HANGUL_LVT_SYLLABLE 

Hangul LVT Syllable (H3).

UNICODE_BREAK_CLOSE_PARANTHESIS 

Closing Parenthesis (CP).

Since glibmm 2.28:
UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER 

Conditional Japanese Starter (CJ).

Since glibmm 2.32:
UNICODE_BREAK_HEBREW_LETTER 

Hebrew Letter (HL).

Since glibmm 2.32:
UNICODE_BREAK_REGIONAL_INDICATOR 

Regional Indicator (RI).

Since glibmm 2.36:
UNICODE_BREAK_EMOJI_BASE 

Emoji Base (EB).

Since glibmm 2.50:
UNICODE_BREAK_EMOJI_MODIFIER 

Emoji Modifier (EM).

Since glibmm 2.50:
UNICODE_BREAK_ZERO_WIDTH_JOINER 

Zero Width Joiner (ZWJ).

Since glibmm 2.50:

◆ UnicodeType

Enumerator
UNICODE_CONTROL 

General category "Other, Control" (Cc).

UNICODE_FORMAT 

General category "Other, Format" (Cf).

UNICODE_UNASSIGNED 

General category "Other, Not Assigned" (Cn).

UNICODE_PRIVATE_USE 

General category "Other, Private Use" (Co).

UNICODE_SURROGATE 

General category "Other, Surrogate" (Cs).

UNICODE_LOWERCASE_LETTER 

General category "Letter, Lowercase" (Ll).

UNICODE_MODIFIER_LETTER 

General category "Letter, Modifier" (Lm).

UNICODE_OTHER_LETTER 

General category "Letter, Other" (Lo).

UNICODE_TITLECASE_LETTER 

General category "Letter, Titlecase" (Lt).

UNICODE_UPPERCASE_LETTER 

General category "Letter, Uppercase" (Lu).

UNICODE_SPACING_MARK 

General category "Mark, Spacing" (Mc).

UNICODE_ENCLOSING_MARK 

General category "Mark, Enclosing" (Me).

UNICODE_NON_SPACING_MARK 

General category "Mark, Nonspacing" (Mn).

UNICODE_DECIMAL_NUMBER 

General category "Number, Decimal Digit" (Nd).

UNICODE_LETTER_NUMBER 

General category "Number, Letter" (Nl).

UNICODE_OTHER_NUMBER 

General category "Number, Other" (No).

UNICODE_CONNECT_PUNCTUATION 

General category "Punctuation, Connector" (Pc).

UNICODE_DASH_PUNCTUATION 

General category "Punctuation, Dash" (Pd).

UNICODE_CLOSE_PUNCTUATION 

General category "Punctuation, Close" (Pe).

UNICODE_FINAL_PUNCTUATION 

General category "Punctuation, Final quote" (Pf).

UNICODE_INITIAL_PUNCTUATION 

General category "Punctuation, Initial quote" (Pi).

UNICODE_OTHER_PUNCTUATION 

General category "Punctuation, Other" (Po).

UNICODE_OPEN_PUNCTUATION 

General category "Punctuation, Open" (Ps).

UNICODE_CURRENCY_SYMBOL 

General category "Symbol, Currency" (Sc).

UNICODE_MODIFIER_SYMBOL 

General category "Symbol, Modifier" (Sk).

UNICODE_MATH_SYMBOL 

General category "Symbol, Math" (Sm).

UNICODE_OTHER_SYMBOL 

General category "Symbol, Other" (So).

UNICODE_LINE_SEPARATOR 

General category "Separator, Line" (Zl).

UNICODE_PARAGRAPH_SEPARATOR 

General category "Separator, Paragraph" (Zp).

UNICODE_SPACE_SEPARATOR 

General category "Separator, Space" (Zs).

◆ UserDirectory

Enumerator
USER_DIRECTORY_DESKTOP 

The user's Desktop directory.

USER_DIRECTORY_DOCUMENTS 

The user's Documents directory.

USER_DIRECTORY_DOWNLOAD 

The user's Downloads directory.

USER_DIRECTORY_MUSIC 

The user's Music directory.

USER_DIRECTORY_PICTURES 

The user's Pictures directory.

USER_DIRECTORY_PUBLIC_SHARE 

The user's shared directory.

USER_DIRECTORY_TEMPLATES 

The user's Templates directory.

USER_DIRECTORY_VIDEOS 

The user's Movies directory.

USER_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
filenamename of a file to write contents to, in the GLib file name encoding
contentsstring to write to the file
lengthlength 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_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.

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

Examples
thread/dispatcher.cc, and thread/thread.cc.

◆ thread_init()

void Glib::thread_init ( GThreadFunctions *  vtable = nullptr)

Initializes the GLib thread system.

Deprecated:
Calling thread_init() is no longer necessary and no longer has any effect.

◆ thread_supported()

bool Glib::thread_supported ( )

Returns whether the thread system is initialized.

Returns
true, if the thread system is initialized.
Deprecated:
This is no longer useful, because the thread system is always initialized.

◆ 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)

◆ VariantBase::cast_dynamic< Variant< Glib::ustring > >()

◆ VariantBase::cast_dynamic< Variant< std::string > >()

◆ 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