logo top
Main Page   Widgets   Namespaces   Book  

Glib Namespace Reference


Classes

class  Glib::ArrayHandle<T, Tr>
 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 or std::vector. More...

class  Glib::Sequence<Iterator>
 Utility class holding an iterator sequence. More...

class  Glib::ConvertError
 Exception class for charset conversion errors. More...

class  Glib::IConv
 Thin iconv() wrapper. More...

class  Glib::Date
 Julian calendar date. More...

class  Glib::Dispatcher
 Signal class for inter-thread communication. More...

class  Glib::Error
class  Glib::Exception
class  Glib::FileError
 Exception class for file-related errors. More...

class  Glib::DirIterator
 The iterator type of Glib::Dir. More...

class  Glib::Dir
 Utility class representing an open directory. More...

class  Glib::HelperList<T_Child, T_CppElement, T_Iterator>
class  Glib::Interface
class  Glib::IOChannelError
 Exception class for IOChannel errors. More...

class  Glib::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  Glib::ListHandle<T, Tr>
class  Glib::PollFD
class  Glib::SignalTimeout
class  Glib::SignalIdle
class  Glib::SignalIO
class  Glib::MainContext
 Main context. More...

class  Glib::MainLoop
class  Glib::Source
class  Glib::TimeoutSource
class  Glib::IdleSource
class  Glib::IOSource
class  Glib::MarkupError
 Exception class for markup parsing errors. More...

class  Glib::Module
 Dynamic Loading of Modules These functions provide a portable way to dynamically load object files (commonly known as 'plug-ins'). More...

class  Glib::Object
class  Glib::ObjectBase
class  Glib::PatternSpec
class  Glib::PropertyBase
class  Glib::Property<T>
class  Glib::PropertyProxy<T>
 A PropertyProxy can be used to get and set the value of an object's property. More...

class  Glib::PropertyProxy_WriteOnly<T>
 See PropertyProxy(). More...

class  Glib::PropertyProxy_ReadOnly<T>
 See PropertyProxy(). More...

class  Glib::SignalProxyProperty
 Use the connect() method, with sigc::ptr_fun() or sig::mem_fun() to connect signals to signal handlers. More...

class  Glib::PropertyProxy_Base
class  Glib::QueryQuark
 Quarks are unique IDs in Glib for strings for use in hash table lookups. More...

class  Glib::Quark
class  Glib::Rand
class  Glib::RefPtr<T_CppObject>
 RefPtr<> is a reference-counting shared smartpointer. More...

class  Glib::ShellError
 Exception class for shell utility errors. More...

class  Glib::SignalProxyBase
class  Glib::SignalProxyNormal
class  Glib::SignalProxy0<R>
 Proxy for signals with 0 arguments. More...

class  Glib::SignalProxy1<R, P1>
 Proxy for signals with 1 arguments. More...

class  Glib::SignalProxy2<R, P1, P2>
 Proxy for signals with 2 arguments. More...

class  Glib::SignalProxy3<R, P1, P2, P3>
 Proxy for signals with 3 arguments. More...

class  Glib::SignalProxy4<R, P1, P2, P3, P4>
 Proxy for signals with 4 arguments. More...

class  Glib::SignalProxy5<R, P1, P2, P3, P4, P5>
 Proxy for signals with 5 arguments. More...

class  Glib::SignalProxy6<R, P1, P2, P3, P4, P5, P6>
 Proxy for signals with 6 arguments. More...

class  Glib::SignalProxyConnectionNode
 SignalProxyConnectionNode is a connection node for use with SignalProxy. More...

class  Glib::SListHandle<T, Tr>
class  Glib::SpawnError
 Exception class for errors occuring when spawning processes. More...

class  Glib::StreamIOChannel
 This whole class is deprecated in glibmm 2.2. More...

class  Glib::ThreadError
 Exception class for thread-related errors. More...

class  Glib::Thread
 Represents a running thread. More...

class  Glib::Thread::Exit
 Exception class used to exit from a thread. More...

struct  Glib::StaticMutex
 Like Glib::Mutex, but can be defined at compile time. More...

class  Glib::Mutex
 Represents a mutex (mutual exclusion). More...

class  Glib::Mutex::Lock
 Utility class for exception-safe mutex locking. More...

struct  Glib::StaticRecMutex
 Like Glib::RecMutex, but can be defined at compile time. More...

class  Glib::RecMutex
class  Glib::RecMutex::Lock
 Utility class for exception-safe locking of recursive mutexes. More...

