glibmm: Glib Namespace Reference

Namespaces

 Ascii
 
 Base64
 
 Container_Helpers
 
 Markup
 
 Traits
 
 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  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  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 These functions provide a portable way to dynamically load object files (commonly known as 'plug-ins'). 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::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< 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::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 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. More...

 
using TimeSpan = GTimeSpan
 A value representing an interval of time, in microseconds. More...

 
using Pid = GPid
 
using SlotSpawnChildSetup = sigc::slot< void()>
 For instance,

void on_child_setup();. More...

 

Enumerations

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). More...

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

 
void init ()
 Initialize glibmm. More...

 
void set_init_to_users_preferred_locale (bool state=true)
 Instruct Glib::init() which global locale to set. More...

 
bool get_init_to_users_preferred_locale ()
 Get the state, set with set_init_to_users_preferred_locale(). More...

 
RefPtr< ObjectBasewrap_interface (GObject* object, bool take_copy=false)
 
SignalTimeout signal_timeout ()
 Convenience timeout signal. More...

 
SignalIdle signal_idle ()
 Convenience idle signal. More...

 
SignalIO signal_io ()
 Convenience I/O signal. More...

 
SignalChildWatch signal_child_watch ()
 Convenience child watch signal. More...

 
bool str_has_prefix (const std::string& str, const std::string& prefix)
 Looks whether the string str begins with prefix. More...

 
bool str_has_suffix (const std::string& str, const std::string& suffix)
 Looks whether the string str ends with suffix. More...

 
std::string strescape (const std::string& source)
 Escapes all special characters in the string. More...

 
std::string strescape (const std::string& source, const std::string& exceptions)
 Escapes all special characters in the string. More...

 
std::string strcompress (const std::string& source)
 Replaces all escaped characters with their one byte equivalent. More...

 
Glib::ustring strerror (int errnum)
 Returns a string corresponding to the given error code, e.g. "no such process". More...

 
Glib::ustring strsignal (int signum)
 Returns a string describing the given signal, e.g. "Segmentation fault". More...

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

 
template<class T >
T::BaseObjectType* unwrap (T* ptr)
 Get the underlying C instance from the C++ instance. More...

 
template<class T >
const T::BaseObjectType* unwrap (const T* ptr)
 Get the underlying C instance from the C++ instance. More...

 
template<class T >
T::BaseObjectType* unwrap (const Glib::RefPtr< T >& ptr)
 Get the underlying C instance from the C++ instance. More...

 
template<class T >
const T::BaseObjectType* unwrap (const Glib::RefPtr< const T >& ptr)
 Get the underlying C instance from the C++ instance. More...

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

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

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

 
Binding::Flags operator| (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags operator& (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags operator^ (Binding::Flags lhs, Binding::Flags rhs)
 
Binding::Flags operator~ (Binding::Flags flags)
 
Binding::Flagsoperator|= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::Flagsoperator&= (Binding::Flags& lhs, Binding::Flags rhs)
 
Binding::Flagsoperator^= (Binding::Flags& lhs, Binding::Flags rhs)
 
bool get_charset ()
 Get the charset used by the current locale. More...

 
bool get_charset (std::string& charset)
 Get the charset used by the current locale. More...

 
std::string convert (const std::string& str, const std::string& to_codeset, const std::string& from_codeset)
 Convert from one encoding to another. More...

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

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

 
Glib::ustring locale_to_utf8 (const std::string& opsys_string)
 Convert from the current locale's encoding to UTF-8. More...

 
std::string locale_from_utf8 (const Glib::ustring& utf8_string)
 Convert from UTF-8 to the current locale's encoding. More...

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

 
std::string filename_from_utf8 (const Glib::ustring& utf8_string)
 Converts a string from UTF-8 to the encoding used for filenames. More...

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

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

 
Glib::ustring filename_to_uri (const std::string& filename, const Glib::ustring& hostname)
 Converts an absolute filename to an escaped UTF-8 encoded URI. More...

 
Glib::ustring filename_to_uri (const std::string& filename)
 Converts an absolute filename to an escaped UTF-8 encoded URI. More...

 
Glib::ustring filename_display_basename (const std::string& filename)
 Returns the display basename for the particular filename, guaranteed to be valid UTF-8. More...

 
Glib::ustring filename_display_name (const std::string& filename)
 Converts a filename into a valid UTF-8 string. More...

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

 
int mkstemp (std::string& filename_template)
 Opens a temporary file. More...

 
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()). More...

 
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()). More...

 
std::string file_get_contents (const std::string& filename)
 Reads an entire file into a string, with good error checking. More...

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

 
void file_set_contents (const std::string& filename, const std::string& contents)
 A variant of file_set_contents which accepts a standard C++ string. More...

 
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)
 
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::Flagsoperator|= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::Flagsoperator&= (KeyFile::Flags& lhs, KeyFile::Flags rhs)
 
KeyFile::Flagsoperator^= (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)
 
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(). More...

 
void set_application_name (UStringView application_name)
 Sets a human-readable name for the application. More...

 
std::string get_prgname ()
 Gets the name of the program. More...

 
void set_prgname (StdStringView prgname)
 Sets the name of the program. More...

 