struct  Glib::StaticRWLock
 Like Glib::RWLock, but can be defined at compile time. More...

class  Glib::RWLock
class  Glib::RWLock::ReaderLock
 Utility class for exception-safe locking of read/write locks. More...

class  Glib::RWLock::WriterLock
 Utility class for exception-safe locking of read/write locks. More...

class  Glib::Cond
 An opaque data structure to represent a condition. More...

struct  Glib::StaticPrivate<T>
class  Glib::Private<T>
class  Glib::ThreadPool
 A pool of threads to execute work concurrently. More...

class  Glib::Timer
 Portable stop watch interface. More...

struct  Glib::TimeVal
 Glib::TimeVal is a wrapper around the glib structure GTimeVal. More...

class  Glib::ustring_Iterator<T>
 The iterator type of Glib::ustring. More...

class  Glib::ustring
 Glib::ustring has much the same interface as std::string, but contains Unicode characters encoded as UTF-8. More...

class  Glib::ValueBase
class  Glib::ValueBase_Boxed
class  Glib::ValueBase_Object
class  Glib::ValueBase_Enum
class  Glib::ValueBase_Flags
class  Glib::ValueBase_String
class  Glib::Value_Boxed<T>
class  Glib::Value<Glib::RefPtr<T>>
 Partial specialization for RefPtr<> to Glib::Object. More...

class  Glib::Value<std::string>
 Specialization for strings. More...

class  Glib::Value<Glib::ustring>
 Specialization for UTF-8 strings. More...

class  Glib::Value_Enum<T>
 Base class of Glib::Value<T> specializations for enum types. More...

class  Glib::Value_Flags<T>
 Base class of Glib::Value<T> specializations for flags types. More...

class  Glib::Value<bool>
class  Glib::Value<char>
class  Glib::Value<unsigned char>
class  Glib::Value<int>
class  Glib::Value<unsigned int>
class  Glib::Value<long>
class  Glib::Value<unsigned long>
class  Glib::Value<long long>
class  Glib::Value<unsigned long long>
class  Glib::Value<float>
class  Glib::Value<double>
class  Glib::Value<void*>
class  Glib::Value_Pointer<T, PtrT>
class  Glib::Value<T>
 Generic value implementation for custom types. More...

class  Glib::Value<T*>
 Specialization for pointers to instances of any type. More...

class  Glib::Value<const T*>
 Specialization for pointers to const instances of any type. More...


Typedefs

typedef ArrayHandle<Glib::ustringStringArrayHandle
 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>.

typedef Glib::ArrayHandle<
Glib::ustring
SArray
typedef GPid Pid
typedef Glib::ObjectBase*(* WrapNewFunction )(GObject*)

Enumerations

enum  OwnershipType {
  OWNERSHIP_NONE = 0,
  OWNERSHIP_SHALLOW,
  OWNERSHIP_DEEP
}
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_WRITEABLE = 1 << 3,
  IO_FLAG_IS_SEEKABLE = 1 << 4,
  IO_FLAG_MASK = 0x1F,
  IO_FLAG_GET_MASK = 0x1F,
  IO_FLAG_SET_MASK = 0x03
}
enum  {
  PRIORITY_HIGH = -100,
  PRIORITY_DEFAULT = 0,
  PRIORITY_HIGH_IDLE = 100,
  PRIORITY_DEFAULT_IDLE = 200,
  PRIORITY_LOW = 300
}
enum  IOCondition {
  IO_IN,
  IO_OUT,
  IO_PRI,
  IO_ERR,
  IO_HUP,
  IO_NVAL
}
 A bitwise combination representing an I/O condition to watch for on an event source. More...

enum  ModuleFlags {
  MODULE_BIND_LAZY = 1 << 0,
  MODULE_BIND_MASK = 0x01
}
enum  SpawnFlags {
  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
}
enum  ThreadPriority {
  THREAD_PRIORITY_LOW,
  THREAD_PRIORITY_NORMAL,
  THREAD_PRIORITY_HIGH,
  THREAD_PRIORITY_URGENT
}
 Specifies the priority of a thread. More...

enum  NotLock { NOT_LOCK }
enum  TryLock { TRY_LOCK }
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_COMBINING_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
}
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.

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.

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.

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 init ()
 Initialize glibmm.