std::string getenv (StdStringView variable, bool& found)
 Returns the value of an environment variable. More...

 
std::string getenv (StdStringView variable)
 Returns the value of an environment variable. More...

 
bool setenv (StdStringView variable, StdStringView value, bool overwrite=true)
 Sets an environment variable. More...

 
void unsetenv (StdStringView variable)
 Removes an environment variable from the environment. More...

 
std::vector< std::stringlistenv ()
 Gets the names of all variables set in the environment. More...

 
std::string get_user_name ()
 Gets the user name of the current user. More...

 
std::string get_real_name ()
 Gets the real name of the current user. More...

 
Glib::ustring get_host_name ()
 Return a name for the machine. More...

 
std::string get_home_dir ()
 Gets the current user's home directory. More...

 
std::string get_tmp_dir ()
 Gets the directory to use for temporary files. More...

 
std::string get_current_dir ()
 Gets the current directory. More...

 
std::string get_user_special_dir (UserDirectory directory)
 Returns the full path of a special directory using its logical id. More...

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

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

 
std::vector< std::stringget_system_data_dirs ()
 Returns an ordered list of base directories in which to access system-wide application data. More...

 
std::vector< std::stringget_system_config_dirs ()
 Returns an ordered list of base directories in which to access system-wide configuration information. More...

 
std::string get_user_cache_dir ()
 Returns a base directory in which to store non-essential, cached data specific to particular user. More...

 
std::string get_user_runtime_dir ()
 Returns a directory that is unique to the current user on the local system. More...

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

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

 
std::string path_get_basename (StdStringView filename)
 Gets the name of the file without any leading directory components. More...

 
std::string path_get_dirname (StdStringView filename)
 Gets the directory components of a file name. More...

 
std::string canonicalize_filename (StdStringView filename, StdStringView relative_to=nullptr)
 Gets the canonical file name from filename. More...

 
std::string build_filename (const std::vector< std::string >& elements)
 Creates a filename from a series of elements using the correct separator for filenames. More...

 
template<typename... Strings>
std::string build_filename (const Strings&...strings)
 Creates a filename from one or more elements using the correct separator for filenames. More...

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

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

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

 
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::Flagsoperator|= (Module::Flags& lhs, Module::Flags rhs)
 
Module::Flagsoperator&= (Module::Flags& lhs, Module::Flags rhs)
 
Module::Flagsoperator^= (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::Flagsoperator|= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flagsoperator&= (OptionEntry::Flags& lhs, OptionEntry::Flags rhs)
 
OptionEntry::Flagsoperator^= (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::CompileFlagsoperator|= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlagsoperator&= (Regex::CompileFlags& lhs, Regex::CompileFlags rhs)
 
Regex::CompileFlagsoperator^= (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::MatchFlagsoperator|= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlagsoperator&= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
Regex::MatchFlagsoperator^= (Regex::MatchFlags& lhs, Regex::MatchFlags rhs)
 
std::vector< 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). More...

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

 
std::string shell_unquote (const std::string& quoted_string)
 Unquotes a string as the shell (/bin/sh) would. More...

 
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 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). More...

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

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

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

 
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* exit_status=nullptr)
 Executes a child synchronously (waits for the child to exit before returning). More...

 
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* exit_status=nullptr)
 Like the main spawn_sync() method, but inheriting the parent's environment. More...

 
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(). More...

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

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

 
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={})
 Unescapes a whole escaped string. More...

 
std::string uri_parse_scheme (const std::string& uri)
 Gets the scheme portion of a URI. More...

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

 
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

using Glib::Pid = typedef GPid
template <class T_CppObject >
using Glib::RefPtr = typedef std::shared_ptr<T_CppObject>

RefPtr<> is a reference-counting shared smartpointer.

Some objects in gtkmm are obtained from a shared store. Consequently you cannot instantiate them yourself. Instead they return a RefPtr which behaves much like an ordinary pointer in that members can be reached with the usual object_ptr->member notation.

Reference counting means that a shared reference count is incremented each time a RefPtr is copied, and decremented each time a RefPtr is destroyed, for instance when it leaves its scope. When the reference count reaches zero, the contained object is deleted, meaning you don't need to remember to delete the object.

See the "Memory Management" section in the "Programming with gtkmm" book for further information.

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

Function Documentation

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.

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

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

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
stateIf 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:
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.

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.

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.

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.

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.

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.

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.

void Glib::usleep ( unsigned long  microseconds)
Glib::RefPtr<Gio::Volume> Glib::wrap ( GVolume *  object,
bool  take_copy 
)
related
Glib::RefPtr<Gio::Drive> Glib::wrap ( GDrive *  object,
bool  take_copy 
)
related
Glib::RefPtr<Gio::Mount> Glib::wrap ( GMount *  object,
bool  take_copy 
)
related
Glib::RefPtr<IOChannel> Glib::wrap ( GIOChannel *  gobject,
bool  take_copy = false 
)
Glib::RefPtr<Gio::File> Glib::wrap ( GFile *  object,
bool  take_copy 
)
related
RefPtr<ObjectBase> Glib::wrap_interface ( GObject *  object,
bool  take_copy = false 
)

Variable Documentation

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