RefPtr<ObjectBasewrap_interface (GObject* object, bool take_copy=false)
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)
Glib::RefPtr<IOChannelwrap (GIOChannel* gobject, bool take_copy=false)
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)
SignalTimeout signal_timeout ()
 Convenience timeout signal.

SignalIdle signal_idle ()
 Convenience idle signal.

SignalIO signal_io ()
 Convenience I/O signal.

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 an environment variable.

std::string getenv (const std::string& variable)
 Returns an environment variable.

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

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

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.

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 build_filename (const Glib::ArrayHandle<std::string>& elements)
 Creates a filename from a series of 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_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.

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)
bool _gobject_cppinstance_already_deleted (GObject* gobject)
Glib::ArrayHandle<std::string> shell_parse_argv (const std::string& command_line)
 Parses a command line into an argument vector, in much the same way the shell would, but without many of the expansions the shell would perform (variable expansion, globs, operators, filename expansion, etc. are not supported).

std::string shell_quote (const std::string& unquoted_string)
 Quotes a string so that the shell (/bin/sh) will interpret the quoted string to mean unquoted_string.

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

SpawnFlags operator| (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags operator& (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags operator^ (SpawnFlags lhs, SpawnFlags rhs)
SpawnFlags operator~ (SpawnFlags flags)
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=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), Pid* child_pid=0, int* standard_input=0, int* standard_output=0, int* standard_error=0)
void spawn_async_with_pipes (const std::string& working_directory, const Glib::ArrayHandle<std::string>& argv, SpawnFlags flags=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), Pid* child_pid=0, int* standard_input=0, int* standard_output=0, int* standard_error=0)
void spawn_async (const std::string& working_directory, const Glib::ArrayHandle<std::string>& argv, const Glib::ArrayHandle<std::string>& envp, SpawnFlags flags=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), Pid* child_pid=0)
void spawn_async (const std::string& working_directory, const Glib::ArrayHandle<std::string>& argv, SpawnFlags flags=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), Pid* child_pid=0)
void spawn_sync (const std::string& working_directory, const Glib::ArrayHandle<std::string>& argv, const Glib::ArrayHandle<std::string>& envp, SpawnFlags flags=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), std::string* standard_output=0, std::string* standard_error=0, int* exit_status=0)
void spawn_sync (const std::string& working_directory, const Glib::ArrayHandle<std::string>& argv, SpawnFlags flags=SpawnFlags(0), const sigc::slot<void>& child_setup=sigc::slot<void>(), std::string* standard_output=0, std::string* standard_error=0, int* exit_status=0)
void spawn_command_line_async (const std::string& command_line)
void spawn_command_line_sync (const std::string& command_line, std::string* standard_output=0, std::string* standard_error=0, int* exit_status=0)
void spawn_close_pid (Pid pid)
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 thread_init (GThreadFunctions* vtable=0)
 Initializes the GLib thread system.

bool thread_supported ()
 Returns whether the thread system is initialized.

void usleep (unsigned long microseconds)
gunichar get_unichar_from_std_iterator (std::string::const_iterator pos) G_GNUC_PURE
 Extract a UCS-4 character from UTF-8 data.

void wrap_register_init ()
void wrap_register_cleanup ()
void wrap_register (GType type, WrapNewFunction func)
Glib::ObjectBasewrap_auto (GObject* object, bool take_copy=false)
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 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.


Typedef Documentation

typedef GPid Glib::Pid
 

typedef Glib::ArrayHandle<Glib::ustring> Glib::SArray
 

typedef Glib::ObjectBase*(* Glib::WrapNewFunction)(GObject*)
 


Function Documentation

bool _gobject_cppinstance_already_deleted ( GObject gobject  ) 
 

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.

gunichar 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 init (  ) 
 

Initialize glibmm.

You may call this more than once. You do nott need to call this if you are using Glib::MainLoop or Gtk::Main, because they call it for you.

template <class T>
const T::BaseObjectType* 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* 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* 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* 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* 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.

template <class T>
T::BaseObjectType* 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.

void usleep ( unsigned long  microseconds  ) 
 

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

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

Glib::ObjectBase* wrap_auto ( GObject object,
bool  take_copy = false
 

RefPtr<ObjectBase> wrap_interface ( GObject object,
bool  take_copy = false
 

void wrap_register ( GType  type,
WrapNewFunction  func
 

void wrap_register_cleanup (  ) 
 

void wrap_register_init (  ) 
 


Generated for glibmm 2.4 by Doxygen 1.3.7 © 1997-2001