From 6c2f22fd4fe7769e32eca83071526eccc6a7e495 Mon Sep 17 00:00:00 2001 From: "Andrew J. Hesford" Date: Wed, 7 Oct 2020 09:55:01 -0400 Subject: [PATCH] gitg: rebuild for Python 3.9 --- srcpkgs/gitg/patches/vapi.patch | 8594 +++++++++++++++++++++++++++++++ srcpkgs/gitg/template | 2 +- 2 files changed, 8595 insertions(+), 1 deletion(-) create mode 100644 srcpkgs/gitg/patches/vapi.patch diff --git a/srcpkgs/gitg/patches/vapi.patch b/srcpkgs/gitg/patches/vapi.patch new file mode 100644 index 0000000000..5fb234b453 --- /dev/null +++ b/srcpkgs/gitg/patches/vapi.patch @@ -0,0 +1,8594 @@ +From fe4a8bf205bc4a1f2753ccf83f0946d5ef55202e Mon Sep 17 00:00:00 2001 +From: Alberto Fanjul +Date: Wed, 7 Aug 2019 00:41:56 +0200 +Subject: [PATCH] vala: Remove obsolete vapi files + +--- + vapi/gio-windows-2.0.vapi | 21 - + vapi/glib-2.0.vapi | 6173 ----------------------------------- + vapi/gtksourceview-3.0.deps | 7 - + vapi/gtksourceview-3.0.vapi | 937 ------ + vapi/libsoup-2.4.deps | 1 - + vapi/libsoup-2.4.vapi | 1396 -------- + 6 files changed, 8535 deletions(-) + delete mode 100644 vapi/gio-windows-2.0.vapi + delete mode 100644 vapi/glib-2.0.vapi + delete mode 100644 vapi/gtksourceview-3.0.deps + delete mode 100644 vapi/gtksourceview-3.0.vapi + delete mode 100644 vapi/libsoup-2.4.deps + delete mode 100644 vapi/libsoup-2.4.vapi + +diff --git a/vapi/gio-windows-2.0.vapi b/vapi/gio-windows-2.0.vapi +deleted file mode 100644 +index 39c9da28..00000000 +--- vapi/gio-windows-2.0.vapi ++++ /dev/null +@@ -1,21 +0,0 @@ +-[CCode (cprefix = "G", lower_case_cprefix = "g_")] +-namespace GLib { +- [CCode (cheader_filename = "gio/gwin32inputstream.h")] +- public class Win32InputStream : GLib.InputStream { +- [CCode (has_construct_function = false, type = "GInputStream*")] +- public Win32InputStream (int handle, bool close_fd); +- public bool get_close_handle (); +- public void set_close_handle (bool close_fd); +- public bool close_handle { get; set; } +- public int handle { get; construct; } +- } +- [CCode (cheader_filename = "gio/gwin32outputstream.h")] +- public class Win32OutputStream : GLib.OutputStream { +- [CCode (has_construct_function = false, type = "GOutputStream*")] +- public Win32OutputStream (int handle, bool close_fd); +- public bool get_close_handle (); +- public void set_close_handle (bool close_fd); +- public bool close_handle { get; set; } +- public int handle { get; construct; } +- } +-} +diff --git a/vapi/glib-2.0.vapi b/vapi/glib-2.0.vapi +deleted file mode 100644 +index 37de9592..00000000 +--- vapi/glib-2.0.vapi ++++ /dev/null +@@ -1,6173 +0,0 @@ +-/* glib-2.0.vala +- * +- * Copyright (C) 2006-2014 Jürg Billeter +- * Copyright (C) 2006-2008 Raffaele Sandrini +- * Copyright (C) 2007 Mathias Hasselmann +- * +- * This library is free software; you can redistribute it and/or +- * modify it under the terms of the GNU Lesser General Public +- * License as published by the Free Software Foundation; either +- * version 2.1 of the License, or (at your option) any later version. +- * +- * This library is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +- * Lesser General Public License for more details. +- * +- * You should have received a copy of the GNU Lesser General Public +- * License along with this library; if not, write to the Free Software +- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +- * +- * As a special exception, if you use inline functions from this file, this +- * file does not by itself cause the resulting executable to be covered by +- * the GNU Lesser General Public License. +- * +- * Author: +- * Jürg Billeter +- * Raffaele Sandrini +- * Mathias Hasselmann +- */ +- +-//FIXME: This file is added to include fixes in glib-2.0.vapi that should be released on vala 0.43.3. Remove then. +- +-[SimpleType] +-[GIR (name = "gboolean")] +-[CCode (cname = "gboolean", cheader_filename = "glib.h", type_id = "G_TYPE_BOOLEAN", marshaller_type_name = "BOOLEAN", get_value_function = "g_value_get_boolean", set_value_function = "g_value_set_boolean", default_value = "FALSE", type_signature = "b")] +-[BooleanType] +-public struct bool { +- public string to_string () { +- if (this) { +- return "true"; +- } else { +- return "false"; +- } +- } +- +- public static bool parse (string str) { +- if (str == "true") { +- return true; +- } else { +- return false; +- } +- } +- public static bool try_parse (string str, out bool result = null) { +- if (str == "true") { +- result = true; +- return true; +- } else if (str == "false") { +- result = false; +- return true; +- } else { +- result = false; +- return false; +- } +- } +-} +- +-[SimpleType] +-[GIR (name = "gint8")] +-[CCode (cname = "gchar", cprefix = "g_ascii_", cheader_filename = "glib.h", type_id = "G_TYPE_CHAR", marshaller_type_name = "CHAR", get_value_function = "g_value_get_schar", set_value_function = "g_value_set_schar", default_value = "\'\\0\'", type_signature = "y")] +-[IntegerType (rank = 2, min = 0, max = 127)] +-public struct char { +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%c"); +- public bool isalnum (); +- public bool isalpha (); +- public bool iscntrl (); +- public bool isdigit (); +- public bool isgraph (); +- public bool islower (); +- public bool isprint (); +- public bool ispunct (); +- public bool isspace (); +- public bool isupper (); +- public bool isxdigit (); +- public int digit_value (); +- public int xdigit_value (); +- public char tolower (); +- public char toupper (); +- +- [CCode (cname = "MIN")] +- public static char min (char a, char b); +- [CCode (cname = "MAX")] +- public static char max (char a, char b); +- [CCode (cname = "CLAMP")] +- public char clamp (char low, char high); +-} +- +-[SimpleType] +-[GIR (name = "guint8")] +-[CCode (cname = "guchar", cheader_filename = "glib.h", type_id = "G_TYPE_UCHAR", marshaller_type_name = "UCHAR", get_value_function = "g_value_get_uchar", set_value_function = "g_value_set_uchar", default_value = "\'\\0\'", type_signature = "y")] +-[IntegerType (rank = 3, min = 0, max = 255)] +-public struct uchar { +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hhu"); +- +- [CCode (cname = "MIN")] +- public static uchar min (uchar a, uchar b); +- [CCode (cname = "MAX")] +- public static uchar max (uchar a, uchar b); +- [CCode (cname = "CLAMP")] +- public uchar clamp (uchar low, uchar high); +-} +- +-[SimpleType] +-[GIR (name = "gint")] +-[CCode (cname = "gint", cheader_filename = "glib.h", type_id = "G_TYPE_INT", marshaller_type_name = "INT", get_value_function = "g_value_get_int", set_value_function = "g_value_set_int", default_value = "0", default_value_on_error = "-1", type_signature = "i")] +-[IntegerType (rank = 6)] +-public struct int { +- [CCode (cname = "G_MININT")] +- public const int MIN; +- [CCode (cname = "G_MAXINT")] +- public const int MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%i"); +- +- [CCode (cname = "MIN")] +- public static int min (int a, int b); +- [CCode (cname = "MAX")] +- public static int max (int a, int b); +- [CCode (cname = "CLAMP")] +- public int clamp (int low, int high); +- +- [CCode (cname = "GINT_TO_POINTER")] +- public void* to_pointer (); +- [CCode (cname = "GPOINTER_TO_INT")] +- public static int from_pointer (void* p); +- +- [CCode (cname = "abs", cheader_filename = "stdlib.h")] +- public int abs (); +- +- [CCode (cname = "GINT_TO_BE")] +- public int to_big_endian (); +- [CCode (cname = "GINT_TO_LE")] +- public int to_little_endian (); +- +- [CCode (cname = "GINT_FROM_BE")] +- public static int from_big_endian (int val); +- [CCode (cname = "GINT_FROM_LE")] +- public static int from_little_endian (int val); +- +- [CCode (cname = "atoi", cheader_filename = "stdlib.h")] +- public static int parse (string str); +-} +- +-[SimpleType] +-[GIR (name = "guint")] +-[CCode (cname = "guint", cheader_filename = "glib.h", type_id = "G_TYPE_UINT", marshaller_type_name = "UINT", get_value_function = "g_value_get_uint", set_value_function = "g_value_set_uint", default_value = "0U", type_signature = "u")] +-[IntegerType (rank = 7)] +-public struct uint { +- [CCode (cname = "0")] +- public const uint MIN; +- [CCode (cname = "G_MAXUINT")] +- public const uint MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%u"); +- +- [CCode (cname = "MIN")] +- public static uint min (uint a, uint b); +- [CCode (cname = "MAX")] +- public static uint max (uint a, uint b); +- [CCode (cname = "CLAMP")] +- public uint clamp (uint low, uint high); +- +- [CCode (cname = "GUINT_TO_POINTER")] +- public void* to_pointer (); +- [CCode (cname = "GPOINTER_TO_UINT")] +- public static uint from_pointer (void* p); +- +- [CCode (cname = "GUINT_TO_BE")] +- public uint to_big_endian (); +- [CCode (cname = "GUINT_TO_LE")] +- public uint to_little_endian (); +- +- [CCode (cname = "GUINT_FROM_BE")] +- public static uint from_big_endian (uint val); +- [CCode (cname = "GUINT_FROM_LE")] +- public static uint from_little_endian (uint val); +-} +- +-[SimpleType] +-[GIR (name = "gshort")] +-[CCode (cname = "gshort", cheader_filename = "glib.h", type_id = "G_TYPE_INT", marshaller_type_name = "INT", get_value_function = "g_value_get_int", set_value_function = "g_value_set_int", default_value = "0", default_value_on_error = "-1", type_signature = "n")] +-[IntegerType (rank = 4, min = -32768, max = 32767)] +-public struct short { +- [CCode (cname = "G_MINSHORT")] +- public const short MIN; +- [CCode (cname = "G_MAXSHORT")] +- public const short MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hi"); +- +- [CCode (cname = "MIN")] +- public static short min (short a, short b); +- [CCode (cname = "MAX")] +- public static short max (short a, short b); +- [CCode (cname = "CLAMP")] +- public short clamp (short low, short high); +- [CCode (cname = "abs", cheader_filename = "stdlib.h")] +- public short abs (); +-} +- +-[SimpleType] +-[GIR (name = "gushort")] +-[CCode (cname = "gushort", cheader_filename = "glib.h", type_id = "G_TYPE_UINT", marshaller_type_name = "UINT", get_value_function = "g_value_get_uint", set_value_function = "g_value_set_uint", default_value = "0U", type_signature = "q")] +-[IntegerType (rank = 5, min = 0, max = 65535)] +-public struct ushort { +- [CCode (cname = "0U")] +- public const ushort MIN; +- [CCode (cname = "G_MAXUSHORT")] +- public const ushort MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hu"); +- +- [CCode (cname = "MIN")] +- public static ushort min (ushort a, ushort b); +- [CCode (cname = "MAX")] +- public static ushort max (ushort a, ushort b); +- [CCode (cname = "CLAMP")] +- public ushort clamp (ushort low, ushort high); +-} +- +-[SimpleType] +-[GIR (name = "glong")] +-[CCode (cname = "glong", cheader_filename = "glib.h", type_id = "G_TYPE_LONG", marshaller_type_name = "LONG", get_value_function = "g_value_get_long", set_value_function = "g_value_set_long", default_value = "0L", default_value_on_error = "-1L")] +-[IntegerType (rank = 8)] +-public struct long { +- [CCode (cname = "G_MINLONG")] +- public const long MIN; +- [CCode (cname = "G_MAXLONG")] +- public const long MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%li"); +- +- [CCode (cname = "MIN")] +- public static long min (long a, long b); +- [CCode (cname = "MAX")] +- public static long max (long a, long b); +- [CCode (cname = "CLAMP")] +- public long clamp (long low, long high); +- [CCode (cname = "labs", cheader_filename = "stdlib.h")] +- public long abs (); +- +- [CCode (cname = "GLONG_TO_BE")] +- public long to_big_endian (); +- [CCode (cname = "GLONG_TO_LE")] +- public long to_little_endian (); +- +- [CCode (cname = "GLONG_FROM_BE")] +- public static long from_big_endian (long val); +- [CCode (cname = "GLONG_FROM_LE")] +- public static long from_little_endian (long val); +- +- [CCode (cname = "strtol", cheader_filename = "stdlib.h")] +- static long strtol (string nptr, out char* endptr, uint _base); +- +- public static long parse (string str) { +- return strtol (str, null, 0); +- } +- +- public static bool try_parse (string str, out long result = null, out unowned string unparsed = null) { +- char* endptr; +- result = strtol (str, out endptr, 0); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +-} +- +-[SimpleType] +-[GIR (name = "gulong")] +-[CCode (cname = "gulong", cheader_filename = "glib.h", type_id = "G_TYPE_ULONG", marshaller_type_name = "ULONG", get_value_function = "g_value_get_ulong", set_value_function = "g_value_set_ulong", default_value = "0UL")] +-[IntegerType (rank = 9)] +-public struct ulong { +- [CCode (cname = "0UL")] +- public const ulong MIN; +- [CCode (cname = "G_MAXULONG")] +- public const ulong MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%lu"); +- +- [CCode (cname = "MIN")] +- public static ulong min (ulong a, ulong b); +- [CCode (cname = "MAX")] +- public static ulong max (ulong a, ulong b); +- [CCode (cname = "CLAMP")] +- public ulong clamp (ulong low, ulong high); +- +- [CCode (cname = "GULONG_TO_BE")] +- public ulong to_big_endian (); +- [CCode (cname = "GULONG_TO_LE")] +- public ulong to_little_endian (); +- +- [CCode (cname = "GULONG_FROM_BE")] +- public static ulong from_big_endian (ulong val); +- [CCode (cname = "GULONG_FROM_LE")] +- public static ulong from_little_endian (ulong val); +- +- [CCode (cname = "strtoul", cheader_filename = "stdlib.h")] +- static ulong strtoul (string nptr, out char* endptr, uint _base); +- +- public static ulong parse (string str) { +- return strtoul (str, null, 0); +- } +- +- public static bool try_parse (string str, out ulong result = null, out unowned string unparsed = null) { +- char* endptr; +- result = strtoul (str, out endptr, 0); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +-} +- +-[SimpleType] +-[GIR (name = "gulong")] +-[CCode (cname = "gsize", cheader_filename = "glib.h", type_id = "G_TYPE_ULONG", marshaller_type_name = "ULONG", get_value_function = "g_value_get_ulong", set_value_function = "g_value_set_ulong", default_value = "0UL")] +-[IntegerType (rank = 9)] +-public struct size_t { +- [CCode (cname = "0UL")] +- public const ulong MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXSIZE")] +- public const ulong MAX; +- +- [Version (since = "2.6")] +- [CCode (cname = "G_GSIZE_FORMAT")] +- public const string FORMAT; +- [Version (since = "2.6")] +- [CCode (cname = "G_GSIZE_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "GSIZE_TO_POINTER")] +- public void* to_pointer (); +- [CCode (cname = "GPOINTER_TO_SIZE")] +- public static size_t from_pointer (void* p); +- +- [CCode (cname = "MIN")] +- public static size_t min (size_t a, size_t b); +- [CCode (cname = "MAX")] +- public static size_t max (size_t a, size_t b); +- [CCode (cname = "CLAMP")] +- public size_t clamp (size_t low, size_t high); +-} +- +-[SimpleType] +-[GIR (name = "glong")] +-[CCode (cname = "gssize", cheader_filename = "glib.h", type_id = "G_TYPE_LONG", marshaller_type_name = "LONG", get_value_function = "g_value_get_long", set_value_function = "g_value_set_long", default_value = "0L", default_value_on_error = "-1L")] +-[IntegerType (rank = 8)] +-public struct ssize_t { +- [Version (since = "2.14")] +- [CCode (cname = "G_MINSSIZE")] +- public const long MIN; +- [Version (since = "2.14")] +- [CCode (cname = "G_MAXSSIZE")] +- public const long MAX; +- +- [Version (since = "2.6")] +- [CCode (cname = "G_GSSIZE_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GSIZE_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "MIN")] +- public static ssize_t min (ssize_t a, ssize_t b); +- [CCode (cname = "MAX")] +- public static ssize_t max (ssize_t a, ssize_t b); +- [CCode (cname = "CLAMP")] +- public ssize_t clamp (ssize_t low, ssize_t high); +-} +- +-[SimpleType] +-[GIR (name = "gulong")] +-[CCode (cname = "guintptr", cheader_filename = "glib.h", type_id = "G_TYPE_ULONG", marshaller_type_name = "ULONG", get_value_function = "g_value_get_ulong", set_value_function = "g_value_set_ulong", default_value = "0UL")] +-[IntegerType (rank = 9)] +-public struct uintptr { +- [CCode (cname = "0UL")] +- public const ulong MIN; +- [CCode (cname = "G_MAXSIZE")] +- public const ulong MAX; +- +- [CCode (cname = "G_GUINTPTR_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINTPTR_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "GSIZE_TO_POINTER")] +- public void* to_pointer (); +- [CCode (cname = "GPOINTER_TO_SIZE")] +- public static uintptr from_pointer (void* p); +- +- [CCode (cname = "MIN")] +- public static uintptr min (uintptr a, uintptr b); +- [CCode (cname = "MAX")] +- public static uintptr max (uintptr a, uintptr b); +- [CCode (cname = "CLAMP")] +- public uintptr clamp (uintptr low, uintptr high); +-} +- +-[SimpleType] +-[GIR (name = "glong")] +-[CCode (cname = "gintptr", cheader_filename = "glib.h", type_id = "G_TYPE_LONG", marshaller_type_name = "LONG", get_value_function = "g_value_get_long", set_value_function = "g_value_set_long", default_value = "0L")] +-[IntegerType (rank = 8)] +-public struct intptr { +- [CCode (cname = "G_MINSSIZE")] +- public const long MIN; +- [CCode (cname = "G_MAXSSIZE")] +- public const long MAX; +- +- [CCode (cname = "G_GINTPTR_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINTPTR_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "MIN")] +- public static intptr min (intptr a, intptr b); +- [CCode (cname = "MAX")] +- public static intptr max (intptr a, intptr b); +- [CCode (cname = "CLAMP")] +- public intptr clamp (intptr low, intptr high); +-} +- +-[SimpleType] +-[GIR (name = "gint8")] +-[CCode (cname = "gint8", cheader_filename = "glib.h", type_id = "G_TYPE_CHAR", marshaller_type_name = "CHAR", get_value_function = "g_value_get_char", set_value_function = "g_value_set_char", default_value = "0", default_value_on_error = "-1", type_signature = "y")] +-[IntegerType (rank = 1, min = -128, max = 127)] +-public struct int8 { +- [Version (since = "2.4")] +- [CCode (cname = "G_MININT8")] +- public const int8 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXINT8")] +- public const int8 MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hhi"); +- +- [CCode (cname = "MIN")] +- public static int8 min (int8 a, int8 b); +- [CCode (cname = "MAX")] +- public static int8 max (int8 a, int8 b); +- [CCode (cname = "CLAMP")] +- public int8 clamp (int8 low, int8 high); +-} +- +-[SimpleType] +-[GIR (name = "guint8")] +-[CCode (cname = "guint8", cheader_filename = "glib.h", type_id = "G_TYPE_UCHAR", marshaller_type_name = "UCHAR", get_value_function = "g_value_get_uchar", set_value_function = "g_value_set_uchar", default_value = "0U", type_signature = "y")] +-[IntegerType (rank = 3, min = 0, max = 255)] +-public struct uint8 { +- [CCode (cname = "0U")] +- public const uint8 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXUINT8")] +- public const uint8 MAX; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hhu"); +- +- [CCode (cname = "MIN")] +- public static uint8 min (uint8 a, uint8 b); +- [CCode (cname = "MAX")] +- public static uint8 max (uint8 a, uint8 b); +- [CCode (cname = "CLAMP")] +- public uint8 clamp (uint8 low, uint8 high); +-} +- +-[SimpleType] +-[GIR (name = "gint16")] +-[CCode (cname = "gint16", cheader_filename = "glib.h", type_id = "G_TYPE_INT", marshaller_type_name = "INT", get_value_function = "g_value_get_int", set_value_function = "g_value_set_int", default_value = "0", default_value_on_error = "-1", type_signature = "n")] +-[IntegerType (rank = 4, min = -32768, max = 32767)] +-public struct int16 { +- [Version (since = "2.4")] +- [CCode (cname = "G_MININT16")] +- public const int16 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXINT16")] +- public const int16 MAX; +- +- [CCode (cname = "G_GINT16_FORMAT")] +- public const string FORMAT; +- [Version (since = "2.4")] +- [CCode (cname = "G_GINT16_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "MIN")] +- public static int16 min (int16 a, int16 b); +- [CCode (cname = "MAX")] +- public static int16 max (int16 a, int16 b); +- [CCode (cname = "CLAMP")] +- public int16 clamp (int16 low, int16 high); +- +- [CCode (cname = "GINT16_TO_BE")] +- public int16 to_big_endian (); +- [CCode (cname = "GINT16_TO_LE")] +- public int16 to_little_endian (); +- +- [CCode (cname = "GINT16_FROM_BE")] +- public static int16 from_big_endian (int16 val); +- [CCode (cname = "GINT16_FROM_LE")] +- public static int16 from_little_endian (int16 val); +-} +- +-[SimpleType] +-[GIR (name = "guint16")] +-[CCode (cname = "guint16", cheader_filename = "glib.h", type_id = "G_TYPE_UINT", marshaller_type_name = "UINT", get_value_function = "g_value_get_uint", set_value_function = "g_value_set_uint", default_value = "0U", type_signature = "q")] +-[IntegerType (rank = 5, min = 0, max = 65535)] +-public struct uint16 { +- [CCode (cname = "0U")] +- public const uint16 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXUINT16")] +- public const uint16 MAX; +- +- [CCode (cname = "G_GUINT16_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINT16_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%hu"); +- +- [CCode (cname = "MIN")] +- public static uint16 min (uint16 a, uint16 b); +- [CCode (cname = "MAX")] +- public static uint16 max (uint16 a, uint16 b); +- [CCode (cname = "CLAMP")] +- public uint16 clamp (uint16 low, uint16 high); +- +- [CCode (cname = "GUINT16_TO_BE")] +- public uint16 to_big_endian (); +- [CCode (cname = "GUINT16_TO_LE")] +- public uint16 to_little_endian (); +- +- [CCode (cname = "GUINT16_FROM_BE")] +- public static uint16 from_big_endian (uint16 val); +- [CCode (cname = "GUINT16_FROM_LE")] +- public static uint16 from_little_endian (uint16 val); +- +- [CCode (cname = "g_htons")] +- public static uint16 to_network (uint16 val); +- [CCode (cname = "g_ntohs")] +- public static uint16 from_network (uint16 val); +- +- [CCode (cname = "GUINT16_SWAP_BE_PDP")] +- public uint16 swap_big_endian_pdp (); +- [CCode (cname = "GUINT16_SWAP_LE_BE")] +- public uint16 swap_little_endian_big_endian (); +- [CCode (cname = "GUINT16_SWAP_LE_PDP")] +- public uint16 swap_little_endian_pdp (); +-} +- +-[SimpleType] +-[GIR (name = "gint32")] +-[CCode (cname = "gint32", cheader_filename = "glib.h", type_id = "G_TYPE_INT", marshaller_type_name = "INT", get_value_function = "g_value_get_int", set_value_function = "g_value_set_int", default_value = "0", default_value_on_error = "-1", type_signature = "i")] +-[IntegerType (rank = 6)] +-public struct int32 { +- [Version (since = "2.4")] +- [CCode (cname = "G_MININT32")] +- public const int32 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXINT32")] +- public const int32 MAX; +- +- [CCode (cname = "G_GINT32_FORMAT")] +- public const string FORMAT; +- [Version (since = "2.4")] +- [CCode (cname = "G_GINT32_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%i"); +- +- [CCode (cname = "MIN")] +- public static int32 min (int32 a, int32 b); +- [CCode (cname = "MAX")] +- public static int32 max (int32 a, int32 b); +- [CCode (cname = "CLAMP")] +- public int32 clamp (int32 low, int32 high); +- +- [CCode (cname = "GINT32_TO_BE")] +- public int32 to_big_endian (); +- [CCode (cname = "GINT32_TO_LE")] +- public int32 to_little_endian (); +- +- [CCode (cname = "GINT32_FROM_BE")] +- public static int32 from_big_endian (int32 val); +- [CCode (cname = "GINT32_FROM_LE")] +- public static int32 from_little_endian (int32 val); +-} +- +-[SimpleType] +-[GIR (name = "guint32")] +-[CCode (cname = "guint32", cheader_filename = "glib.h", type_id = "G_TYPE_UINT", marshaller_type_name = "UINT", get_value_function = "g_value_get_uint", set_value_function = "g_value_set_uint", default_value = "0U", type_signature = "u")] +-[IntegerType (rank = 7)] +-public struct uint32 { +- [CCode (cname = "0U")] +- public const uint32 MIN; +- [Version (since = "2.4")] +- [CCode (cname = "G_MAXUINT32")] +- public const uint32 MAX; +- +- [CCode (cname = "G_GUINT32_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINT32_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%u"); +- +- [CCode (cname = "MIN")] +- public static uint32 min (uint32 a, uint32 b); +- [CCode (cname = "MAX")] +- public static uint32 max (uint32 a, uint32 b); +- [CCode (cname = "CLAMP")] +- public uint32 clamp (uint32 low, uint32 high); +- +- [CCode (cname = "GUINT32_TO_BE")] +- public uint32 to_big_endian (); +- [CCode (cname = "GUINT32_TO_LE")] +- public uint32 to_little_endian (); +- +- [CCode (cname = "GUINT32_FROM_BE")] +- public static uint32 from_big_endian (uint32 val); +- [CCode (cname = "GUINT32_FROM_LE")] +- public static uint32 from_little_endian (uint32 val); +- +- [CCode (cname = "g_htonl")] +- public static uint32 to_network (uint32 val); +- [CCode (cname = "g_ntohl")] +- public static uint32 from_network (uint32 val); +- +- [CCode (cname = "GUINT32_SWAP_BE_PDP")] +- public uint32 swap_big_endian_pdp (); +- [CCode (cname = "GUINT32_SWAP_LE_BE")] +- public uint32 swap_little_endian_big_endian (); +- [CCode (cname = "GUINT32_SWAP_LE_PDP")] +- public uint32 swap_little_endian_pdp (); +-} +- +-[SimpleType] +-[GIR (name = "gint64")] +-[CCode (cname = "gint64", cheader_filename = "glib.h", type_id = "G_TYPE_INT64", marshaller_type_name = "INT64", get_value_function = "g_value_get_int64", set_value_function = "g_value_set_int64", default_value = "0LL", default_value_on_error = "-1LL", type_signature = "x")] +-[IntegerType (rank = 10)] +-public struct int64 { +- [CCode (cname = "G_MININT64")] +- public const int64 MIN; +- [CCode (cname = "G_MAXINT64")] +- public const int64 MAX; +- +- [CCode (cname = "G_GINT64_FORMAT")] +- public const string FORMAT; +- [Version (since = "2.4")] +- [CCode (cname = "G_GINT64_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "MIN")] +- public static int64 min (int64 a, int64 b); +- [CCode (cname = "MAX")] +- public static int64 max (int64 a, int64 b); +- [CCode (cname = "CLAMP")] +- public int64 clamp (int64 low, int64 high); +- [CCode (cname = "llabs", cheader_filename = "stdlib.h")] +- public int64 abs (); +- +- [CCode (cname = "GINT64_TO_BE")] +- public int64 to_big_endian (); +- [CCode (cname = "GINT64_TO_LE")] +- public int64 to_little_endian (); +- +- [CCode (cname = "GINT64_FROM_BE")] +- public static int64 from_big_endian (int64 val); +- [CCode (cname = "GINT64_FROM_LE")] +- public static int64 from_little_endian (int64 val); +- +- [CCode (cname = "GUINT64_SWAP_LE_BE")] +- public uint64 swap_little_endian_big_endian (); +- +- [CCode (cname = "g_ascii_strtoll")] +- static int64 ascii_strtoll (string nptr, out char* endptr, uint _base); +- +- [Version (since = "2.12")] +- public static int64 parse (string str) { +- return ascii_strtoll (str, null, 0); +- } +- +- [Version (since = "2.12")] +- public static bool try_parse (string str, out int64 result = null, out unowned string unparsed = null) { +- char* endptr; +- result = ascii_strtoll (str, out endptr, 0); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +- +- [CCode (cname = "g_ascii_string_to_signed")] +- [Version (since = "2.54")] +- public static bool from_string (string str, [CCode (pos = 5.1)] out int64 out_num = null, uint @base = 10U, int64 min = int64.MIN, int64 max = int64.MAX) throws GLib.NumberParserError; +-} +- +-[SimpleType] +-[GIR (name = "guint64")] +-[CCode (cname = "guint64", cheader_filename = "glib.h", type_id = "G_TYPE_UINT64", marshaller_type_name = "UINT64", get_value_function = "g_value_get_uint64", set_value_function = "g_value_set_uint64", default_value = "0ULL", type_signature = "t")] +-[IntegerType (rank = 11)] +-public struct uint64 { +- [CCode (cname = "0ULL")] +- public const uint64 MIN; +- [CCode (cname = "G_MAXUINT64")] +- public const uint64 MAX; +- +- [CCode (cname = "G_GUINT64_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINT64_MODIFIER")] +- public const string FORMAT_MODIFIER; +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%" + FORMAT); +- +- [CCode (cname = "MIN")] +- public static uint64 min (uint64 a, uint64 b); +- [CCode (cname = "MAX")] +- public static uint64 max (uint64 a, uint64 b); +- [CCode (cname = "CLAMP")] +- public uint64 clamp (uint64 low, uint64 high); +- +- [CCode (cname = "GUINT64_TO_BE")] +- public uint64 to_big_endian (); +- [CCode (cname = "GUINT64_TO_LE")] +- public uint64 to_little_endian (); +- +- [CCode (cname = "GUINT64_FROM_BE")] +- public static uint64 from_big_endian (uint64 val); +- [CCode (cname = "GUINT64_FROM_LE")] +- public static uint64 from_little_endian (uint64 val); +- +- [CCode (cname = "g_ascii_strtoull")] +- static uint64 ascii_strtoull (string nptr, out char* endptr, uint _base); +- +- public static uint64 parse (string str) { +- return ascii_strtoull (str, null, 0); +- } +- +- public static bool try_parse (string str, out uint64 result = null, out unowned string unparsed = null) { +- char* endptr; +- result = ascii_strtoull (str, out endptr, 0); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +- +- [CCode (cname = "g_ascii_string_to_unsigned")] +- [Version (since = "2.54")] +- public static bool from_string (string str, [CCode (pos = 5.1)] out uint64 out_num = null, uint @base = 10U, uint64 min = uint64.MIN, uint64 max = uint64.MAX) throws GLib.NumberParserError; +-} +- +-[SimpleType] +-[GIR (name = "gfloat")] +-[CCode (cname = "gfloat", cheader_filename = "glib.h,float.h,math.h", type_id = "G_TYPE_FLOAT", marshaller_type_name = "FLOAT", get_value_function = "g_value_get_float", set_value_function = "g_value_set_float", default_value = "0.0F", default_value_on_error = "-1.0F")] +-[FloatingType (rank = 1)] +-public struct float { +- [CCode (cname = "FLT_ROUNDS")] +- public const int ROUNDS; +- [CCode (cname = "FLT_RADIX")] +- public const int RADIX; +- [CCode (cname = "FLT_MANT_DIG")] +- public const int MANT_DIG; +- [CCode (cname = "FLT_DIG")] +- public const int DIG; +- +- [CCode (cname = "FLT_MIN_EXP")] +- public const int MIN_EXP; +- [CCode (cname = "FLT_MAX_EXP")] +- public const int MAX_EXP; +- +- [CCode (cname = "FLT_MIN_10_EXP")] +- public const int MIN_10_EXP; +- [CCode (cname = "FLT_MAX_10_EXP")] +- public const int MAX_10_EXP; +- +- [CCode (cname = "FLT_EPSILON")] +- public const float EPSILON; +- [CCode (cname = "FLT_MIN")] +- public const float MIN; +- [CCode (cname = "FLT_MAX")] +- public const float MAX; +- +- [CCode (cname = "NAN")] +- public const float NAN; +- [CCode (cname = "INFINITY")] +- public const float INFINITY; +- +- [CCode (cname = "isnan")] +- public bool is_nan (); +- [CCode (cname = "isfinite")] +- public bool is_finite (); +- [CCode (cname = "isnormal")] +- public bool is_normal (); +- [CCode (cname = "isinf")] +- public int is_infinity (); +- +- [CCode (cname = "g_strdup_printf", instance_pos = -1)] +- public string to_string (string format = "%g"); +- +- [CCode (cname = "MIN")] +- public static float min (float a, float b); +- [CCode (cname = "MAX")] +- public static float max (float a, float b); +- [CCode (cname = "CLAMP")] +- public float clamp (float low, float high); +- [CCode (cname = "fabsf")] +- public float abs (); +- +- [CCode (cname = "strtof", cheader_filename = "stdlib.h")] +- static float strtof (string nptr, out char* endptr); +- +- public static float parse (string str) { +- return strtof (str, null); +- } +- +- public static bool try_parse (string str, out float result = null, out unowned string unparsed = null) { +- char* endptr; +- result = strtof (str, out endptr); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +-} +- +-[SimpleType] +-[GIR (name = "gdouble")] +-[CCode (cname = "gdouble", cheader_filename = "glib.h,float.h,math.h", type_id = "G_TYPE_DOUBLE", marshaller_type_name = "DOUBLE", get_value_function = "g_value_get_double", set_value_function = "g_value_set_double", default_value = "0.0", default_value_on_error = "-1.0", type_signature = "d")] +-[FloatingType (rank = 2)] +-public struct double { +- [CCode (cname = "DBL_MANT_DIG")] +- public const int MANT_DIG; +- [CCode (cname = "DBL_DIG")] +- public const int DIG; +- +- [CCode (cname = "DBL_MIN_EXP")] +- public const int MIN_EXP; +- [CCode (cname = "DBL_MAX_EXP")] +- public const int MAX_EXP; +- +- [CCode (cname = "DBL_MIN_10_EXP")] +- public const int MIN_10_EXP; +- [CCode (cname = "DBL_MAX_10_EXP")] +- public const int MAX_10_EXP; +- +- [CCode (cname = "DBL_EPSILON")] +- public const double EPSILON; +- [CCode (cname = "DBL_MIN")] +- public const double MIN; +- [CCode (cname = "DBL_MAX")] +- public const double MAX; +- +- [CCode (cname = "((double) NAN)")] +- public const double NAN; +- [CCode (cname = "((double) INFINITY)")] +- public const double INFINITY; +- +- [CCode (cname = "isnan")] +- public bool is_nan (); +- [CCode (cname = "isfinite")] +- public bool is_finite (); +- [CCode (cname = "isnormal")] +- public bool is_normal (); +- [CCode (cname = "isinf")] +- public int is_infinity (); +- +- [CCode (cname = "MIN")] +- public static double min (double a, double b); +- [CCode (cname = "MAX")] +- public static double max (double a, double b); +- [CCode (cname = "CLAMP")] +- public double clamp (double low, double high); +- [CCode (cname = "fabs")] +- public double abs (); +- +- [CCode (cname = "G_ASCII_DTOSTR_BUF_SIZE")] +- public const int DTOSTR_BUF_SIZE; +- [CCode (cname = "g_ascii_dtostr", instance_pos = -1)] +- public unowned string to_str (char[] buffer); +- [CCode (cname = "g_ascii_formatd", instance_pos = -1)] +- public unowned string format (char[] buffer, string format = "%g"); +- +- public string to_string () { +- return this.to_str(new char[DTOSTR_BUF_SIZE]); +- } +- +- [CCode (cname = "g_ascii_strtod")] +- static double ascii_strtod (string nptr, out char* endptr); +- +- public static double parse (string str) { +- return ascii_strtod (str, null); +- } +- +- public static bool try_parse (string str, out double result = null, out unowned string unparsed = null) { +- char* endptr; +- result = ascii_strtod (str, out endptr); +- if (endptr == (char*) str + str.length) { +- unparsed = ""; +- return true; +- } else { +- unparsed = (string) endptr; +- return false; +- } +- } +-} +- +-[GIR (name = "glong")] +-[CCode (cheader_filename = "time.h", has_type_id = false, default_value = "0")] +-[IntegerType (rank = 8)] +-public struct time_t { +- [CCode (cname = "time")] +- public time_t (out time_t result = null); +-} +- +-[SimpleType] +-[CCode (cheader_filename="stdarg.h", cprefix="va_", has_type_id = false, destroy_function = "va_end", lvalue_access = false)] +-public struct va_list { +- [CCode (cname = "va_start")] +- public va_list (); +- [CCode (cname = "va_copy")] +- public va_list.copy (va_list src); +- [CCode (generic_type_pos = 1.1, simple_generics = true)] +- public unowned G arg (); +-} +- +-[SimpleType] +-[GIR (name = "gunichar")] +-[CCode (cname = "gunichar", cprefix = "g_unichar_", cheader_filename = "glib.h", type_id = "G_TYPE_UINT", marshaller_type_name = "UINT", get_value_function = "g_value_get_uint", set_value_function = "g_value_set_uint", default_value = "0U", type_signature = "u")] +-[IntegerType (rank = 7)] +-public struct unichar { +- public bool validate (); +- public bool isalnum (); +- public bool isalpha (); +- public bool iscntrl (); +- public bool isdigit (); +- public bool isgraph (); +- public bool islower (); +- [Version (since = "2.14")] +- public bool ismark (); +- public bool isprint (); +- public bool ispunct (); +- public bool isspace (); +- public bool isupper (); +- public bool isxdigit (); +- public bool istitle (); +- public bool isdefined (); +- public bool iswide (); +- [Version (since = "2.12")] +- public bool iswide_cjk (); +- [Version (since = "2.14")] +- public bool iszerowidth (); +- public unichar toupper (); +- public unichar tolower (); +- public unichar totitle (); +- public int digit_value (); +- public int xdigit_value (); +- public GLib.UnicodeType type (); +- public GLib.UnicodeBreakType break_type (); +- [Version (since = "2.14")] +- public GLib.UnicodeScript get_script(); +- +- public int to_utf8 (string? outbuf); +- +- public string to_string () { +- string str = (string) new char[7]; +- this.to_utf8 (str); +- return str; +- } +- +- [Version (since = "2.30")] +- public bool compose (unichar b, out unichar ch); +- [Version (since = "2.30")] +- public bool decompose (out unichar a, out unichar b); +- [Version (since = "2.30")] +- public size_t fully_decompose (bool compat, unichar[] result); +- +- [CCode (cname = "MIN")] +- public static unichar min (unichar a, unichar b); +- [CCode (cname = "MAX")] +- public static unichar max (unichar a, unichar b); +- [CCode (cname = "CLAMP")] +- public unichar clamp (unichar low, unichar high); +- +- [CCode (cname = "G_UNICHAR_MAX_DECOMPOSITION_LENGTH")] +- public const int MAX_DECOMPOSITION_LENGTH; +- +- [CCode (cname = "G_GUINT32_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINT32_MODIFIER")] +- public const string FORMAT_MODIFIER; +-} +- +-[SimpleType] +-[GIR (name = "guint16")] +-[CCode (cname = "gunichar2", cheader_filename = "glib.h", default_value = "0U", type_signature = "q", has_type_id = false)] +-[IntegerType (rank = 5)] +-public struct unichar2 { +- [CCode (cname = "G_GUINT16_FORMAT")] +- public const string FORMAT; +- [CCode (cname = "G_GINT16_MODIFIER")] +- public const string FORMAT_MODIFIER; +-} +- +-[Compact] +-[Immutable] +-[GIR (name = "utf8")] +-[CCode (cname = "gchar", const_cname = "const gchar", copy_function = "g_strdup", free_function = "g_free", cheader_filename = "stdlib.h,string.h,glib.h", type_id = "G_TYPE_STRING", marshaller_type_name = "STRING", param_spec_function = "g_param_spec_string", get_value_function = "g_value_get_string", set_value_function = "g_value_set_string", take_value_function = "g_value_take_string", type_signature = "s")] +-public class string { +- [Version (replacement = "string.index_of")] +- [CCode (cname = "strstr")] +- public unowned string? str (string needle); +- [Version (replacement = "string.last_index_of")] +- [CCode (cname = "g_strrstr")] +- public unowned string? rstr (string needle); +- [CCode (cname = "g_strrstr_len")] +- public unowned string? rstr_len (ssize_t haystack_len, string needle); +- +- [CCode (cname = "strstr")] +- static char* strstr (char* haystack, char* needle); +- [CCode (cname = "g_strrstr")] +- static char* strrstr (char* haystack, char* needle); +- [CCode (cname = "g_utf8_strchr")] +- static char* utf8_strchr (char* str, ssize_t len, unichar c); +- [CCode (cname = "g_utf8_strrchr")] +- static char* utf8_strrchr (char* str, ssize_t len, unichar c); +- +- public int index_of (string needle, int start_index = 0) { +- char* result = strstr ((char*) this + start_index, (char*) needle); +- +- if (result != null) { +- return (int) (result - (char*) this); +- } else { +- return -1; +- } +- } +- +- public int last_index_of (string needle, int start_index = 0) { +- char* result = strrstr ((char*) this + start_index, (char*) needle); +- +- if (result != null) { +- return (int) (result - (char*) this); +- } else { +- return -1; +- } +- } +- +- public int index_of_char (unichar c, int start_index = 0) { +- char* result = utf8_strchr ((char*) this + start_index, -1, c); +- +- if (result != null) { +- return (int) (result - (char*) this); +- } else { +- return -1; +- } +- } +- +- public int last_index_of_char (unichar c, int start_index = 0) { +- char* result = utf8_strrchr ((char*) this + start_index, -1, c); +- +- if (result != null) { +- return (int) (result - (char*) this); +- } else { +- return -1; +- } +- } +- +- [Version (since = "2.2")] +- [CCode (cname = "g_str_has_prefix")] +- public bool has_prefix (string prefix); +- [Version (since = "2.2")] +- [CCode (cname = "g_str_has_suffix")] +- public bool has_suffix (string suffix); +- [CCode (cname = "g_strdup_printf"), PrintfFormat] +- public string printf (...); +- [CCode (cname = "g_strdup_vprintf")] +- public string vprintf (va_list args); +- [CCode (cname = "sscanf", cheader_filename = "stdio.h"), ScanfFormat] +- public int scanf (string format, ...); +- [CCode (cname = "g_strconcat")] +- public string concat (string string2, ...); +- [CCode (cname = "g_strescape")] +- public string escape (string? exceptions = null); +- [CCode (cname = "g_strcompress")] +- public string compress (); +- [CCode (cname = "g_strsplit", array_length = false, array_null_terminated = true)] +- public string[] split (string delimiter, int max_tokens = 0); +- [Version (since = "2.4")] +- [CCode (cname = "g_strsplit_set", array_length = false, array_null_terminated = true)] +- public string[] split_set (string delimiters, int max_tokens = 0); +- [CCode (cname = "g_stpcpy")] +- private static void* copy_to_buffer (void* dest, string src); +- [CCode (cname = "_vala_g_strjoinv")] +- public static string joinv (string? separator, string?[]? str_array) { +- if (separator == null) { +- separator = ""; +- } +- if (str_array != null && (str_array.length > 0 || (str_array.length == -1 && str_array[0] != null))) { +- int i; +- size_t len = 1; +- for (i = 0 ; (str_array.length != -1 && i < str_array.length) || (str_array.length == -1 && str_array[i] != null) ; i++) { +- len += (str_array[i] != null) ? ((!) str_array[i]).length : 0; +- } +- if (i == 0) { +- return ""; +- } +- str_array.length = i; +- len += ((!) separator).length * (i - 1); +- +- string* res = GLib.malloc (len); +- void* ptr = string.copy_to_buffer ((void*) res, (!) str_array[0]); +- for (i = 1 ; i < str_array.length ; i++) { +- ptr = string.copy_to_buffer (ptr, (!) separator); +- ptr = string.copy_to_buffer (ptr, (str_array[i] != null) ? ((!) str_array[i]) : ""); +- } +- +- return (owned) res; +- } else { +- return ""; +- } +- } +- [CCode (cname = "g_strjoin")] +- public static string join (string separator, ...); +- [CCode (cname = "g_strnfill")] +- public static string nfill (size_t length, char fill_char); +- +- public char get (long index) { +- return ((char*) this)[index]; +- } +- +- // checks whether valid string character starts at specified index +- // embedded NULs are not supported by the string class +- public bool valid_char (int index) { +- uint8 c = ((uint8*) this)[index]; +- if (c == 0x00 || (c >= 0x80 && c < 0xc2) || c >= 0xf5) { +- return false; +- } else { +- return true; +- } +- } +- +- [CCode (cname = "g_utf8_next_char")] +- public unowned string next_char (); +- [CCode (cname = "g_utf8_next_char")] +- static char* utf8_next_char (char* str); +- public bool get_next_char (ref int index, out unichar c) { +- c = utf8_get_char ((char*) this + index); +- if (c != 0) { +- index = (int) (utf8_next_char ((char*) this + index) - (char*) this); +- return true; +- } else { +- return false; +- } +- } +- [CCode (cname = "g_utf8_get_char")] +- static unichar utf8_get_char (char* str); +- public unichar get_char (long index = 0) { +- return utf8_get_char ((char*) this + index); +- } +- [CCode (cname = "g_utf8_get_char_validated")] +- public unichar get_char_validated (ssize_t max_len = -1); +- +- [Version (replacement = "string.index_of_nth_char")] +- [CCode (cname = "g_utf8_offset_to_pointer")] +- public unowned string utf8_offset (long offset); +- public unowned string offset (long offset) { +- return (string) ((char*) this + offset); +- } +- [Version (replacement = "string.char_count")] +- public long pointer_to_offset (string pos) { +- return (long) ((char*) pos - (char*) this); +- } +- +- [CCode (cname = "g_utf8_offset_to_pointer")] +- char* utf8_offset_to_pointer (long offset); +- +- public int index_of_nth_char (long c) { +- return (int) (this.utf8_offset_to_pointer (c) - (char*) this); +- } +- +- [CCode (cname = "g_utf8_prev_char")] +- public unowned string prev_char (); +- [CCode (cname = "g_utf8_prev_char")] +- static char* utf8_prev_char (char* str); +- public bool get_prev_char (ref int index, out unichar c) { +- if (0 < index) { +- index = (int) (utf8_prev_char ((char*) this + index) - (char*) this); +- c = utf8_get_char ((char*) this + index); +- return true; +- } else { +- c = 0; +- return false; +- } +- } +- +- [Version (replacement = "string.length")] +- [CCode (cname = "strlen")] +- public long len (); +- [Version (replacement = "string.index_of_char")] +- [CCode (cname = "g_utf8_strchr")] +- public unowned string chr (ssize_t len, unichar c); +- [Version (replacement = "string.last_index_of_char")] +- [CCode (cname = "g_utf8_strrchr")] +- public unowned string rchr (ssize_t len, unichar c); +- [Version (since = "2.2")] +- [CCode (cname = "g_utf8_strreverse")] +- public string reverse (ssize_t len = -1); +- [CCode (cname = "g_utf8_validate")] +- public bool validate (ssize_t max_len = -1, out char* end = null); +- [Version (since = "2.52")] +- [CCode (cname = "g_utf8_make_valid")] +- public string make_valid (ssize_t len = -1); +- [CCode (cname = "g_utf8_normalize")] +- public string normalize (ssize_t len = -1, GLib.NormalizeMode mode = GLib.NormalizeMode.DEFAULT); +- +- [CCode (cname = "g_utf8_strup")] +- public string up (ssize_t len = -1); +- [CCode (cname = "g_utf8_strdown")] +- public string down (ssize_t len = -1); +- [CCode (cname = "g_utf8_casefold")] +- public string casefold (ssize_t len = -1); +- [CCode (cname = "g_utf8_collate")] +- public int collate (string str2); +- [CCode (cname = "g_utf8_collate_key")] +- public string collate_key (ssize_t len = -1); +- [Version (since = "2.8")] +- [CCode (cname = "g_utf8_collate_key_for_filename")] +- public string collate_key_for_filename (ssize_t len = -1); +- +- [CCode (cname = "g_locale_to_utf8")] +- public string locale_to_utf8 (ssize_t len, out size_t bytes_read, out size_t bytes_written, out GLib.Error error = null); +- +- [CCode (cname = "g_strchomp")] +- public unowned string _chomp(); +- public string chomp () { +- string result = this.dup (); +- result._chomp (); +- return result; +- } +- +- [CCode (cname = "g_strchug")] +- public unowned string _chug(); +- public string chug () { +- string result = this.dup (); +- result._chug (); +- return result; +- } +- +- [CCode (cname = "g_strstrip")] +- public unowned string _strip (); +- public string strip () { +- string result = this.dup (); +- result._strip (); +- return result; +- } +- +- [CCode (cname = "g_strdelimit")] +- public unowned string _delimit (string delimiters, char new_delimiter); +- public string delimit (string delimiters, char new_delimiter) { +- string result = this.dup (); +- result._delimit (delimiters, new_delimiter); +- return result; +- } +- +- [CCode (cname = "g_str_hash")] +- public uint hash (); +- +- [Version (since = "2.40")] +- [CCode (cname = "g_str_is_ascii")] +- public bool is_ascii (); +- [Version (since = "2.40")] +- [CCode (instance_pos = "1.5", cname = "g_str_match_string")] +- public bool match_string (string search_term, bool accept_alternates); +- [Version (since = "2.40")] +- [CCode (cname = "g_str_to_ascii")] +- public string to_ascii (string? from_locale = null); +- [Version (replacement = "int.parse")] +- [CCode (cname = "atoi")] +- public int to_int (); +- [Version (replacement = "long.parse")] +- [CCode (cname = "strtol")] +- public long to_long (out unowned string endptr = null, int _base = 0); +- [Version (replacement = "double.parse")] +- [CCode (cname = "g_ascii_strtod")] +- public double to_double (out unowned string endptr = null); +- [Version (replacement = "ulong.parse")] +- [CCode (cname = "strtoul")] +- public ulong to_ulong (out unowned string endptr = null, int _base = 0); +- [Version (replacement = "int64.parse")] +- [CCode (cname = "g_ascii_strtoll")] +- public int64 to_int64 (out unowned string endptr = null, int _base = 0); +- [Version (replacement = "uint64.parse", since = "2.2")] +- [CCode (cname = "g_ascii_strtoull")] +- public uint64 to_uint64 (out unowned string endptr = null, int _base = 0); +- [CCode (cname = "g_str_tokenize_and_fold", array_length = false, array_null_terminated = true)] +- [Version (since = "2.40")] +- public string[] tokenize_and_fold (string transit_locale, [CCode (array_length = false, array_null_terminated = true)] out string[] ascii_alternates); +- +- [Version (replacement = "bool.parse")] +- public bool to_bool () { +- if (this == "true") { +- return true; +- } else { +- return false; +- } +- } +- +- [Version (replacement = "string.length")] +- [CCode (cname = "strlen")] +- public size_t size (); +- +- [CCode (cname = "g_ascii_strcasecmp")] +- public int ascii_casecmp (string s2); +- [CCode (cname = "g_ascii_strncasecmp")] +- public int ascii_ncasecmp (string s2, size_t n); +- [CCode (cname = "g_ascii_strup")] +- public string ascii_up (ssize_t len = -1); +- [CCode (cname = "g_ascii_strdown")] +- public string ascii_down (ssize_t len = -1); +- +- [CCode (cname = "g_utf8_skip")] +- public static char skip[256]; +- +- /* modifies string in place */ +- [CCode (cname = "g_strcanon")] +- public void canon (string valid_chars, char substitutor); +- +- [CCode (cname = "g_strdup")] +- public string dup (); +- [Version (replacement = "string.substring")] +- [CCode (cname = "g_strndup")] +- public string ndup (size_t n); +- +- [CCode (cname = "memchr")] +- static char* memchr (char* s, int c, size_t n); +- +- // strnlen is not available on all systems +- static long strnlen (char* str, long maxlen) { +- char* end = memchr (str, 0, maxlen); +- if (end == null) { +- return maxlen; +- } else { +- return (long) (end - str); +- } +- } +- +- [CCode (cname = "g_strndup")] +- static string strndup (char* str, size_t n); +- +- public string substring (long offset, long len = -1) { +- long string_length; +- if (offset >= 0 && len >= 0) { +- // avoid scanning whole string +- string_length = strnlen ((char*) this, offset + len); +- } else { +- string_length = this.length; +- } +- +- if (offset < 0) { +- offset = string_length + offset; +- GLib.return_val_if_fail (offset >= 0, null); +- } else { +- GLib.return_val_if_fail (offset <= string_length, null); +- } +- if (len < 0) { +- len = string_length - offset; +- } +- GLib.return_val_if_fail (offset + len <= string_length, null); +- return strndup ((char*) this + offset, len); +- } +- +- public string slice (long start, long end) { +- long string_length = this.length; +- if (start < 0) { +- start = string_length + start; +- } +- if (end < 0) { +- end = string_length + end; +- } +- GLib.return_val_if_fail (start >= 0 && start <= string_length, null); +- GLib.return_val_if_fail (end >= 0 && end <= string_length, null); +- GLib.return_val_if_fail (start <= end, null); +- return strndup ((char*) this + start, end - start); +- } +- +- public string splice (long start, long end, string? str = null) { +- long string_length = this.length; +- if (start < 0) { +- start = string_length + start; +- } +- if (end < 0) { +- end = string_length + end; +- } +- GLib.return_val_if_fail (start >= 0 && start <= string_length, null); +- GLib.return_val_if_fail (end >= 0 && end <= string_length, null); +- GLib.return_val_if_fail (start <= end, null); +- +- size_t str_size; +- if (str == null) { +- str_size = 0; +- } else { +- str_size = ((!)(str)).length; +- } +- +- string* result = GLib.malloc0 (string_length - (end - start) + str_size + 1); +- +- char* dest = (char*) result; +- +- GLib.Memory.copy (dest, this, start); +- dest += start; +- +- GLib.Memory.copy (dest, str, str_size); +- dest += str_size; +- +- GLib.Memory.copy (dest, (char*) this + end, string_length - end); +- +- return (owned) result; +- } +- +- public bool contains (string needle) { +- return strstr ((char*) this, (char*) needle) != null; +- } +- +- public string replace (string old, string replacement) { +- if (*((char*) this) == '\0' || *((char*) old) == '\0' || old == replacement) +- return this; +- +- try { +- var regex = new GLib.Regex (GLib.Regex.escape_string (old)); +- return regex.replace_literal (this, -1, 0, replacement); +- } catch (GLib.RegexError e) { +- GLib.assert_not_reached (); +- } +- } +- +- [CCode (cname = "g_utf8_strlen")] +- public int char_count (ssize_t max = -1); +- +- public int length { +- [CCode (cname = "strlen")] +- get; +- } +- +- public uint8[] data { +- get { +- unowned uint8[] res = (uint8[]) this; +- res.length = (int) this.length; +- return res; +- } +- } +- +- public char[] to_utf8 () { +- var string_length = this.length; +- char[] result = new char[string_length + 1]; +- result.length--; +- GLib.Memory.copy (result, this, string_length); +- return result; +- } +- +- public unowned string to_string () { +- return this; +- } +- +- [CCode (cname = "g_utf8_to_utf16")] +- public string16 to_utf16 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- [CCode (cname = "g_utf8_to_ucs4")] +- public string32 to_utf32 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- [CCode (cname = "g_utf8_to_ucs4_fast")] +- public string32 to_utf32_fast (long len = -1, out long items_written = null); +- +-} +- +-[Compact] +-[Immutable] +-[GIR (name = "gunichar")] +-[CCode (cname = "gunichar", const_cname = "const gunichar", free_function = "g_free", cheader_filename = "glib.h")] +-public class string32 { +- [CCode (cname = "g_ucs4_to_utf16")] +- public string16 to_utf16 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- [CCode (cname = "g_ucs4_to_utf8")] +- public string to_utf8 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- +- public string? to_string () { +- try { +- return this.to_utf8 (); +- } catch (GLib.ConvertError e) { +- return null; +- } +- } +-} +- +-[Compact] +-[Immutable] +-[GIR (name = "guint16")] +-[CCode (cname = "gunichar2", const_cname = "const gunichar2", free_function = "g_free", cheader_filename = "glib.h")] +-public class string16 { +- [CCode (cname = "g_utf16_to_ucs4")] +- public string32 to_utf32 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- [CCode (cname = "g_utf16_to_utf8")] +- public string to_utf8 (long len = -1, out long items_read = null, out long items_written = null) throws GLib.ConvertError; +- +- public string? to_string () { +- try { +- return this.to_utf8 (); +- } catch (GLib.ConvertError e) { +- return null; +- } +- } +-} +- +-[CCode (cprefix = "G", lower_case_cprefix = "g_", cheader_filename = "glib.h", gir_namespace = "GLib", gir_version = "2.0")] +-namespace GLib { +- [PointerType] +- [GIR (fullname = "gpointer")] +- [CCode (cname = "gpointer", const_cname = "gconstpointer", cheader_filename = "glib.h")] +- public struct pointer { +- } +- +- [CCode (lower_case_cprefix = "", cheader_filename = "math.h")] +- namespace Math { +- [CCode (cname = "G_E")] +- public const double E; +- +- [CCode (cname = "G_PI")] +- public const double PI; +- +- [CCode (cname = "G_LN2")] +- public const double LN2; +- +- [CCode (cname = "G_LN10")] +- public const double LN10; +- +- [CCode (cname = "G_PI_2")] +- public const double PI_2; +- +- [CCode (cname = "G_PI_4")] +- public const double PI_4; +- +- [CCode (cname = "G_SQRT2")] +- public const double SQRT2; +- +- [CCode (cname = "G_LOG_2_BASE_10")] +- public const double LOG_2_BASE_10; +- +- /* generated from of glibc */ +- public static double acos (double x); +- public static float acosf (float x); +- public static double asin (double x); +- public static float asinf (float x); +- public static double atan (double x); +- public static float atanf (float x); +- public static double atan2 (double y, double x); +- public static float atan2f (float y, float x); +- public static double cos (double x); +- public static float cosf (float x); +- public static double sin (double x); +- public static float sinf (float x); +- public static double tan (double x); +- public static float tanf (float x); +- public static double cosh (double x); +- public static float coshf (float x); +- public static double sinh (double x); +- public static float sinhf (float x); +- public static double tanh (double x); +- public static float tanhf (float x); +- public static void sincos (double x, out double sinx, out double cosx); +- public static void sincosf (float x, out float sinx, out float cosx); +- public static double acosh (double x); +- public static float acoshf (float x); +- public static double asinh (double x); +- public static float asinhf (float x); +- public static double atanh (double x); +- public static float atanhf (float x); +- public static double exp (double x); +- public static float expf (float x); +- public static double frexp (double x, out int exponent); +- public static float frexpf (float x, out int exponent); +- public static double ldexp (double x, int exponent); +- public static float ldexpf (float x, int exponent); +- public static double log (double x); +- public static float logf (float x); +- public static double log10 (double x); +- public static float log10f (float x); +- public static double modf (double x, out double iptr); +- public static float modff (float x, out float iptr); +- [CCode (feature_test_macro = "_GNU_SOURCE")] +- public static double exp10 (double x); +- [CCode (feature_test_macro = "_GNU_SOURCE")] +- public static float exp10f (float x); +- [CCode (feature_test_macro = "_GNU_SOURCE")] +- public static double pow10 (double x); +- [CCode (feature_test_macro = "_GNU_SOURCE")] +- public static float pow10f (float x); +- public static double expm1 (double x); +- public static float expm1f (float x); +- public static double log1p (double x); +- public static float log1pf (float x); +- public static double logb (double x); +- public static float logbf (float x); +- public static double exp2 (double x); +- public static float exp2f (float x); +- public static double log2 (double x); +- public static float log2f (float x); +- public static double pow (double x, double y); +- public static float powf (float x, float y); +- public static double sqrt (double x); +- public static float sqrtf (float x); +- public static double hypot (double x, double y); +- public static float hypotf (float x, float y); +- public static double cbrt (double x); +- public static float cbrtf (float x); +- public static double ceil (double x); +- public static float ceilf (float x); +- public static double fabs (double x); +- public static float fabsf (float x); +- public static double floor (double x); +- public static float floorf (float x); +- public static double fmod (double x, double y); +- public static float fmodf (float x, float y); +- public static int isinf (double value); +- public static int isinff (float value); +- public static int finite (double value); +- public static int finitef (float value); +- public static double drem (double x, double y); +- public static float dremf (float x, float y); +- public static double significand (double x); +- public static float significandf (float x); +- public static double copysign (double x, double y); +- public static float copysignf (float x, float y); +- public static double nan (string tagb); +- public static float nanf (string tagb); +- public static int isnan (double value); +- public static int isnanf (float value); +- public static double j0 (double x0); +- public static float j0f (float x0); +- public static double j1 (double x0); +- public static float j1f (float x0); +- public static double jn (int x0, double x1); +- public static float jnf (int x0, float x1); +- public static double y0 (double x0); +- public static float y0f (float x0); +- public static double y1 (double x0); +- public static float y1f (float x0); +- public static double yn (int x0, double x1); +- public static float ynf (int x0, float x1); +- public static double erf (double x0); +- public static float erff (float x0); +- public static double erfc (double x0); +- public static float erfcf (float x0); +- public static double lgamma (double x0); +- public static float lgammaf (float x0); +- public static double tgamma (double x0); +- public static float tgammaf (float x0); +- public static double gamma (double x0); +- public static float gammaf (float x0); +- public static double lgamma_r (double x0, out int signgamp); +- public static float lgamma_rf (float x0, out int signgamp); +- public static double rint (double x); +- public static float rintf (float x); +- public static double nextafter (double x, double y); +- public static float nextafterf (float x, float y); +- public static double nexttoward (double x, double y); +- public static float nexttowardf (float x, double y); +- public static double remainder (double x, double y); +- public static float remainderf (float x, float y); +- public static double scalbn (double x, int n); +- public static float scalbnf (float x, int n); +- public static int ilogb (double x); +- public static int ilogbf (float x); +- public static double scalbln (double x, long n); +- public static float scalblnf (float x, long n); +- public static double nearbyint (double x); +- public static float nearbyintf (float x); +- public static double round (double x); +- public static float roundf (float x); +- public static double trunc (double x); +- public static float truncf (float x); +- public static double remquo (double x, double y, out int quo); +- public static float remquof (float x, float y, out int quo); +- public static long lrint (double x); +- public static long lrintf (float x); +- public static int64 llrint (double x); +- public static int64 llrintf (float x); +- public static long lround (double x); +- public static long lroundf (float x); +- public static int64 llround (double x); +- public static int64 llroundf (float x); +- public static double fdim (double x, double y); +- public static float fdimf (float x, float y); +- public static double fmax (double x, double y); +- public static float fmaxf (float x, float y); +- public static double fmin (double x, double y); +- public static float fminf (float x, float y); +- public static double fma (double x, double y, double z); +- public static float fmaf (float x, float y, float z); +- public static double scalb (double x, double n); +- public static float scalbf (float x, float n); +- } +- +- /* Byte order */ +- [CCode (cprefix = "G_", cname = "int", has_type_id = false)] +- public enum ByteOrder { +- [CCode (cname = "G_BYTE_ORDER")] +- HOST, +- LITTLE_ENDIAN, +- BIG_ENDIAN, +- PDP_ENDIAN +- } +- +- public const ByteOrder BYTE_ORDER; +- +- /* Atomic Operations */ +- +- [Version (since = "2.4")] +- namespace AtomicInt { +- public static int get ([CCode (type = "volatile gint *")] ref int atomic); +- public static void set ([CCode (type = "volatile gint *")] ref int atomic, int newval); +- [Version (since = "2.30")] +- public static int add ([CCode (type = "volatile gint *")] ref int atomic, int val); +- [Version (deprecated_since = "2.30", replacement = "add")] +- public static int exchange_and_add ([CCode (type = "volatile gint *")] ref int atomic, int val); +- public static bool compare_and_exchange ([CCode (type = "volatile gint *")] ref int atomic, int oldval, int newval); +- public static void inc ([CCode (type = "volatile gint *")] ref int atomic); +- public static bool dec_and_test ([CCode (type = "volatile gint *")] ref int atomic); +- } +- +- [Version (since = "2.4")] +- namespace AtomicPointer { +- public static void* get ([CCode (type = "volatile gpointer *")] void** atomic); +- public static void set ([CCode (type = "volatile gpointer *")] void** atomic, void* newval); +- public static bool compare_and_exchange ([CCode (type = "volatile gpointer *")] void** atomic, void* oldval, void* newval); +- } +- +- /* The Main Event Loop */ +- +- [Compact] +- [CCode (ref_function = "g_main_loop_ref", unref_function = "g_main_loop_unref")] +- public class MainLoop { +- public MainLoop (MainContext? context = null, bool is_running = false); +- public void run (); +- public void quit (); +- public bool is_running (); +- public unowned MainContext get_context (); +- } +- +- namespace Priority { +- public const int HIGH; +- public const int DEFAULT; +- public const int HIGH_IDLE; +- public const int DEFAULT_IDLE; +- public const int LOW; +- } +- +- [Compact] +- [CCode (ref_function = "g_main_context_ref", unref_function = "g_main_context_unref")] +- public class MainContext { +- public MainContext (); +- public static unowned MainContext @default (); +- public bool iteration (bool may_block); +- public bool pending (); +- public unowned Source find_source_by_id (uint source_id); +- public unowned Source find_source_by_user_data (void* user_data); +- public unowned Source find_source_by_funcs_user_data (SourceFuncs funcs, void* user_data); +- public void wakeup (); +- public bool acquire (); +- public void release (); +- [Version (since = "2.10")] +- public bool is_owner (); +- public bool wait (Cond cond, Mutex mutex); +- public bool prepare (out int priority); +- public int query (int max_priority, out int timeout_, PollFD[] fds); +- public bool check (int max_priority, PollFD[] fds); +- public void dispatch (); +- public void set_poll_func (PollFunc func); +- public PollFunc get_poll_func (); +- public void add_poll (ref PollFD fd, int priority); +- public void remove_poll (ref PollFD fd); +- public int depth (); +- [Version (since = "2.12")] +- [CCode (cname = "g_main_current_source")] +- public static unowned Source current_source (); +- [Version (since = "2.22")] +- public static unowned MainContext? get_thread_default (); +- [Version (since = "2.32")] +- public static MainContext ref_thread_default (); +- [Version (since = "2.22")] +- public void push_thread_default (); +- [Version (since = "2.22")] +- public void pop_thread_default (); +- [Version (since = "2.28")] +- [CCode (cname = "g_main_context_invoke_full")] +- public void invoke (owned SourceFunc function, [CCode (pos = 0.1)] int priority = Priority.DEFAULT); +- [Version (since = "2.28")] +- public void invoke_full (int priority, owned SourceFunc function); +- } +- +- [CCode (has_target = false)] +- public delegate int PollFunc (PollFD[] ufds, int timeout_); +- +- [CCode (cname = "GSource")] +- public class TimeoutSource : Source { +- public TimeoutSource (uint interval); +- [Version (since = "2.14")] +- public TimeoutSource.seconds (uint interval); +- } +- +- namespace Timeout { +- [CCode (cname = "g_timeout_add_full")] +- public static uint add (uint interval, owned SourceFunc function, [CCode (pos = 0.1)] int priority = Priority.DEFAULT); +- public static uint add_full (int priority, uint interval, owned SourceFunc function); +- [Version (since = "2.14")] +- [CCode (cname = "g_timeout_add_seconds_full")] +- public static uint add_seconds (uint interval, owned SourceFunc function, [CCode (pos = 0.1)] int priority = Priority.DEFAULT); +- [Version (since = "2.14")] +- public static uint add_seconds_full (int priority, uint interval, owned SourceFunc function); +- } +- +- [CCode (cname = "GSource")] +- public class IdleSource : Source { +- public IdleSource (); +- } +- +- namespace Idle { +- [CCode (cname = "g_idle_add_full")] +- public static uint add (owned SourceFunc function, [CCode (pos = 0.1)] int priority = Priority.DEFAULT_IDLE); +- public static uint add_full (int priority, owned SourceFunc function); +- public static bool remove_by_data (void* data); +- } +- +- [CCode (type_id = "G_TYPE_INT", marshaller_type_name = "INT", get_value_function = "g_value_get_int", set_value_function = "g_value_set_int", default_value = "0")] +- [IntegerType (rank = 6)] +- public struct Pid : int { +- [CCode (cname = "G_PID_FORMAT")] +- [Version (since = "2.50")] +- public const string FORMAT; +- } +- +- public delegate void ChildWatchFunc (Pid pid, int status); +- +- [CCode (cname = "GSource")] +- public class ChildWatchSource : Source { +- public ChildWatchSource (Pid pid); +- } +- +- namespace ChildWatch { +- [Version (since = "2.4")] +- [CCode (cname = "g_child_watch_add_full")] +- public static uint add (Pid pid, owned ChildWatchFunc function, [CCode (pos = 0.1)] int priority = Priority.DEFAULT_IDLE); +- [Version (since = "2.4")] +- public static uint add_full (int priority, Pid pid, owned ChildWatchFunc function); +- } +- +- public struct PollFD { +- public int fd; +- public IOCondition events; +- public IOCondition revents; +- } +- +- [Compact] +- [CCode (ref_function = "g_source_ref", unref_function = "g_source_unref")] +- public abstract class Source { +- protected Source (); +- [Version (since = "2.12")] +- public void set_funcs (SourceFuncs funcs); +- public uint attach (MainContext? context = null); +- public void destroy (); +- [Version (since = "2.12")] +- public bool is_destroyed (); +- public void set_priority (int priority); +- public int get_priority (); +- public void set_can_recurse (bool can_recurse); +- public bool get_can_recurse (); +- public uint get_id (); +- [Version (since = "2.26")] +- public unowned string? get_name (); +- [Version (since = "2.26")] +- public void set_name (string? name); +- [Version (since = "2.26")] +- public static void set_name_by_id (uint tag, string? name); +- public unowned MainContext get_context (); +- public void set_callback (owned SourceFunc func); +- public void set_callback_indirect (void* callback_data, SourceCallbackFuncs callback_funcs); +- [Version (since = "2.36")] +- public void* add_unix_fd (int fd, IOCondition events); +- [Version (since = "2.36")] +- public void remove_unix_fd (void* tag); +- [Version (since = "2.36")] +- public void modify_unix_fd (void* tag, IOCondition new_events); +- [Version (since = "2.36")] +- public IOCondition query_unix_fd (void* tag); +- public void add_poll (ref PollFD fd); +- public void remove_poll (ref PollFD fd); +- [Version (since = "2.28")] +- public void add_child_source (Source child_source); +- [Version (since = "2.28")] +- public void remove_child_source (Source child_source); +- [Version (since = "2.28")] +- public int64 get_time (); +- [Version (deprecated_since = "2.28", replacement = "get_time")] +- public void get_current_time (out TimeVal timeval); +- [Version (since = "2.36")] +- public void set_ready_time (int64 ready_time); +- public int64 get_ready_time (); +- public static bool remove (uint id); +- public static bool remove_by_funcs_user_data (void* user_data); +- public static bool remove_by_user_data (void* user_data); +- [Version (since = "2.32")] +- [CCode (cname = "G_SOURCE_CONTINUE")] +- public const bool CONTINUE; +- [Version (since = "2.32")] +- [CCode (cname = "G_SOURCE_REMOVE")] +- public const bool REMOVE; +- +- protected abstract bool prepare (out int timeout_); +- protected abstract bool check (); +- protected abstract bool dispatch (SourceFunc? _callback); +- } +- +- [CCode (has_target = false)] +- public delegate void SourceDummyMarshal (); +- +- [CCode (has_target = false)] +- public delegate bool SourcePrepareFunc (Source source, out int timeout_); +- [CCode (has_target = false)] +- public delegate bool SourceCheckFunc (Source source); +- [CCode (has_target = false)] +- public delegate bool SourceDispatchFunc (Source source, SourceFunc? _callback); +- [CCode (has_target = false)] +- public delegate void SourceFinalizeFunc (Source source); +- +- public struct SourceFuncs { +- public SourcePrepareFunc prepare; +- public SourceCheckFunc check; +- public SourceDispatchFunc dispatch; +- public SourceFinalizeFunc finalize; +- } +- +- [CCode (has_target = false)] +- public delegate void SourceCallbackRefFunc (void* cb_data); +- [CCode (has_target = false)] +- public delegate void SourceCallbackUnrefFunc (void* cb_data); +- [CCode (has_target = false)] +- public delegate void SourceCallbackGetFunc (void* cb_data, Source source, SourceFunc func); +- +- [Compact] +- public class SourceCallbackFuncs { +- public SourceCallbackRefFunc @ref; +- public SourceCallbackUnrefFunc unref; +- public SourceCallbackGetFunc @get; +- } +- +- public delegate bool SourceFunc (); +- +- public errordomain ThreadError { +- AGAIN; +- public static GLib.Quark quark (); +- } +- +- /* Thread support */ +- +- [CCode (scope = "async")] +- public delegate G ThreadFunc (); +- public delegate void Func (G data); +- +- [Version (since = "2.36")] +- public uint get_num_processors (); +- +- [CCode (has_type_id = false)] +- public enum ThreadPriority { +- LOW, +- NORMAL, +- HIGH, +- URGENT +- } +- +- [Compact] +- [Version (since = "2.32")] +- [CCode (ref_function = "g_thread_ref", unref_function = "g_thread_unref")] +- public class Thread { +- [Version (since = "2.32")] +- public Thread (string? name, owned ThreadFunc func); +- [Version (since = "2.32")] +- [CCode (cname = "g_thread_try_new")] +- public Thread.try (string? name, owned ThreadFunc func) throws GLib.Error; +- public static bool supported (); +- [Version (deprecated_since = "2.32", replacement = "new Thread ()")] +- [CCode (simple_generics = true)] +- public static unowned Thread create (owned ThreadFunc func, bool joinable) throws ThreadError; +- [Version (deprecated_since = "2.32", replacement = "new Thread ()")] +- [CCode (simple_generics = true)] +- public static unowned Thread create_full (owned ThreadFunc func, ulong stack_size, bool joinable, bool bound, ThreadPriority priority) throws ThreadError; +- [CCode (simple_generics = true)] +- public static unowned Thread self (); +- [DestroysInstance] +- public T join (); +- [Version (deprecated_since = "2.32")] +- public void set_priority (ThreadPriority priority); +- public static void yield (); +- public static void exit (T retval); +- [Version (deprecated_since = "2.32", since = "2.10")] +- public static void @foreach (Func thread_func); +- +- [CCode (cname = "g_usleep")] +- public static void usleep (ulong microseconds); +- } +- +- [Version (since = "2.32")] +- [CCode (destroy_function = "g_mutex_clear", lvalue_access = false)] +- public struct Mutex { +- public Mutex (); +- public void @lock (); +- public bool trylock (); +- public void unlock (); +- } +- +- [Version (since = "2.44")] +- [CCode (destroy_function = "g_mutex_locker_free")] +- public struct MutexLocker { +- public MutexLocker (Mutex mutex); +- public void free (); +- } +- +- [Version (since = "2.32")] +- [CCode (destroy_function = "g_rec_mutex_clear")] +- public struct RecMutex { +- public RecMutex (); +- public void lock (); +- public bool trylock (); +- public void unlock (); +- } +- +- [Version (since = "2.32")] +- [CCode (destroy_function = "g_rw_lock_clear")] +- public struct RWLock { +- public RWLock (); +- public void writer_lock (); +- public bool writer_trylock (); +- public void writer_unlock (); +- public void reader_lock (); +- public bool reader_trylock (); +- public void reader_unlock (); +- } +- +- [Version (deprecated_since = "2.32", replacement = "Mutex")] +- [CCode (destroy_function = "g_static_mutex_free", default_value = "G_STATIC_MUTEX_INIT")] +- public struct StaticMutex { +- public StaticMutex (); +- public void lock (); +- public bool trylock (); +- public void unlock (); +- public void lock_full (); +- } +- +- [Version (deprecated_since = "2.32", replacement = "RecMutex")] +- [CCode (destroy_function = "g_static_rec_mutex_free", default_value = "G_STATIC_REC_MUTEX_INIT")] +- public struct StaticRecMutex { +- public StaticRecMutex (); +- public void lock (); +- public bool trylock (); +- public void unlock (); +- public void lock_full (); +- } +- +- [Version (deprecated_since = "2.32", replacement = "RWLock")] +- [CCode (destroy_function = "g_static_rw_lock_free", default_value = "G_STATIC_RW_LOCK_INIT")] +- public struct StaticRWLock { +- public StaticRWLock (); +- public void reader_lock (); +- public bool reader_trylock (); +- public void reader_unlock (); +- public void writer_lock (); +- public bool writer_trylock (); +- public void writer_unlock (); +- } +- +- [Compact] +- [CCode (ref_function = "", unref_function = "")] +- public class Private { +- public Private (DestroyNotify? destroy_func = null); +- public void* get (); +- public void set (void* data); +- public void replace (void* data); +- } +- +- [CCode (destroy_function = "g_static_private_free", default_value = "G_STATIC_PRIVATE_INIT")] +- [Version (deprecated_since = "2.32")] +- public struct StaticPrivate { +- public StaticPrivate (); +- public void* get (); +- public void set (void* data, DestroyNotify? destroy_func); +- } +- +- [Version (since = "2.32")] +- [CCode (destroy_function = "g_cond_clear", lvalue_access = false)] +- public struct Cond { +- public Cond (); +- public void @signal (); +- public void broadcast (); +- public void wait (Mutex mutex); +- [Version (deprecated_since = "2.32", replacement = "wait_until")] +- public bool timed_wait (Mutex mutex, TimeVal abs_time); +- [Version (since = "2.32")] +- public bool wait_until (Mutex mutex, int64 end_time); +- } +- +- [CCode (cname = "GThreadFunc")] +- public delegate G OnceFunc (); +- +- [Version (since = "2.4")] +- [CCode (default_value = "G_ONCE_INIT")] +- public struct Once { +- [CCode (cname = "g_once")] +- public unowned G once (OnceFunc function); +- [Version (since = "2.14")] +- public static bool init_enter ([CCode (type="volatile gsize *")] size_t *value); +- [Version (since = "2.14")] +- public static void init_leave ([CCode (type="volatile gsize *")] size_t *value, size_t set_value); +- public OnceStatus status; +- } +- +- [CCode (cprefix = "G_ONCE_STATUS_", has_type_id = false)] +- public enum OnceStatus { +- NOTCALLED, +- PROGRESS, +- READY +- } +- +- /* Thread Pools */ +- +- [CCode (cname = "GFunc")] +- public delegate void ThreadPoolFunc (owned G data); +- +- [Compact] +- [CCode (free_function = "g_thread_pool_free")] +- public class ThreadPool { +- [Version (deprecated_since = "vala-0.18", replacement = "ThreadPool.with_owned_data")] +- public ThreadPool (Func func, int max_threads, bool exclusive) throws ThreadError; +- [CCode (cname = "g_thread_pool_new")] +- public ThreadPool.with_owned_data (ThreadPoolFunc func, int max_threads, bool exclusive) throws ThreadError; +- [Version (deprecated_since = "vala-0.18", replacement = "add")] +- public void push (T data) throws ThreadError; +- [CCode (cname = "g_thread_pool_push")] +- public void add (owned T data) throws ThreadError; +- public void set_max_threads (int max_threads) throws ThreadError; +- public int get_max_threads (); +- public uint get_num_threads (); +- [Version (since = "2.46")] +- public bool move_to_front (T data); +- public uint unprocessed (); +- [CCode (cname = "g_thread_pool_free")] +- void _free (bool immediate, bool wait); +- [CCode (cname = "vala__g_thread_pool_free_wrapper")] +- public static void free (owned ThreadPool? pool, bool immediate, bool wait) { +- ThreadPool* ptr = (owned) pool; +- if (ptr != null) { +- ((ThreadPool)ptr)._free (immediate, wait); +- } +- } +- public static void set_max_unused_threads (int max_threads); +- public static int get_max_unused_threads (); +- public static uint get_num_unused_threads (); +- public static void stop_unused_threads (); +- [Version (since = "2.10")] +- public void set_sort_function (CompareDataFunc func); +- [Version (since = "2.10")] +- public static void set_max_idle_time (uint interval); +- [Version (since = "2.10")] +- public static uint get_max_idle_time (); +- } +- +- /* Asynchronous Queues */ +- +- [Compact] +- [CCode (ref_function = "g_async_queue_ref", unref_function = "g_async_queue_unref")] +- public class AsyncQueue { +- [Version (since = "2.16")] +- [CCode (cname = "g_async_queue_new_full", simple_generics = true)] +- public AsyncQueue (); +- public void push (owned G data); +- [Version (since = "2.10")] +- public void push_sorted (owned G data, CompareDataFunc func); +- public G pop (); +- public G? try_pop (); +- public G? timed_pop (ref TimeVal end_time); +- public int length (); +- [Version (since = "2.10")] +- public void sort (CompareDataFunc func); +- public void @lock (); +- public void unlock (); +- public void ref_unlocked (); +- public void unref_and_unlock (); +- [Version (since = "2.46")] +- public void push_front (owned G data); +- [Version (since = "2.46")] +- public void push_front_unlocked (owned G data); +- public void push_unlocked (owned G data); +- [Version (since = "2.10")] +- public void push_sorted_unlocked (owned G data, CompareDataFunc func); +- public G pop_unlocked (); +- [Version (since = "2.46")] +- public bool remove (G data); +- [Version (since = "2.46")] +- public bool remove_unlocked (G data); +- public G? try_pop_unlocked (); +- public G? timed_pop_unlocked (ref TimeVal end_time); +- public G? timeout_pop (uint64 timeout); +- public G? timeout_pop_unlocked (uint64 timeout); +- public int length_unlocked (); +- public void sort_unlocked (CompareDataFunc func); +- } +- +- /* Memory Allocation */ +- +- public static void* malloc (size_t n_bytes); +- public static void* malloc0 (size_t n_bytes); +- public static void* realloc (void* mem, size_t n_bytes); +- +- public static void* try_malloc (size_t n_bytes); +- [Version (since = "2.8")] +- public static void* try_malloc0 (size_t n_bytes); +- public static void* try_realloc (void* mem, size_t n_bytes); +- +- public static void free (void* mem); +- +- public class MemVTable { +- } +- +- [CCode (cname = "glib_mem_profiler_table")] +- public static MemVTable mem_profiler_table; +- +- public static void mem_set_vtable (MemVTable vtable); +- public static void mem_profile (); +- +- [CCode (cheader_filename = "string.h")] +- namespace Memory { +- [CCode (cname = "memcmp")] +- public static int cmp (void* s1, void* s2, size_t n); +- [CCode (cname = "memcpy")] +- public static void* copy (void* dest, void* src, size_t n); +- [CCode (cname = "memset")] +- public static void* set (void* dest, int src, size_t n); +- [CCode (cname = "g_memmove")] +- public static void* move (void* dest, void* src, size_t n); +- [CCode (cname = "g_memdup")] +- public static void* dup (void* mem, uint n); +- } +- +- [Version (since = "2.10")] +- namespace Slice { +- public static void* alloc (size_t block_size); +- public static void* alloc0 (size_t block_size); +- [Version (since = "2.14")] +- public static void* copy (size_t block_size, void* mem_block); +- [CCode (cname = "g_slice_free1")] +- public static void free (size_t block_size, void* mem_block); +- public static void free_chain_with_offset (size_t block_size, void *mem_chain, size_t next_offset); +- public static int64 get_config (SliceConfig ckey); +- [CCode (array_length_cname = "n_values", array_length_type = "guint")] +- public static int64[] get_config_state (SliceConfig ckey, int64 address); +- public static void set_config (SliceConfig ckey, int64 value); +- } +- +- [CCode (cprefix = "G_SLICE_CONFIG_", has_type_id = false)] +- public enum SliceConfig { +- ALWAYS_MALLOC, +- BYPASS_MAGAZINES, +- WORKING_SET_MSECS, +- COLOR_INCREMENT, +- CHUNK_SIZES, +- CONTENTION_COUNTER +- } +- +- /* IO Channels */ +- +- [Compact] +- [CCode (ref_function = "g_io_channel_ref", unref_function = "g_io_channel_unref")] +- public class IOChannel { +- [CCode (cname = "g_io_channel_unix_new")] +- public IOChannel.unix_new (int fd); +- public int unix_get_fd (); +- [CCode (cname = "g_io_channel_win32_new_fd")] +- public IOChannel.win32_new_fd (int fd); +- [CCode (cname = "g_io_channel_win32_new_socket")] +- public IOChannel.win32_socket (int socket); +- [CCode (cname = "g_io_channel_win32_new_messages")] +- public IOChannel.win32_messages (size_t hwnd); +- public void init (); +- public IOChannel.file (string filename, string mode) throws FileError; +- public IOStatus read_chars (char[] buf, out size_t bytes_read) throws ConvertError, IOChannelError; +- public IOStatus read_unichar (out unichar thechar) throws ConvertError, IOChannelError; +- public IOStatus read_line (out string str_return, out size_t length, out size_t terminator_pos) throws ConvertError, IOChannelError; +- public IOStatus read_line_string (StringBuilder buffer, out size_t terminator_pos) throws ConvertError, IOChannelError; +- public IOStatus read_to_end (out string str_return, out size_t length) throws ConvertError, IOChannelError; +- public IOStatus write_chars (char[] buf, out size_t bytes_written) throws ConvertError, IOChannelError; +- public IOStatus write_unichar (unichar thechar) throws ConvertError, IOChannelError; +- public IOStatus flush () throws IOChannelError; +- public IOStatus seek_position (int64 offset, SeekType type) throws IOChannelError; +- public IOStatus shutdown (bool flush) throws IOChannelError; +- [CCode (cname = "g_io_create_watch")] +- public IOSource create_watch (IOCondition condition); +- [CCode (cname = "g_io_add_watch")] +- public uint add_watch (IOCondition condition, IOFunc func); +- [CCode (cname = "g_io_add_watch_full")] +- public uint add_watch_full (int priority, IOCondition condition, owned IOFunc func); +- public size_t get_buffer_size (); +- public void set_buffer_size (size_t size); +- public IOCondition get_buffer_condition (); +- public IOFlags get_flags (); +- public IOStatus set_flags (IOFlags flags) throws IOChannelError; +- public unowned string get_line_term (out int length); +- public void set_line_term (string line_term, int length); +- public bool get_buffered (); +- public void set_buffered (bool buffered); +- public unowned string get_encoding (); +- public IOStatus set_encoding (string? encoding) throws IOChannelError; +- public bool get_close_on_unref (); +- public void set_close_on_unref (bool do_close); +- } +- +- [Compact] +- [CCode (cname = "GSource")] +- public class IOSource : Source { +- [CCode (cname = "g_io_create_watch")] +- public IOSource (IOChannel channel, IOCondition condition); +- [CCode (cname = "g_source_set_callback")] +- public void set_callback ([CCode (type = "GSourceFunc")] owned IOFunc func); +- } +- +- [CCode (cprefix = "G_SEEK_", has_type_id = false)] +- public enum SeekType { +- CUR, +- SET, +- END +- } +- +- [CCode (has_type_id = false)] +- public enum IOStatus { +- ERROR, +- NORMAL, +- EOF, +- AGAIN +- } +- +- public errordomain IOChannelError { +- FBIG, +- INVAL, +- IO, +- ISDIR, +- NOSPC, +- NXIO, +- OVERFLOW, +- PIPE, +- FAILED; +- public static GLib.Quark quark (); +- } +- +- [Flags] +- [CCode (cprefix = "G_IO_")] +- public enum IOCondition { +- IN, +- OUT, +- PRI, +- ERR, +- HUP, +- NVAL +- } +- +- public delegate bool IOFunc (IOChannel source, IOCondition condition); +- +- [CCode (cprefix = "G_IO_FLAG_", has_type_id = false)] +- [Flags] +- public enum IOFlags { +- APPEND, +- NONBLOCK, +- IS_READABLE, +- IS_WRITABLE, +- IS_WRITEABLE, +- IS_SEEKABLE, +- MASK, +- GET_MASK, +- SET_MASK +- } +- +- /* Error Reporting */ +- +- [Compact] +- [ErrorBase] +- [CCode (copy_function = "g_error_copy", free_function = "g_error_free")] +- public class Error { +- [PrintfFormat] +- public Error (Quark domain, int code, string format, ...); +- public Error.literal (Quark domain, int code, string message); +- [PrintfFormat] +- public Error.valist (Quark domain, int code, string format, va_list args); +- public Error copy (); +- public bool matches (Quark domain, int code); +- [CCode (cname = "g_prefix_error")] +- public static void prefix (out Error? dest, string format, ...); +- [CCode (cname = "g_propagate_error")] +- public static void propagate (out Error? dest, owned Error src); +- [CCode (cname = "g_propagate_prefixed_error")] +- public static void propagate_prefixed (out Error? dest, owned Error src, string format, ...); +- [CCode (cname = "g_set_error")] +- public static void @set (out Error? dest, Quark domain, int code, string format, ...); +- [CCode (cname = "g_set_error_literal")] +- public static void set_literal (out Error? dest, Quark domain, int code, string message); +- +- public Quark domain; +- public int code; +- public string message; +- } +- +- /* Message Output and Debugging Functions */ +- +- [PrintfFormat] +- public static void print (string format, ...); +- public static void set_print_handler (PrintFunc func); +- [CCode (has_target = false)] +- public delegate void PrintFunc (string text); +- [PrintfFormat] +- public static void printerr (string format, ...); +- public static void set_printerr_handler (PrintFunc func); +- +- public static void return_if_fail (bool expr); +- [CCode (sentinel = "")] +- public static void return_val_if_fail (bool expr, ...); +- [NoReturn] +- public static void return_if_reached (); +- [NoReturn] +- [CCode (sentinel = "")] +- public static void return_val_if_reached (...); +- [Version (since = "2.16")] +- public static void warn_if_fail (bool expr); +- [Version (since = "2.16")] +- public static void warn_if_reached (); +- +- [Assert] +- public static void assert (bool expr); +- [Assert] +- [Version (since = "2.46")] +- public static void assert_cmpmem (uint8[] m1, uint8[] m2); +- [Assert] +- public static void assert_error (Error? error, Quark error_domain, int error_code); +- [Assert] +- [Version (since = "2.38")] +- public static void assert_false (bool expr); +- [Assert] +- [Version (since = "2.38")] +- public static void assert_true (bool expr); +- [Assert] +- [Version (since = "2.38")] +- public static void assert_null (void* expr); +- [Assert] +- public static void assert_no_error (Error? error); +- [Assert] +- [Version (since = "2.40")] +- public static void assert_nonnull (void* expr); +- [NoReturn] +- public static void assert_not_reached (); +- +- public static void on_error_query (string? prg_name = null); +- public static void on_error_stack_trace (string? prg_name = null); +- [CCode (cname = "G_BREAKPOINT")] +- public static void breakpoint (); +- +- /* Message Logging */ +- +- [CCode (cprefix = "G_LOG_", has_type_id = false)] +- [Flags] +- public enum LogLevelFlags { +- /* log flags */ +- FLAG_RECURSION, +- FLAG_FATAL, +- +- /* GLib log levels */ +- LEVEL_ERROR, +- LEVEL_CRITICAL, +- LEVEL_WARNING, +- LEVEL_MESSAGE, +- LEVEL_INFO, +- LEVEL_DEBUG, +- +- LEVEL_MASK +- } +- +- [CCode (cprefix = "G_LOG_WRITER_", has_type_id = false)] +- [Version (since = "2.50")] +- public enum LogWriterOutput { +- HANDLED, +- UNHANDLED +- } +- +- [CCode (has_type_id = false, simple_generics = true)] +- [Version (since = "2.50")] +- public struct LogField { +- public unowned string key; +- public unowned T @value; +- public ssize_t length; +- } +- +- public void logv (string? log_domain, LogLevelFlags log_level, string format, va_list args); +- [Diagnostics] +- [PrintfFormat] +- public void log (string? log_domain, LogLevelFlags log_level, string format, ...); +- +- [Version (since = "2.50")] +- public void log_structured (string? log_domain, LogLevelFlags log_levels, ...); +- [Version (since = "2.50")] +- public void log_structured_array (LogLevelFlags log_levels, LogField[] fields); +- +- [Version (since = "2.50")] +- public void log_variant (string? log_domain, LogLevelFlags log_levels, GLib.Variant fields); +- +- [Diagnostics] +- [PrintfFormat] +- public void message (string format, ...); +- [Diagnostics] +- [PrintfFormat] +- public void warning (string format, ...); +- [Diagnostics] +- [PrintfFormat] +- public void critical (string format, ...); +- [Diagnostics] +- [PrintfFormat] +- [NoReturn] +- public void error (string format, ...); +- [Diagnostics] +- [PrintfFormat] +- [Version (since = "2.6")] +- public void debug (string format, ...); +- [Diagnostics] +- [PrintfFormat] +- [Version (since = "2.40")] +- public void info (string format, ...); +- [CCode (cname = "G_DEBUG_HERE")] +- [Version (since = "2.50")] +- public void debug_here (); +- +- public delegate void LogFunc (string? log_domain, LogLevelFlags log_levels, string message); +- [Version (since = "2.50")] +- public delegate LogWriterOutput LogWriterFunc (LogLevelFlags log_level, LogField[] fields); +- +- namespace Log { +- public static uint set_handler (string? log_domain, LogLevelFlags log_levels, LogFunc log_func); +- [Version (since = "2.46")] +- public static void set_handler_full (string? log_domain, LogLevelFlags log_levels, owned LogFunc log_func); +- [Version (since = "2.6")] +- public static void set_default_handler (LogFunc log_func); +- [CCode (delegate_target = false)] +- public static GLib.LogFunc default_handler; +- public static LogLevelFlags set_fatal_mask (string log_domain, LogLevelFlags log_levels); +- public static LogLevelFlags set_always_fatal (LogLevelFlags log_levels); +- public static void remove_handler (string? log_domain, uint handler_id); +- +- public const string FILE; +- public const int LINE; +- public const string METHOD; +- +- [Version (since = "2.50")] +- public static void set_writer_func (owned LogWriterFunc func); +- [Version (since = "2.50")] +- public static bool writer_supports_color (int output_fd); +- [Version (since = "2.50")] +- public static bool writer_is_journald (int output_fd); +- [Version (since = "2.50")] +- public static string writer_format_fields (LogLevelFlags log_levels, LogField[] fields, bool use_color); +- [Version (since = "2.50")] +- public static LogWriterOutput writer_journald (LogLevelFlags log_levels, LogField[] fields, void* user_data); +- [Version (since = "2.50")] +- public static LogWriterOutput writer_standard_streams (LogLevelFlags log_levels, LogField[] fields, void* user_data); +- [Version (since = "2.50")] +- public static LogWriterOutput writer_default (LogLevelFlags log_levels, LogField[] fields, void* user_data); +- } +- +- [CCode (has_type_id = false)] +- public struct DebugKey { +- unowned string key; +- uint value; +- } +- +- public uint parse_debug_string (string? debug_string, DebugKey[] keys); +- +- /* String Utility Functions */ +- +- public string strdup (string str); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] strdupv ([CCode (array_length = false, array_null_terminated = true)] string[] str_array); +- +- public void strfreev (string** str_array); +- [Version (since = "2.6")] +- public uint strv_length ([CCode (array_length = false, array_null_terminated = true)] string[] str_array); +- [Version (since = "2.44")] +- public bool strv_contains ([CCode (array_length = false, array_null_terminated = true)] string[] str_array, string str); +- +- [CCode (cname = "errno", cheader_filename = "errno.h")] +- public int errno; +- public unowned string strerror (int errnum); +- +- /* Character Set Conversions */ +- +- public static string convert (string str, ssize_t len, string to_codeset, string from_codeset, out size_t bytes_read = null, out size_t bytes_written = null) throws ConvertError; +- public static string convert_with_fallback (string str, ssize_t len, string to_codeset, string from_codeset, string? fallback = null, out size_t bytes_read = null, out size_t bytes_written = null) throws ConvertError; +- public static string convert_with_iconv (string str, ssize_t len, IConv converter, out size_t bytes_read = null, out size_t bytes_written = null) throws ConvertError; +- public static bool get_charset (out unowned string charset); +- public static bool get_filename_charsets ([CCode (array_length = false, array_null_terminated = true)] out unowned string[] charsets); +- +- [SimpleType] +- public struct IConv { +- public static IConv open (string to_codeset, string from_codeset); +- [CCode (cname = "g_iconv")] +- public size_t iconv ([CCode (array_length = false)] ref char[] inbuf, ref size_t inbytes_left, [CCode (array_length = false)] ref char[] outbuf, ref size_t outbytes_left); +- public int close (); +- } +- +- namespace Filename { +- public static string to_utf8 (string opsysstring, ssize_t len, out size_t bytes_read, out size_t bytes_written) throws ConvertError; +- public static string from_utf8 (string utf8string, ssize_t len, out size_t bytes_read, out size_t bytes_written) throws ConvertError; +- public static string from_uri (string uri, out string hostname = null) throws ConvertError; +- public static string to_uri (string filename, string? hostname = null) throws ConvertError; +- [Version (since = "2.6")] +- public static string display_name (string filename); +- [Version (since = "2.6")] +- public static string display_basename (string filename); +- [Version (cname = "g_canonicalize_filename", since = "2.58")] +- public static string canonicalize (string filename, string? relative_to = null); +- } +- +- public errordomain ConvertError { +- NO_CONVERSION, +- ILLEGAL_SEQUENCE, +- FAILED, +- PARTIAL_INPUT, +- BAD_URI, +- NOT_ABSOLUTE_PATH; +- public static GLib.Quark quark (); +- } +- +- /* Base64 Encoding */ +- +- [Version (since = "2.12")] +- namespace Base64 { +- public static size_t encode_step (uchar[] _in, bool break_lines, char* _out, ref int state, ref int save); +- public static size_t encode_close (bool break_lines, char* _out, ref int state, ref int save); +- public static string encode (uchar[] data); +- public static size_t decode_step (char[] _in, uchar* _out, ref int state, ref uint save); +- [CCode (array_length_type = "size_t")] +- public static uchar[] decode (string text); +- } +- +- /* Data Checksums */ +- +- [Version (since = "2.16")] +- [CCode (cprefix = "G_CHECKSUM_", has_type_id = false)] +- public enum ChecksumType { +- MD5, +- SHA1, +- SHA256, +- [Version (since = "2.52")] +- SHA384, +- [Version (since = "2.36")] +- SHA512; +- +- public ssize_t get_length (); +- } +- +- [Compact] +- [Version (since = "2.16")] +- [CCode (free_function = "g_checksum_free")] +- public class Checksum { +- public Checksum (ChecksumType checksum_type); +- public Checksum copy (); +- public void update ([CCode (array_length = false)] uchar[] data, size_t length); +- public unowned string get_string (); +- public void get_digest ([CCode (array_length = false)] uint8[] buffer, ref size_t digest_len); +- [CCode (cname = "g_compute_checksum_for_data")] +- public static string compute_for_data (ChecksumType checksum_type, uchar[] data); +- [CCode (cname = "g_compute_checksum_for_string")] +- public static string compute_for_string (ChecksumType checksum_type, string str, size_t length = -1); +- [Version (since = "2.34")] +- [CCode (cname = "g_compute_checksum_for_bytes")] +- public static string compute_for_bytes (ChecksumType checksum_type, Bytes data); +- } +- +- /* Secure HMAC Digests */ +- +- [Compact] +- [Version (since = "2.30")] +- [CCode (ref_function = "g_hmac_ref", unref_function = "g_hmac_unref")] +- public class Hmac { +- public Hmac (ChecksumType digest_type, [CCode (array_length_type = "gsize")] uint8[] key); +- public Hmac copy (); +- public void update ([CCode (array_length_type = "gssize")] uint8[] data); +- public unowned string get_string (); +- public void get_digest ([CCode (array_length = false)] uint8[] buffer, ref size_t digest_len); +- [Version (since = "2.30")] +- [CCode (cname = "g_compute_hmac_for_data")] +- public static string compute_for_data (ChecksumType checksum_type, uint8[] key, uint8[] data); +- [Version (since = "2.30")] +- [CCode (cname = "g_compute_hmac_for_string")] +- public static string compute_for_string (ChecksumType checksum_type, uint8[] key, string str, size_t length = -1); +- [Version (since = "2.50")] +- [CCode (cname = "g_compute_hmac_for_bytes")] +- public static string compute_hmac_for_bytes (ChecksumType checksum_type, Bytes key, Bytes data); +- } +- +- /* Date and Time Functions */ +- +- [CCode (has_type_id = false)] +- public struct TimeVal { +- public long tv_sec; +- public long tv_usec; +- +- [CCode (cname = "g_get_current_time")] +- public TimeVal (); +- [CCode (cname = "g_get_current_time")] +- public void get_current_time (); +- public void add (long microseconds); +- [Version (since = "2.12")] +- [CCode (instance_pos = -1)] +- public bool from_iso8601 (string iso_date); +- [Version (since = "2.12")] +- public string to_iso8601 (); +- } +- +- [Version (since = "2.28")] +- public static int64 get_monotonic_time (); +- [Version (since = "2.28")] +- public static int64 get_real_time (); +- +- public struct DateDay : uchar { +- [CCode (cname = "G_DATE_BAD_DAY")] +- public static DateDay BAD_DAY; +- +- [CCode (cname = "g_date_valid_day")] +- public bool valid (); +- } +- +- [CCode (cprefix = "G_DATE_", has_type_id = false)] +- public enum DateMonth { +- BAD_MONTH, +- JANUARY, +- FEBRUARY, +- MARCH, +- APRIL, +- MAY, +- JUNE, +- JULY, +- AUGUST, +- SEPTEMBER, +- OCTOBER, +- NOVEMBER, +- DECEMBER; +- +- [CCode (cname = "g_date_get_days_in_month")] +- public uchar get_days_in_month (DateYear year); +- [CCode (cname = "g_date_valid_month")] +- public bool valid (); +- } +- +- public struct DateYear : ushort { +- [CCode (cname = "G_DATE_BAD_YEAR")] +- public static DateDay BAD_YEAR; +- +- [CCode (cname = "g_date_is_leap_year")] +- public bool is_leap_year (); +- [CCode (cname = "g_date_get_monday_weeks_in_year")] +- public uchar get_monday_weeks_in_year (); +- [CCode (cname = "g_date_get_sunday_weeks_in_year")] +- public uchar get_sunday_weeks_in_year (); +- [CCode (cname = "g_date_valid_year")] +- public bool valid (); +- } +- +- [CCode (cprefix = "G_DATE_", has_type_id = false)] +- public enum DateWeekday { +- BAD_WEEKDAY, +- MONDAY, +- TUESDAY, +- WEDNESDAY, +- THURSDAY, +- FRIDAY, +- SATURDAY, +- SUNDAY; +- +- [CCode (cname = "g_date_valid_weekday")] +- public bool valid (); +- } +- +- [CCode (cprefix = "G_DATE_", has_type_id = false)] +- public enum DateDMY { +- DAY, +- MONTH, +- YEAR +- } +- +- [CCode (type_id = "G_TYPE_DATE")] +- public struct Date { +- public void clear (uint n_dates = 1); +- [Version (since = "2.56")] +- public Date copy (); +- public void set_day (DateDay day); +- public void set_month (DateMonth month); +- public void set_year (DateYear year); +- public void set_dmy (DateDay day, int month, DateYear y); +- public void set_julian (uint julian_day); +- [Version (since = "2.10")] +- public void set_time_t (time_t timet); +- [Version (since = "2.10")] +- public void set_time_val (TimeVal timeval); +- public void set_parse (string str); +- public void add_days (uint n_days); +- public void subtract_days (uint n_days); +- public void add_months (uint n_months); +- public void subtract_months (uint n_months); +- public void add_years (uint n_years); +- public void subtract_years (uint n_years); +- public int days_between (Date date2); +- public int compare (Date rhs); +- public void clamp (Date min_date, Date max_date); +- public void order (Date date2); +- public DateDay get_day (); +- public DateMonth get_month (); +- public DateYear get_year (); +- public uint get_julian (); +- public DateWeekday get_weekday (); +- public uint get_day_of_year (); +- public bool is_first_of_month (); +- public bool is_last_of_month (); +- public uint get_monday_week_of_year (); +- public uint get_sunday_week_of_year (); +- [Version (since = "2.6")] +- public uint get_iso8601_week_of_year (); +- [CCode (instance_pos = -1)] +- public size_t strftime (char[] s, string format); +- [CCode (cname = "g_date_to_struct_tm")] +- public void to_time (out Time tm); +- public bool valid (); +- public static uchar get_days_in_month (DateMonth month, DateYear year); +- public static bool valid_day (DateDay day); +- public static bool valid_dmy (DateDay day, DateMonth month, DateYear year); +- public static bool valid_julian (uint julian_date); +- public static bool valid_weekday (DateWeekday weekday); +- } +- +- [CCode (cname = "struct tm", cheader_filename = "time.h", has_type_id = false)] +- public struct Time { +- [CCode (cname = "tm_sec")] +- public int second; +- [CCode (cname = "tm_min")] +- public int minute; +- [CCode (cname = "tm_hour")] +- public int hour; +- [CCode (cname = "tm_mday")] +- public int day; +- [CCode (cname = "tm_mon")] +- public int month; +- [CCode (cname = "tm_year")] +- public int year; +- [CCode (cname = "tm_wday")] +- public int weekday; +- [CCode (cname = "tm_yday")] +- public int day_of_year; +- [CCode (cname = "tm_isdst")] +- public int isdst; +- +- [CCode (cname = "gmtime_r", feature_test_macro = "_XOPEN_SOURCE")] +- static void gmtime_r (ref time_t time, out Time result); +- [CCode (cname = "localtime_r", feature_test_macro = "_XOPEN_SOURCE")] +- static void localtime_r (ref time_t time, out Time result); +- +- public static Time gm (time_t time) { +- Time result; +- gmtime_r (ref time, out result); +- return result; +- } +- public static Time local (time_t time) { +- Time result; +- localtime_r (ref time, out result); +- return result; +- } +- +- public string to_string () { +- return "%04d-%02d-%02d %02d:%02d:%02d".printf (year + 1900, month + 1, day, hour, minute, second); +- } +- +- public string format (string format) { +- var buffer = new char[64]; +- this.strftime (buffer, format); +- return (string) buffer; +- } +- +- [CCode (cname = "mktime")] +- public time_t mktime (); +- +- [CCode (cname = "strftime", instance_pos = -1)] +- public size_t strftime (char[] s, string format); +- [CCode (cname = "strptime", instance_pos = -1, feature_test_macro = "_XOPEN_SOURCE")] +- public unowned string? strptime (string buf, string format); +- } +- +- [SimpleType] +- [Version (since = "2.26")] +- [CCode (cheader_filename = "glib.h", type_id = "G_TYPE_INT64", marshaller_type_name = "INT64", get_value_function = "g_value_get_int64", set_value_function = "g_value_set_int64", default_value = "0LL", type_signature = "x")] +- [IntegerType (rank = 10)] +- public struct TimeSpan : int64 { +- public const TimeSpan DAY; +- public const TimeSpan HOUR; +- public const TimeSpan MINUTE; +- public const TimeSpan SECOND; +- public const TimeSpan MILLISECOND; +- } +- +- [Compact] +- [Version (since = "2.26")] +- [CCode (ref_function = "g_date_time_ref", unref_function = "g_date_time_unref", type_id = "G_TYPE_DATE_TIME")] +- public class DateTime { +- public DateTime.now (TimeZone tz = new TimeZone.local ()); +- public DateTime.now_local (); +- public DateTime.now_utc (); +- [Version (since = "2.56")] +- public DateTime.from_iso8601 (string text, TimeZone default_tz); +- public DateTime.from_unix_local (int64 t); +- public DateTime.from_unix_utc (int64 t); +- public DateTime.from_timeval_local (TimeVal tv); +- public DateTime.from_timeval_utc (TimeVal tv); +- public DateTime (TimeZone tz, int year, int month, int day, int hour, int minute, double seconds); +- public DateTime.local (int year, int month, int day, int hour, int minute, double seconds); +- public DateTime.utc (int year, int month, int day, int hour, int minute, double seconds); +- public DateTime add (TimeSpan timespan); +- public DateTime add_years (int years); +- public DateTime add_months (int months); +- public DateTime add_weeks (int weeks); +- public DateTime add_days (int days); +- public DateTime add_hours (int hours); +- public DateTime add_minutes (int minutes); +- public DateTime add_seconds (double seconds); +- public DateTime add_full (int years, int months, int days, int hours = 0, int minutes = 0, double seconds = 0); +- public int compare (DateTime dt); +- public TimeSpan difference (DateTime begin); +- public uint hash (); +- public bool equal (DateTime dt); +- public void get_ymd (out int year, out int month, out int day); +- public int get_year (); +- public int get_month (); +- public int get_day_of_month (); +- public int get_week_numbering_year (); +- public int get_week_of_year (); +- public int get_day_of_week (); +- public int get_day_of_year (); +- public int get_hour (); +- public int get_minute (); +- public int get_second (); +- public int get_microsecond (); +- public double get_seconds (); +- [Version (since = "2.58")] +- public unowned TimeZone get_timezone (); +- public int64 to_unix (); +- public bool to_timeval (out TimeVal tv); +- public TimeSpan get_utc_offset (); +- public unowned string get_timezone_abbreviation (); +- public bool is_daylight_savings (); +- public DateTime to_timezone (TimeZone tz); +- public DateTime to_local (); +- public DateTime to_utc (); +- public string format (string format); +- public string to_string () { +- return this.format ("%FT%H:%M:%S%z"); +- } +- } +- +- public enum TimeType { +- STANDARD, +- DAYLIGHT, +- UNIVERSAL +- } +- +- [Compact] +- [Version (since = "2.26")] +- [CCode (ref_function = "g_time_zone_ref", unref_function = "g_time_zone_unref")] +- public class TimeZone { +- public TimeZone (string identifier); +- public TimeZone.utc (); +- public TimeZone.local (); +- [Version (since = "2.58")] +- public TimeZone.offset (int32 seconds); +- public int find_interval (TimeType type, int64 time); +- public int adjust_time (TimeType type, ref int64 time); +- public unowned string get_abbreviation (int interval); +- [Version (since = "2.58")] +- public unowned string get_identifier (); +- public int32 get_offset (int interval); +- public bool is_dst (int interval); +- } +- +- /* Random Numbers */ +- +- [Compact] +- [CCode (copy_function = "g_rand_copy", free_function = "g_rand_free")] +- public class Rand { +- public Rand.with_seed (uint32 seed); +- [Version (since = "2.4")] +- public Rand.with_seed_array ([CCode (array_length = false)] uint32[] seed, uint seed_length); +- public Rand (); +- public void set_seed (uint32 seed); +- [Version (since = "2.4")] +- public void set_seed_array ([CCode (array_length = false)] uint32[] seed, uint seed_length); +- public bool boolean (); +- [CCode (cname = "g_rand_int")] +- public uint32 next_int (); +- public int32 int_range (int32 begin, int32 end); +- [CCode (cname = "g_rand_double")] +- public double next_double (); +- public double double_range (double begin, double end); +- } +- +- namespace Random { +- public static void set_seed (uint32 seed); +- public static bool boolean (); +- [CCode (cname = "g_random_int")] +- public static uint32 next_int (); +- public static int32 int_range (int32 begin, int32 end); +- [CCode (cname = "g_random_double")] +- public static double next_double (); +- public static double double_range (double begin, double end); +- } +- +- namespace Uuid { +- [Version (since = "2.52")] +- public static bool string_is_valid (string str); +- [Version (since = "2.52")] +- public static string string_random (); +- } +- +- /* Miscellaneous Utility Functions */ +- +- namespace Environment { +- [Version (since = "2.2")] +- [CCode (cname = "g_get_application_name")] +- public static unowned string? get_application_name (); +- [Version (since = "2.2")] +- [CCode (cname = "g_set_application_name")] +- public static void set_application_name (string application_name); +- [CCode (cname = "g_get_prgname")] +- public static unowned string get_prgname (); +- [CCode (cname = "g_set_prgname")] +- public static void set_prgname (string application_name); +- [CCode (cname = "g_getenv")] +- public static unowned string? get_variable (string variable); +- [Version (since = "2.4")] +- [CCode (cname = "g_setenv")] +- public static bool set_variable (string variable, string value, bool overwrite); +- [Version (since = "2.4")] +- [CCode (cname = "g_unsetenv")] +- public static void unset_variable (string variable); +- [Version (since = "2.8")] +- [CCode (cname = "g_listenv", array_length = false, array_null_terminated = true)] +- public static string[] list_variables (); +- [CCode (cname = "g_get_user_name")] +- public static unowned string get_user_name (); +- [CCode (cname = "g_get_real_name")] +- public static unowned string get_real_name (); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_user_cache_dir")] +- public static unowned string get_user_cache_dir (); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_user_data_dir")] +- public static unowned string get_user_data_dir (); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_user_config_dir")] +- public static unowned string get_user_config_dir (); +- [CCode (cname = "g_get_user_runtime_dir")] +- public static unowned string get_user_runtime_dir (); +- [Version (since = "2.14")] +- [CCode (cname = "g_get_user_special_dir")] +- public static unowned string get_user_special_dir (UserDirectory directory); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_system_data_dirs", array_length = false, array_null_terminated = true)] +- public static unowned string[] get_system_data_dirs (); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_system_config_dirs", array_length = false, array_null_terminated = true)] +- public static unowned string[] get_system_config_dirs (); +- [Version (since = "2.8")] +- [CCode (cname = "g_get_host_name")] +- public static unowned string get_host_name (); +- [CCode (cname = "g_get_home_dir")] +- public static unowned string get_home_dir (); +- [CCode (cname = "g_get_tmp_dir")] +- public static unowned string get_tmp_dir (); +- [CCode (cname = "g_get_current_dir")] +- public static string get_current_dir (); +- [CCode (cname = "g_find_program_in_path")] +- public static string? find_program_in_path (string program); +- [Version (deprecated_since = "2.32")] +- [CCode (cname = "g_atexit")] +- public static void atexit (VoidFunc func); +- [Version (since = "2.8")] +- [CCode (cname = "g_chdir")] +- public static int set_current_dir (string path); +- } +- +- namespace Environ { +- [Version (since = "2.28")] +- [CCode (cname = "g_get_environ", array_length = false, array_null_terminated = true)] +- public static string[] get (); +- [Version (since = "2.32")] +- [CCode (cname = "g_environ_getenv")] +- public static unowned string? get_variable ([CCode (array_length = false, array_null_terminated = true)] string[]? envp, string variable); +- [Version (since = "2.32")] +- [CCode (cname = "g_environ_setenv", array_length = false, array_null_terminated = true)] +- public static string[] set_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[]? envp, string variable, string value, bool overwrite = true); +- [Version (since = "2.32")] +- [CCode (cname = "g_environ_unsetenv", array_length = false, array_null_terminated = true)] +- public static string[] unset_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[]? envp, string variable); +- } +- +- [Version (since = "2.14")] +- [CCode (has_type_id = false)] +- public enum UserDirectory { +- DESKTOP, +- DOCUMENTS, +- DOWNLOAD, +- MUSIC, +- PICTURES, +- PUBLIC_SHARE, +- TEMPLATES, +- VIDEOS, +- [CCode (cname = "G_USER_N_DIRECTORIES")] +- N_DIRECTORIES +- } +- +- namespace Hostname { +- public static bool is_non_ascii (string hostname); +- public static bool is_ascii_encoded (string hostname); +- public static bool is_ip_address (string hostname); +- public static string to_ascii (string hostname); +- public static string to_unicode (string hostname); +- } +- +- namespace Path { +- public static bool is_absolute (string file_name); +- public static unowned string skip_root (string file_name); +- public static string get_basename (string file_name); +- public static string get_dirname (string file_name); +- [CCode (cname = "g_build_filename")] +- public static string build_filename (string first_element, ...); +- [Version (since = "2.56")] +- [CCode (cname = "g_build_filename_valist")] +- public static string build_filename_valist (string first_element, va_list args); +- [CCode (cname = "g_build_path")] +- public static string build_path (string separator, string first_element, ...); +- +- [CCode (cname = "G_DIR_SEPARATOR")] +- public const char DIR_SEPARATOR; +- [CCode (cname = "G_DIR_SEPARATOR_S")] +- public const string DIR_SEPARATOR_S; +- [Version (since = "2.6")] +- [CCode (cname = "G_IS_DIR_SEPARATOR")] +- public static bool is_dir_separator (unichar c); +- [CCode (cname = "G_SEARCHPATH_SEPARATOR")] +- public const char SEARCHPATH_SEPARATOR; +- [CCode (cname = "G_SEARCHPATH_SEPARATOR_S")] +- public const string SEARCHPATH_SEPARATOR_S; +- } +- +- namespace Bit { +- public static int nth_lsf (ulong mask, int nth_bit); +- public static int nth_msf (ulong mask, int nth_bit); +- public static uint storage (ulong number); +- } +- +- namespace SpacedPrimes { +- public static uint closest (uint num); +- } +- +- [CCode (has_target = false)] +- public delegate void FreeFunc (void* data); +- [CCode (has_target = false)] +- public delegate void VoidFunc (); +- +- [Version (deprecated_since = "2.30", replacement = "format_size", since = "2.16")] +- public string format_size_for_display (int64 size); +- +- [Version (since = "2.30")] +- [CCode (cname = "g_format_size_full")] +- public string format_size (uint64 size, FormatSizeFlags flags = FormatSizeFlags.DEFAULT); +- +- [Version (since = "2.30")] +- [CCode (cprefix = "G_FORMAT_SIZE_", has_type_id = false)] +- [Flags] +- public enum FormatSizeFlags { +- DEFAULT, +- LONG_FORMAT, +- IEC_UNITS +- } +- +- /* Lexical Scanner */ +- [CCode (has_target = false)] +- public delegate void ScannerMsgFunc (Scanner scanner, string message, bool error); +- +- [Compact] +- [CCode (free_function = "g_scanner_destroy")] +- public class Scanner { +- public unowned string input_name; +- public TokenType token; +- public TokenValue value; +- public uint line; +- public uint position; +- public TokenType next_token; +- public TokenValue next_value; +- public uint next_line; +- public uint next_position; +- public ScannerMsgFunc msg_handler; +- public ScannerConfig? config; +- public Scanner (ScannerConfig? config_templ); +- public void input_file (int input_fd); +- public void sync_file_offset (); +- public void input_text (string text, uint text_len); +- public TokenType peek_next_token (); +- public TokenType get_next_token (); +- public bool eof (); +- public int cur_line (); +- public int cur_position (); +- public TokenType cur_token (); +- public TokenValue cur_value (); +- public uint set_scope (uint scope_id); +- public void scope_add_symbol (uint scope_id, string symbol, void* value); +- public void scope_foreach_symbol (uint scope_id, HFunc func); +- public void* scope_lookup_symbol (uint scope_id, string symbol); +- public void scope_remove_symbol (uint scope_id, string symbol); +- public void* lookup_symbol (string symbol); +- [PrintfFormat] +- public void warn (string format, ...); +- [PrintfFormat] +- public void error (string format, ...); +- public void unexp_token (TokenType expected_token, string? identifier_spec, string? symbol_spec, string? symbol_name, string? message, bool is_error); +- } +- +- public struct ScannerConfig { +- public string* cset_skip_characters; +- public string* cset_identifier_first; +- public string* cset_identifier_nth; +- public string* cpair_comment_single; +- public bool case_sensitive; +- public bool skip_comment_multi; +- public bool skip_comment_single; +- public bool scan_comment_multi; +- public bool scan_identifier; +- public bool scan_identifier_1char; +- public bool scan_identifier_NULL; +- public bool scan_symbols; +- public bool scan_binary; +- public bool scan_octal; +- public bool scan_float; +- public bool scan_hex; +- public bool scan_hex_dollar; +- public bool scan_string_sq; +- public bool scan_string_dq; +- public bool numbers_2_int; +- public bool int_2_float; +- public bool identifier_2_string; +- public bool char_2_token; +- public bool symbol_2_token; +- public bool scope_0_fallback; +- public bool store_int64; +- } +- +- [CCode (lower_case_cprefix="G_CSET_")] +- namespace CharacterSet { +- public const string A_2_Z; +- public const string a_2_z; +- public const string DIGITS; +- public const string LATINC; +- public const string LATINS; +- } +- +- [CCode (cprefix = "G_TOKEN_", has_type_id = false)] +- public enum TokenType { +- EOF, +- LEFT_PAREN, +- RIGHT_PAREN, +- LEFT_CURLY, +- RIGHT_CURLY, +- LEFT_BRACE, +- RIGHT_BRACE, +- EQUAL_SIGN, +- COMMA, +- NONE, +- ERROR, +- CHAR, +- BINARY, +- OCTAL, +- INT, +- HEX, +- FLOAT, +- STRING, +- SYMBOL, +- IDENTIFIER, +- IDENTIFIER_NULL, +- COMMENT_SINGLE, +- COMMENT_MULTI, +- LAST +- } +- +- [SimpleType] +- public struct TokenValue { +- [CCode (cname="v_symbol")] +- public void* symbol; +- [CCode (cname="v_identifier")] +- public unowned string identifier; +- [CCode (cname="v_binary")] +- public ulong binary; +- [CCode (cname="v_octal")] +- public ulong octal; +- [CCode (cname="v_int")] +- public ulong int; +- [CCode (cname="v_int64")] +- public ulong int64; +- [CCode (cname="v_float")] +- public double float; +- [CCode (cname="v_hex")] +- public ulong hex; +- [CCode (cname="v_string")] +- public unowned string string; +- [CCode (cname="v_comment")] +- public unowned string comment; +- [CCode (cname="v_char")] +- public uchar char; +- [CCode (cname="v_error")] +- public uint error; +- } +- +- [CCode (cprefix = "G_ERR_", has_type_id = false)] +- public enum ErrorType { +- UNKNOWN, +- UNEXP_EOF, +- UNEXP_EOF_IN_STRING, +- UNEXP_EOF_IN_COMMENT, +- NON_DIGIT_IN_CONST, +- DIGIT_RADIX, +- FLOAT_RADIX, +- FLOAT_MALFORMED +- } +- +- /* Automatic String Completion */ +- +- [Version (deprecated_since = "2.26")] +- [Compact] +- [CCode (free_function = "g_completion_free")] +- public class Completion { +- public Completion (CompletionFunc? func = null); +- public List items; +- public CompletionFunc func; +- public string prefix; +- public List cache; +- public CompletionStrncmpFunc strncmp_func; +- public void add_items (List items); +- public void remove_items (List items); +- public void clear_items (); +- public unowned List complete (string prefix, out string? new_prefix = null); +- [Version (since = "2.4")] +- public unowned List complete_utf8 (string prefix, out string? new_prefix = null); +- } +- +- [CCode (has_target = false)] +- public delegate string CompletionFunc (void* item); +- [CCode (has_target = false)] +- public delegate int CompletionStrncmpFunc (string s1, string s2, size_t n); +- +- /* Timers */ +- +- [Compact] +- [CCode (free_function = "g_timer_destroy")] +- public class Timer { +- public Timer (); +- public void start (); +- public void stop (); +- [Version (since = "2.4")] +- public void @continue (); +- public double elapsed (out ulong microseconds = null); +- public void reset (); +- } +- +- /* Spawning Processes */ +- +- public errordomain SpawnError { +- FORK, +- READ, +- CHDIR, +- ACCES, +- PERM, +- TOO_BIG, +- NOEXEC, +- NAMETOOLONG, +- NOENT, +- NOMEM, +- NOTDIR, +- LOOP, +- TXTBUSY, +- IO, +- NFILE, +- MFILE, +- INVAL, +- ISDIR, +- LIBBAD, +- FAILED; +- public static GLib.Quark quark (); +- } +- +- [CCode (cprefix = "G_SPAWN_", has_type_id = false)] +- [Flags] +- public enum SpawnFlags { +- LEAVE_DESCRIPTORS_OPEN, +- DO_NOT_REAP_CHILD, +- SEARCH_PATH, +- STDOUT_TO_DEV_NULL, +- STDERR_TO_DEV_NULL, +- CHILD_INHERITS_STDIN, +- FILE_AND_ARGV_ZERO, +- SEARCH_PATH_FROM_ENVP +- } +- +- public delegate void SpawnChildSetupFunc (); +- [CCode (has_target = false, cheader_filename = "signal.h")] +- public delegate void SignalHandlerFunc (int signum); +- +- public unowned string strsignal (int signum); +- +- [CCode (lower_case_cprefix = "g_")] +- namespace Process { +- [Version (since = "2.58")] +- public static bool spawn_async_with_fds (string? working_directory, [CCode (array_length = false, array_null_terminated = true)] string[] argv, [CCode (array_length = false, array_null_terminated = true)] string[]? envp, SpawnFlags _flags, SpawnChildSetupFunc? child_setup, out Pid child_pid = null, int stdin_fd = -1, int stdout_fd = -1, int stderr_fd = -1) throws SpawnError; +- public static bool spawn_async_with_pipes (string? working_directory, [CCode (array_length = false, array_null_terminated = true)] string[] argv, [CCode (array_length = false, array_null_terminated = true)] string[]? envp, SpawnFlags _flags, SpawnChildSetupFunc? child_setup, out Pid child_pid, out int standard_input = null, out int standard_output = null, out int standard_error = null) throws SpawnError; +- public static bool spawn_async (string? working_directory, [CCode (array_length = false, array_null_terminated = true)] string[] argv, [CCode (array_length = false, array_null_terminated = true)] string[]? envp, SpawnFlags _flags, SpawnChildSetupFunc? child_setup, out Pid child_pid) throws SpawnError; +- public static bool spawn_sync (string? working_directory, [CCode (array_length = false, array_null_terminated = true)] string[] argv, [CCode (array_length = false, array_null_terminated = true)] string[]? envp, SpawnFlags _flags, SpawnChildSetupFunc? child_setup, out string standard_output = null, out string standard_error = null, out int exit_status = null) throws SpawnError; +- public static bool spawn_command_line_async (string command_line) throws SpawnError; +- public static bool spawn_command_line_sync (string command_line, out string standard_output = null, out string standard_error = null, out int exit_status = null) throws SpawnError; +- [CCode (cname = "g_spawn_close_pid")] +- public static void close_pid (Pid pid); +- [Version (since = "2.34")] +- [CCode (cname = "g_spawn_check_exit_status")] +- public static bool check_exit_status (int exit_status) throws GLib.Error; +- +- /* these macros are required to examine the exit status of a process */ +- [CCode (cname = "WIFEXITED", cheader_filename = "sys/wait.h")] +- public static bool if_exited (int status); +- [CCode (cname = "WEXITSTATUS", cheader_filename = "sys/wait.h")] +- public static int exit_status (int status); +- [CCode (cname = "WIFSIGNALED", cheader_filename = "sys/wait.h")] +- public static bool if_signaled (int status); +- [CCode (cname = "WTERMSIG", cheader_filename = "sys/wait.h")] +- public static ProcessSignal term_sig (int status); +- [CCode (cname = "WCOREDUMP", cheader_filename = "sys/wait.h")] +- public static bool core_dump (int status); +- [CCode (cname = "WIFSTOPPED", cheader_filename = "sys/wait.h")] +- public static bool if_stopped (int status); +- [CCode (cname = "WSTOPSIG", cheader_filename = "sys/wait.h")] +- public static ProcessSignal stop_sig (int status); +- [CCode (cname = "WIFCONTINUED", cheader_filename = "sys/wait.h")] +- public static bool if_continued (int status); +- +- [NoReturn] +- [CCode (cname = "abort", cheader_filename = "stdlib.h")] +- public void abort (); +- [NoReturn] +- [CCode (cname = "exit", cheader_filename = "stdlib.h")] +- public void exit (int status); +- [CCode (cname = "raise", cheader_filename = "signal.h")] +- public int raise (ProcessSignal sig); +- [CCode (cname = "signal", cheader_filename = "signal.h")] +- public SignalHandlerFunc @signal (ProcessSignal signum, SignalHandlerFunc handler); +- } +- +- [CCode (cname = "int", has_type_id = false, cheader_filename = "signal.h", cprefix = "SIG")] +- public enum ProcessSignal { +- HUP, +- INT, +- QUIT, +- ILL, +- TRAP, +- ABRT, +- BUS, +- FPE, +- KILL, +- SEGV, +- PIPE, +- ALRM, +- TERM, +- USR1, +- USR2, +- CHLD, +- CONT, +- STOP, +- TSTP, +- TTIN, +- TTOU +- } +- +- +- /* File Utilities */ +- +- public errordomain FileError { +- EXIST, +- ISDIR, +- ACCES, +- NAMETOOLONG, +- NOENT, +- NOTDIR, +- NXIO, +- NODEV, +- ROFS, +- TXTBSY, +- FAULT, +- LOOP, +- NOSPC, +- NOMEM, +- MFILE, +- NFILE, +- BADF, +- INVAL, +- PIPE, +- AGAIN, +- INTR, +- IO, +- PERM, +- NOSYS, +- FAILED; +- public static GLib.Quark quark (); +- } +- +- [CCode (has_type_id = false)] +- [Flags] +- public enum FileTest { +- IS_REGULAR, +- IS_SYMLINK, +- IS_DIR, +- IS_EXECUTABLE, +- EXISTS +- } +- +- [CCode (cname = "int", cprefix = "SEEK_", has_type_id = false)] +- public enum FileSeek { +- SET, +- CUR, +- END +- } +- +- [Compact] +- [CCode (cname = "FILE", free_function = "fclose", cheader_filename = "stdio.h")] +- public class FileStream { +- [CCode (cname = "EOF", cheader_filename = "stdio.h")] +- public const int EOF; +- +- [Version (since = "2.6")] +- [CCode (cname = "g_fopen", cheader_filename = "glib/gstdio.h")] +- public static FileStream? open (string path, string mode); +- [CCode (cname = "fdopen")] +- public static FileStream? fdopen (int fildes, string mode); +- [CCode (cname = "fprintf")] +- [PrintfFormat ()] +- public void printf (string format, ...); +- [CCode (cname = "vfprintf")] +- public void vprintf (string format, va_list args); +- [CCode (cname = "fputc", instance_pos = -1)] +- public void putc (char c); +- [CCode (cname = "fputs", instance_pos = -1)] +- public void puts (string s); +- [CCode (cname = "fgetc")] +- public int getc (); +- [CCode (cname = "ungetc", instance_pos = -1)] +- public int ungetc (int c); +- [CCode (cname = "fgets", instance_pos = -1)] +- public unowned string? gets (char[] s); +- [CCode (cname = "feof")] +- public bool eof (); +- [CCode (cname = "fscanf"), ScanfFormat] +- public int scanf (string format, ...); +- [CCode (cname = "fflush")] +- public int flush (); +- [CCode (cname = "fseek")] +- public int seek (long offset, FileSeek whence); +- [CCode (cname = "ftell")] +- public long tell (); +- [CCode (cname = "rewind")] +- public void rewind (); +- [CCode (cname = "fileno")] +- public int fileno (); +- [CCode (cname = "ferror")] +- public int error (); +- [CCode (cname = "clearerr")] +- public void clearerr (); +- [CCode (cname = "fread", instance_pos = -1)] +- public size_t read ([CCode (array_length_pos = 2.1)] uint8[] buf, size_t size = 1); +- [CCode (cname = "fwrite", instance_pos = -1)] +- public size_t write ([CCode (array_length_pos = 2.1)] uint8[] buf, size_t size = 1); +- +- public string? read_line () { +- int c; +- StringBuilder? ret = null; +- while ((c = getc ()) != EOF) { +- if (ret == null) { +- ret = new StringBuilder (); +- } +- if (c == '\n') { +- break; +- } +- ((!)(ret)).append_c ((char) c); +- } +- if (ret == null) { +- return null; +- } else { +- return ((!)(ret)).str; +- } +- } +- } +- +- [CCode (cname = "struct utimbuf", cheader_filename = "sys/types.h,utime.h")] +- public struct UTimBuf { +- time_t actime; /* access time */ +- time_t modtime; /* modification time */ +- } +- +- [CCode (lower_case_cprefix = "g_file_", cheader_filename = "glib/gstdio.h")] +- namespace FileUtils { +- public static bool get_contents (string filename, out string contents, out size_t length = null) throws FileError; +- [Version (since = "2.8")] +- public static bool set_contents (string filename, string contents, ssize_t length = -1) throws FileError; +- [CCode (cname = "g_file_get_contents")] +- public static bool get_data (string filename, [CCode (type = "gchar**", array_length_type = "size_t")] out uint8[] contents) throws FileError; +- [CCode (cname = "g_file_set_contents")] +- public static bool set_data (string filename, [CCode (type = "const char*", array_length_type = "size_t")] uint8[] contents) throws FileError; +- public static bool test (string filename, FileTest test); +- public static int open_tmp (string tmpl, out string name_used) throws FileError; +- [Version (since = "2.4")] +- public static string read_link (string filename) throws FileError; +- public static int error_from_errno (int err_no); +- +- [CCode (cname = "g_mkstemp")] +- public static int mkstemp (string tmpl); +- [Version (since = "2.6")] +- [CCode (cname = "g_rename")] +- public static int rename (string oldfilename, string newfilename); +- [Version (since = "2.6")] +- [CCode (cname = "g_remove")] +- public static int remove (string filename); +- [CCode (cname = "g_unlink")] +- public static int unlink (string filename); +- [Version (since = "2.8")] +- [CCode (cname = "g_chmod")] +- public static int chmod (string filename, int mode); +- [Version (since = "2.18")] +- [CCode (cname = "g_utime")] +- public static int utime (string filename, UTimBuf? times = null); +- +- [CCode (cname = "symlink", cheader_filename = "unistd.h")] +- public static int symlink (string oldpath, string newpath); +- +- [CCode (cname = "close", cheader_filename = "unistd.h")] +- public static int close (int fd); +- +- [Version (since = "2.36")] +- [CCode (cname = "g_close")] +- public static bool close_checked (int fd) throws FileError; +- } +- +- [CCode (cname = "struct stat", cheader_filename = "sys/stat.h,glib/gstdio.h")] +- public struct Stat { +- public time_t st_atime; +- public time_t st_mtime; +- public time_t st_ctime; +- [CCode (cname = "g_stat", instance_pos = -1)] +- public Stat (string filename); +- [Version (since = "2.6")] +- [CCode (cname = "g_lstat", instance_pos = -1)] +- public Stat.l (string filename); +- } +- +- [Compact] +- [CCode (free_function = "g_dir_close")] +- public class Dir { +- public static Dir open (string filename, uint _flags = 0) throws FileError; +- public unowned string? read_name (); +- public void rewind (); +- } +- +- [CCode (cheader_filename = "glib/gstdio.h")] +- namespace DirUtils { +- [Version (since = "2.6")] +- [CCode (cname = "g_mkdir")] +- public static int create (string pathname, int mode); +- [Version (since = "2.8")] +- [CCode (cname = "g_mkdir_with_parents")] +- public static int create_with_parents (string pathname, int mode); +- [Version (since = "2.30")] +- [CCode (cname = "mkdtemp")] +- public static string mkdtemp (owned string template); +- [Version (since = "2.30")] +- [CCode (cname = "g_dir_make_tmp")] +- public static string make_tmp (string tmpl) throws FileError; +- [Version (since = "2.6")] +- [CCode (cname = "g_rmdir")] +- public static int remove (string filename); +- } +- +- [Compact] +- [Version (since = "2.22")] +- [CCode (ref_function = "g_mapped_file_ref", unref_function = "g_mapped_file_unref")] +- public class MappedFile { +- public MappedFile (string filename, bool writable) throws FileError; +- public size_t get_length (); +- public unowned char* get_contents (); +- [Version (since = "2.34")] +- public Bytes get_bytes (); +- } +- +- [CCode (cname = "stdin", cheader_filename = "stdio.h")] +- public static FileStream stdin; +- +- [CCode (cname = "stdout", cheader_filename = "stdio.h")] +- public static FileStream stdout; +- +- [CCode (cname = "stderr", cheader_filename = "stdio.h")] +- public static FileStream stderr; +- +- /* URI Functions */ +- +- namespace Uri { +- public const string RESERVED_CHARS_ALLOWED_IN_PATH; +- public const string RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT; +- public const string RESERVED_CHARS_ALLOWED_IN_USERINFO; +- public const string RESERVED_CHARS_GENERIC_DELIMITERS; +- public const string RESERVED_CHARS_SUBCOMPONENT_DELIMITERS; +- +- [Version (since = "2.16")] +- public static string? parse_scheme (string uri); +- [Version (since = "2.16")] +- public static string escape_string (string unescaped, string? reserved_chars_allowed = null, bool allow_utf8 = true); +- [Version (since = "2.16")] +- public static string? unescape_string (string escaped_string, string? illegal_characters = null); +- [Version (since = "2.16")] +- public static string? unescape_segment (string? escaped_string, string? escaped_string_end, string? illegal_characters = null); +- [Version (since = "2.6")] +- [CCode (array_length = false, array_null_terminated = true)] +- public static string[] list_extract_uris (string uri_list); +- } +- +- /* Shell-related Utilities */ +- +- public errordomain ShellError { +- BAD_QUOTING, +- EMPTY_STRING, +- FAILED; +- public static GLib.Quark quark (); +- } +- +- namespace Shell { +- public static bool parse_argv (string command_line, [CCode (array_length_pos = 1.9)] out string[] argvp) throws ShellError; +- public static string quote (string unquoted_string); +- public static string unquote (string quoted_string) throws ShellError; +- } +- +- /* Commandline option parser */ +- +- public errordomain OptionError { +- UNKNOWN_OPTION, +- BAD_VALUE, +- FAILED; +- public static GLib.Quark quark (); +- } +- +- [Compact] +- [Version (since = "2.6")] +- [CCode (free_function = "g_option_context_free")] +- public class OptionContext { +- public OptionContext (string? parameter_string = null); +- [Version (since = "2.12")] +- public void set_summary (string summary); +- [Version (since = "2.12")] +- public unowned string get_summary (); +- [Version (since = "2.12")] +- public void set_description (string description); +- [Version (since = "2.12")] +- public unowned string get_description (); +- [Version (since = "2.12")] +- public void set_translate_func (TranslateFunc func, DestroyNotify? destroy_notify); +- [Version (since = "2.12")] +- public void set_translation_domain (string domain); +- public bool parse ([CCode (array_length_pos = 0.9)] ref unowned string[] argv) throws OptionError; +- [Version (since = "2.40")] +- public bool parse_strv ([CCode (array_length = false, array_null_terminated = true)] ref string[] argv) throws OptionError; +- public void set_help_enabled (bool help_enabled); +- public bool get_help_enabled (); +- public void set_ignore_unknown_options (bool ignore_unknown); +- public bool get_ignore_unknown_options (); +- [Version (since = "2.14")] +- public string get_help (bool main_help, OptionGroup? group); +- public void add_main_entries ([CCode (array_length = false, array_null_terminated = true)] OptionEntry[] entries, string? translation_domain); +- public void add_group (owned OptionGroup group); +- public void set_main_group (owned OptionGroup group); +- public unowned OptionGroup get_main_group (); +- [Version (since = "2.44")] +- public void set_strict_posix (bool strict_posix); +- [Version (since = "2.44")] +- public bool get_strict_posix (); +- } +- +- public delegate unowned string TranslateFunc (string str); +- +- public const string OPTION_REMAINING; +- +- [CCode (has_type_id = false)] +- public enum OptionArg { +- NONE, +- STRING, +- INT, +- CALLBACK, +- FILENAME, +- STRING_ARRAY, +- FILENAME_ARRAY, +- DOUBLE, +- INT64 +- } +- +- [Flags] +- [CCode (cprefix = "G_OPTION_FLAG_", has_type_id = false)] +- public enum OptionFlags { +- [Version (since = "2.42")] +- NONE, +- HIDDEN, +- IN_MAIN, +- REVERSE, +- NO_ARG, +- FILENAME, +- OPTIONAL_ARG, +- NOALIAS +- } +- +- public struct OptionEntry { +- public unowned string long_name; +- public char short_name; +- public int flags; +- +- public OptionArg arg; +- public void* arg_data; +- +- public unowned string description; +- public unowned string? arg_description; +- } +- +- [Compact] +-#if GLIB_2_44 +- [Version (since = "2.44")] +- [CCode (ref_function = "g_option_group_ref", unref_function = "g_option_group_unref", type_id = "G_TYPE_OPTION_GROUP")] +-#else +- [Version (since = "2.6")] +- [CCode (free_function = "g_option_group_free")] +-#endif +- public class OptionGroup { +- public OptionGroup (string name, string description, string help_description, void* user_data = null, DestroyNotify? destroy = null); +- public void add_entries ([CCode (array_length = false, array_null_terminated = true)] OptionEntry[] entries); +- public void set_parse_hooks (OptionParseFunc? pre_parse_func, OptionParseFunc? post_parse_hook); +- public void set_error_hook (OptionErrorFunc? error_func); +- public void set_translate_func (owned TranslateFunc? func); +- public void set_translation_domain (string domain); +- } +- +- [CCode (has_target = false)] +- public delegate bool OptionParseFunc (OptionContext context, OptionGroup group, void* data) throws OptionError; +- [CCode (has_target = false)] +- public delegate void OptionErrorFunc (OptionContext context, OptionGroup group, void* data, ref Error error); +- [CCode (has_target = false)] +- public delegate bool OptionArgFunc (string option_name, string val, void* data) throws OptionError; +- +- /* Perl-compatible regular expressions */ +- +- [Version (since = "2.14")] +- public errordomain RegexError { +- COMPILE, +- OPTIMIZE, +- REPLACE, +- MATCH, +- INTERNAL, +- STRAY_BACKSLASH, +- MISSING_CONTROL_CHAR, +- UNRECOGNIZED_ESCAPE, +- QUANTIFIERS_OUT_OF_ORDER, +- QUANTIFIER_TOO_BIG, +- UNTERMINATED_CHARACTER_CLASS, +- INVALID_ESCAPE_IN_CHARACTER_CLASS, +- RANGE_OUT_OF_ORDER, +- NOTHING_TO_REPEAT, +- UNRECOGNIZED_CHARACTER, +- POSIX_NAMED_CLASS_OUTSIDE_CLASS, +- UNMATCHED_PARENTHESIS, +- INEXISTENT_SUBPATTERN_REFERENCE, +- UNTERMINATED_COMMENT, +- EXPRESSION_TOO_LARGE, +- MEMORY_ERROR, +- VARIABLE_LENGTH_LOOKBEHIND, +- MALFORMED_CONDITION, +- TOO_MANY_CONDITIONAL_BRANCHES, +- ASSERTION_EXPECTED, +- UNKNOWN_POSIX_CLASS_NAME, +- POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED, +- HEX_CODE_TOO_LARGE, +- INVALID_CONDITION, +- SINGLE_BYTE_MATCH_IN_LOOKBEHIND, +- INFINITE_LOOP, +- MISSING_SUBPATTERN_NAME_TERMINATOR, +- DUPLICATE_SUBPATTERN_NAME, +- MALFORMED_PROPERTY, +- UNKNOWN_PROPERTY, +- SUBPATTERN_NAME_TOO_LONG, +- TOO_MANY_SUBPATTERNS, +- INVALID_OCTAL_VALUE, +- TOO_MANY_BRANCHES_IN_DEFINE, +- DEFINE_REPETION, +- INCONSISTENT_NEWLINE_OPTIONS, +- MISSING_BACK_REFERENCE, +- INVALID_RELATIVE_REFERENCE, +- BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN, +- UNKNOWN_BACKTRACKING_CONTROL_VERB, +- NUMBER_TOO_BIG, +- MISSING_SUBPATTERN_NAME, +- MISSING_DIGIT, +- INVALID_DATA_CHARACTER, +- EXTRA_SUBPATTERN_NAME, +- BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED, +- INVALID_CONTROL_CHAR, +- MISSING_NAME, +- NOT_SUPPORTED_IN_CLASS, +- TOO_MANY_FORWARD_REFERENCES, +- NAME_TOO_LONG, +- CHARACTER_VALUE_TOO_LARGE; +- public static GLib.Quark quark (); +- } +- +- [Version (since = "2.14")] +- [CCode (cprefix = "G_REGEX_", has_type_id = false)] +- [Flags] +- public enum RegexCompileFlags { +- CASELESS, +- MULTILINE, +- DOTALL, +- EXTENDED, +- ANCHORED, +- DOLLAR_ENDONLY, +- UNGREEDY, +- RAW, +- NO_AUTO_CAPTURE, +- OPTIMIZE, +- DUPNAMES, +- NEWLINE_CR, +- NEWLINE_LF, +- NEWLINE_CRLF, +- NEWLINE_ANYCRLF, +- BSR_ANYCRLF, +- JAVASCRIPT_COMPAT +- } +- +- [Version (since = "2.14")] +- [CCode (cprefix = "G_REGEX_MATCH_", has_type_id = false)] +- [Flags] +- public enum RegexMatchFlags { +- ANCHORED, +- NOTBOL, +- NOTEOL, +- NOTEMPTY, +- PARTIAL, +- NEWLINE_CR, +- NEWLINE_LF, +- NEWLINE_CRLF, +- NEWLINE_ANY, +- NEWLINE_ANYCRLF, +- BSR_ANYCRLF, +- BSR_ANY, +- PARTIAL_SOFT, +- PARTIAL_HARD, +- NOTEMPTY_ATSTART +- } +- +- [Compact] +- [Version (since = "2.14")] +- [CCode (ref_function = "g_regex_ref", unref_function = "g_regex_unref", type_id = "G_TYPE_REGEX")] +- public class Regex { +- public Regex (string pattern, RegexCompileFlags compile_options = 0, RegexMatchFlags match_options = 0) throws RegexError; +- public unowned string get_pattern (); +- [Version (since = "2.26")] +- public RegexCompileFlags get_compile_flags (); +- [Version (since = "2.34")] +- public bool get_has_cr_or_lf (); +- [Version (since = "2.26")] +- public RegexMatchFlags get_match_flags (); +- public int get_max_backref (); +- [Version (since = "2.38")] +- public int get_max_lookbehind (); +- public int get_capture_count (); +- public int get_string_number (string name); +- public static string escape_string (string str, int length = -1); +- public static bool match_simple (string pattern, string str, RegexCompileFlags compile_options = 0, RegexMatchFlags match_options = 0); +- public bool match (string str, RegexMatchFlags match_options = 0, out MatchInfo match_info = null); +- public bool match_full (string str, ssize_t string_len = -1, int start_position = 0, RegexMatchFlags match_options = 0, out MatchInfo match_info = null) throws RegexError; +- public bool match_all (string str, RegexMatchFlags match_options = 0, out MatchInfo match_info = null); +- public bool match_all_full (string str, ssize_t string_len = -1, int start_position = 0, RegexMatchFlags match_options = 0, out MatchInfo match_info = null) throws RegexError; +- [CCode (array_length = false, array_null_terminated = true)] +- public static string[] split_simple (string pattern, string str, RegexCompileFlags compile_options = 0, RegexMatchFlags match_options = 0); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] split (string str, RegexMatchFlags match_options = 0); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] split_full (string str, ssize_t string_len = -1, int start_position = 0, RegexMatchFlags match_options = 0, int max_tokens = 0) throws RegexError; +- public string replace (string str, ssize_t string_len, int start_position, string replacement, RegexMatchFlags match_options = 0) throws RegexError; +- public string replace_literal (string str, ssize_t string_len, int start_position, string replacement, RegexMatchFlags match_options = 0) throws RegexError; +- public string replace_eval (string str, ssize_t string_len, int start_position, RegexMatchFlags match_options, RegexEvalCallback eval) throws RegexError; +- public static bool check_replacement (string replacement, out bool has_references = null) throws RegexError; +- } +- +- [Version (since = "2.14")] +- public delegate bool RegexEvalCallback (MatchInfo match_info, StringBuilder result); +- +- [Compact] +- [Version (since = "2.30")] +- [CCode (ref_function = "g_match_info_ref", unref_function = "g_match_info_unref", type_id = "G_TYPE_MATCH_INFO")] +- public class MatchInfo { +- public unowned Regex get_regex (); +- public unowned string get_string (); +- public bool matches (); +- public bool next () throws RegexError; +- public int get_match_count (); +- public bool is_partial_match (); +- public string expand_references (string string_to_expand) throws RegexError; +- public string? fetch (int match_num); +- public bool fetch_pos (int match_num, out int start_pos, out int end_pos); +- public string? fetch_named (string name); +- public bool fetch_named_pos (string name, out int start_pos, out int end_pos); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] fetch_all (); +- } +- +- /* Simple XML Subset Parser +- See http://live.gnome.org/Vala/MarkupSample for an example */ +- +- public errordomain MarkupError { +- BAD_UTF8, +- EMPTY, +- PARSE, +- UNKNOWN_ELEMENT, +- UNKNOWN_ATTRIBUTE, +- INVALID_CONTENT, +- MISSING_ATTRIBUTE; +- public static GLib.Quark quark (); +- } +- +- [CCode (cprefix = "G_MARKUP_", has_type_id = false)] +- [Flags] +- public enum MarkupParseFlags { +- TREAT_CDATA_AS_TEXT, +- PREFIX_ERROR_POSITION +- } +- +- [Compact] +- [Version (since = "2.36")] +- [CCode (ref_function = "g_markup_parse_context_ref", unref_function = "g_markup_parse_context_unref", type_id = "G_TYPE_MARKUP_PARSE_CONTEXT")] +- public class MarkupParseContext { +- public MarkupParseContext (MarkupParser parser, MarkupParseFlags _flags, void* user_data, DestroyNotify? user_data_dnotify); +- public bool parse (string text, ssize_t text_len) throws MarkupError; +- public bool end_parse () throws MarkupError; +- [Version (since = "2.2")] +- public unowned string get_element (); +- [Version (since = "2.16")] +- public unowned SList get_element_stack (); +- public void get_position (out int line_number, out int char_number); +- [Version (since = "2.18")] +- public void push (MarkupParser parser, void* user_data); +- [Version (since = "2.18")] +- public void* pop (); +- [Version (since = "2.18")] +- public void* get_user_data (); +- } +- +- public delegate void MarkupParserStartElementFunc (MarkupParseContext context, string element_name, [CCode (array_length = false, array_null_terminated = true)] string[] attribute_names, [CCode (array_length = false, array_null_terminated = true)] string[] attribute_values) throws MarkupError; +- +- public delegate void MarkupParserEndElementFunc (MarkupParseContext context, string element_name) throws MarkupError; +- +- public delegate void MarkupParserTextFunc (MarkupParseContext context, string text, size_t text_len) throws MarkupError; +- +- public delegate void MarkupParserPassthroughFunc (MarkupParseContext context, string passthrough_text, size_t text_len) throws MarkupError; +- +- public delegate void MarkupParserErrorFunc (MarkupParseContext context, Error error); +- +- public struct MarkupParser { +- [CCode (delegate_target = false)] +- public unowned MarkupParserStartElementFunc start_element; +- [CCode (delegate_target = false)] +- public unowned MarkupParserEndElementFunc end_element; +- [CCode (delegate_target = false)] +- public unowned MarkupParserTextFunc text; +- [CCode (delegate_target = false)] +- public unowned MarkupParserPassthroughFunc passthrough; +- [CCode (delegate_target = false)] +- public unowned MarkupParserErrorFunc error; +- } +- +- namespace Markup { +- [CCode (cprefix = "G_MARKUP_COLLECT_", has_type_id = false)] +- public enum CollectType { +- INVALID, +- STRING, +- STRDUP, +- BOOLEAN, +- TRISTATE, +- OPTIONAL +- } +- +- public static string escape_text (string text, ssize_t length = -1); +- [Version (since = "2.4")] +- [PrintfFormat] +- public static string printf_escaped (string format, ...); +- [Version (since = "2.4")] +- public static string vprintf_escaped (string format, va_list args); +- [Version (since = "2.16")] +- [CCode (sentinel = "G_MARKUP_COLLECT_INVALID")] +- public static bool collect_attributes (string element_name, [CCode (array_length = false, array_null_terminated = true)] string[] attribute_names, [CCode (array_length = false, array_null_terminated = true)] string[] attribute_values, ...) throws MarkupError; +- } +- +- /* Key-value file parser */ +- +- public errordomain KeyFileError { +- UNKNOWN_ENCODING, +- PARSE, +- NOT_FOUND, +- KEY_NOT_FOUND, +- GROUP_NOT_FOUND, +- INVALID_VALUE; +- public static GLib.Quark quark (); +- } +- +- [Compact] +- [Version (since = "2.32")] +- [CCode (ref_function = "g_key_file_ref", unref_function = "g_key_file_unref", type_id = "G_TYPE_KEY_FILE")] +- public class KeyFile { +- public KeyFile (); +- public void set_list_separator (char separator); +- [Version (since = "2.50")] +- public bool load_from_bytes (Bytes bytes, KeyFileFlags @flags) throws KeyFileError; +- public bool load_from_file (string file, KeyFileFlags @flags) throws KeyFileError, FileError; +- [Version (since = "2.14")] +- public bool load_from_dirs (string file, [CCode (array_length = false, array_null_terminated = true)] string[] search_dirs, out string full_path, KeyFileFlags @flags) throws KeyFileError, FileError; +- public bool load_from_data (string data, size_t length, KeyFileFlags @flags) throws KeyFileError; +- public bool load_from_data_dirs (string file, out string full_path, KeyFileFlags @flags) throws KeyFileError, FileError; +- // g_key_file_to_data never throws an error according to the documentation +- public string to_data (out size_t length = null, out GLib.Error error = null); +- public string get_start_group (); +- [CCode (array_length_type = "gsize")] +- public string[] get_groups (); +- [CCode (array_length_type = "gsize")] +- public string[] get_keys (string group_name) throws KeyFileError; +- public bool has_group (string group_name); +- public bool has_key (string group_name, string key) throws KeyFileError; +- public string get_value (string group_name, string key) throws KeyFileError; +- public string get_string (string group_name, string key) throws KeyFileError; +- public string get_locale_string (string group_name, string key, string? locale = null) throws KeyFileError; +- [Version (since = "2.56")] +- public string? get_locale_for_key (string group_name, string key, string? locale = null); +- public bool get_boolean (string group_name, string key) throws KeyFileError; +- public int get_integer (string group_name, string key) throws KeyFileError; +- [Version (since = "2.26")] +- public int64 get_int64 (string group_name, string key) throws KeyFileError; +- [Version (since = "2.26")] +- public uint64 get_uint64 (string group_name, string key) throws KeyFileError; +- [Version (since = "2.12")] +- public double get_double (string group_name, string key) throws KeyFileError; +- [CCode (array_length = true, array_length_type = "gsize", array_null_terminated = true)] +- public string[] get_string_list (string group_name, string key) throws KeyFileError; +- [CCode (array_length_type = "gsize")] +- public string[] get_locale_string_list (string group_name, string key, string? locale = null) throws KeyFileError; +- [CCode (array_length_type = "gsize")] +- public bool[] get_boolean_list (string group_name, string key) throws KeyFileError; +- [CCode (array_length_type = "gsize")] +- public int[] get_integer_list (string group_name, string key) throws KeyFileError; +- [Version (since = "2.12")] +- [CCode (array_length_type = "gsize")] +- public double[] get_double_list (string group_name, string key) throws KeyFileError; +- public string get_comment (string? group_name, string? key) throws KeyFileError; +- [Version (since = "2.40")] +- public bool save_to_file (string filename) throws GLib.FileError; +- public void set_value (string group_name, string key, string value); +- public void set_string (string group_name, string key, string str); +- public void set_locale_string (string group_name, string key, string locale, string str); +- public void set_boolean (string group_name, string key, bool value); +- public void set_integer (string group_name, string key, int value); +- [Version (since = "2.26")] +- public void set_int64 (string group_name, string key, int64 value); +- [Version (since = "2.26")] +- public void set_uint64 (string group_name, string key, uint64 value); +- [Version (since = "2.12")] +- public void set_double (string group_name, string key, double value); +- public void set_string_list (string group_name, string key, [CCode (type = "const gchar* const*")] string[] list); +- public void set_locale_string_list (string group_name, string key, string locale, string[] list); +- public void set_boolean_list (string group_name, string key, bool[] list); +- public void set_integer_list (string group_name, string key, int[] list); +- [Version (since = "2.12")] +- public void set_double_list (string group_name, string key, double[] list); +- public void set_comment (string? group_name, string? key, string comment) throws KeyFileError; +- public void remove_group (string group_name) throws KeyFileError; +- public void remove_key (string group_name, string key) throws KeyFileError; +- public void remove_comment (string group_name, string key) throws KeyFileError; +- } +- +- [CCode (cprefix = "G_KEY_FILE_", has_type_id = false)] +- [Flags] +- public enum KeyFileFlags { +- NONE, +- KEEP_COMMENTS, +- KEEP_TRANSLATIONS +- } +- +- [Version (since = "2.14")] +- [CCode (cprefix = "G_KEY_FILE_DESKTOP_")] +- namespace KeyFileDesktop { +- public const string GROUP; +- public const string KEY_ACTIONS; +- public const string KEY_CATEGORIES; +- public const string KEY_COMMENT; +- public const string KEY_DBUS_ACTIVATABLE; +- public const string KEY_EXEC; +- public const string KEY_FULLNAME; +- public const string KEY_GENERIC_NAME; +- public const string KEY_GETTEXT_DOMAIN; +- public const string KEY_HIDDEN; +- public const string KEY_ICON; +- public const string KEY_KEYWORDS; +- public const string KEY_MIME_TYPE; +- public const string KEY_NAME; +- public const string KEY_NOT_SHOW_IN; +- public const string KEY_NO_DISPLAY; +- public const string KEY_ONLY_SHOW_IN; +- public const string KEY_PATH; +- public const string KEY_STARTUP_NOTIFY; +- public const string KEY_STARTUP_WM_CLASS; +- public const string KEY_TERMINAL; +- public const string KEY_TRY_EXEC; +- public const string KEY_TYPE; +- public const string KEY_URL; +- public const string KEY_VERSION; +- public const string TYPE_APPLICATION; +- public const string TYPE_DIRECTORY; +- public const string TYPE_LINK; +- } +- +- /* Bookmark file parser */ +- +- [Compact] +- [Version (since = "2.12")] +- [CCode (free_function = "g_bookmark_file_free")] +- public class BookmarkFile { +- public BookmarkFile (); +- public bool load_from_file (string file) throws BookmarkFileError, FileError; +- public bool load_from_data (string data, size_t length) throws BookmarkFileError; +- public bool load_from_data_dirs (string file, out string full_path) throws BookmarkFileError, FileError; +- public string to_data (out size_t length) throws BookmarkFileError; +- public bool to_file (string filename) throws BookmarkFileError, FileError; +- public bool has_item (string uri); +- public bool has_group (string uri, string group) throws BookmarkFileError; +- public bool has_application (string uri, string name) throws BookmarkFileError; +- public int get_size (); +- [CCode (array_length_type = "gsize")] +- public string[] get_uris (); +- public string get_title (string uri) throws BookmarkFileError; +- public string get_description (string uri) throws BookmarkFileError; +- public string get_mime_type (string uri) throws BookmarkFileError; +- public bool get_is_private (string uri) throws BookmarkFileError; +- public bool get_icon (string uri, out string href, out string mime_type) throws BookmarkFileError; +- public time_t get_added (string uri) throws BookmarkFileError; +- public time_t get_modified (string uri) throws BookmarkFileError; +- public time_t get_visited (string uri) throws BookmarkFileError; +- [CCode (array_length_type = "gsize")] +- public string[] get_groups (string uri) throws BookmarkFileError; +- [CCode (array_length_type = "gsize")] +- public string[] get_applications (string uri) throws BookmarkFileError; +- public bool get_app_info (string uri, string name, out string exec, out uint count, out time_t stamp) throws BookmarkFileError; +- public void set_title (string uri, string title); +- public void set_description (string uri, string description); +- public void set_mime_type (string uri, string mime_type); +- public void set_is_private (string uri, bool is_private); +- public void set_icon (string uri, string href, string mime_type); +- public void set_added (string uri, time_t added); +- public void set_groups (string uri, string[] groups); +- public void set_modified (string uri, time_t modified); +- public void set_visited (string uri, time_t visited); +- public bool set_app_info (string uri, string name, string exec, int count, time_t stamp) throws BookmarkFileError; +- public void add_group (string uri, string group); +- public void add_application (string uri, string name, string exec); +- public bool remove_group (string uri, string group) throws BookmarkFileError; +- public bool remove_application (string uri, string name) throws BookmarkFileError; +- public bool remove_item (string uri) throws BookmarkFileError; +- public bool move_item (string old_uri, string new_uri) throws BookmarkFileError; +- } +- +- public errordomain BookmarkFileError { +- INVALID_URI, +- INVALID_VALUE, +- APP_NOT_REGISTERED, +- URI_NOT_FOUND, +- READ, +- UNKNOWN_ENCODING, +- WRITE, +- FILE_NOT_FOUND; +- public static GLib.Quark quark (); +- } +- +- /* Testing */ +- +- namespace Test { +- [CCode (cprefix = "G_TEST_", has_type_id = false)] +- public enum FileType { +- DIST, +- BUILT +- } +- +- [PrintfFormat] +- [Version (since = "2.16")] +- public static void minimized_result (double minimized_quantity, string format, ...); +- [PrintfFormat] +- [Version (since = "2.16")] +- public static void maximized_result (double maximized_quantity, string format, ...); +- [Version (since = "2.16")] +- public static void init ([CCode (array_length_pos = 0.9)] ref unowned string[] args, ...); +- public static bool quick (); +- public static bool slow (); +- public static bool thorough (); +- public static bool perf (); +- public static bool verbose (); +- public static bool quiet (); +- [Version (since = "2.16")] +- public static int run (); +- [Version (since = "2.16")] +- public static void add (string testpath, void* fixture, [CCode (delegate_target_pos = 2.9)] TestFixtureFunc fsetup, [CCode (delegate_target_pos = 2.9)] TestFixtureFunc ftest, [CCode (delegate_target_pos = 2.9)] TestFixtureFunc fteardown); +- [Version (since = "2.16")] +- public static void add_func (string testpath, [CCode (scope = "async")] owned TestFunc test_funcvoid); +- [Version (since = "2.16")] +- public static void add_data_func (string testpath, [CCode (delegate_target_pos = 1.9, scope = "async")] owned TestDataFunc test_funcvoid); +- [Version (since = "2.34")] +- public static void add_data_func_full (string testpath, [CCode (delegate_target_pos = 1.9)] owned TestDataFunc test_func); +- [Version (since = "2.34")] +- public static void assert_expected_messages (); +- [Version (since = "2.38")] +- public static string build_filename (GLib.Test.FileType file_type, params string[] path_segments); +- [Version (since = "2.34")] +- public static void expect_message (string? log_domain, LogLevelFlags log_level, string pattern); +- [Version (since = "2.30")] +- public static void fail (); +- [Version (since = "2.38")] +- public static bool failed (); +- [Version (since = "2.38")] +- public static unowned string get_dir (GLib.Test.FileType file_type); +- [Version (since = "2.38")] +- public static unowned string get_filename (GLib.Test.FileType file_type, params string[] path_segments); +- [Version (since = "2.38")] +- public static void incomplete (string? msg = null); +- [Version (since = "2.36")] +- public static bool initialized (); +- [PrintfFormat] +- [Version (since = "2.16")] +- public static void message (string format, ...); +- [Version (since = "2.38")] +- public static void set_nonfatal_assertions (); +- [Version (since = "2.38")] +- public static void skip (string? msg = null); +- [Version (since = "2.38")] +- public static bool subprocess (); +- [Version (since = "2.16")] +- public static void bug_base (string uri_pattern); +- [Version (since = "2.16")] +- public static void bug (string bug_uri_snippet); +- [Version (since = "2.16")] +- public static void timer_start (); +- [Version (since = "2.16")] +- public static double timer_elapsed (); +- [Version (since = "2.16")] +- public static double timer_last (); +- [Version (since = "2.16", deprecated_since = "2.38", replacement = "trap_subprocess")] +- public static bool trap_fork (uint64 usec_timeout, TestTrapFlags test_trap_flags); +- [Version (since = "2.16")] +- public static bool trap_has_passed (); +- [Version (since = "2.16")] +- public static bool trap_reached_timeout (); +- [Version (since = "2.38")] +- public static void trap_subprocess (string? test_path, uint64 usec_timeout, TestSubprocessFlags test_flags); +- [Version (since = "2.16")] +- public static void trap_assert_passed (); +- [Version (since = "2.16")] +- public static void trap_assert_failed (); +- [Version (since = "2.16")] +- public static void trap_assert_stdout (string soutpattern); +- [Version (since = "2.16")] +- public static void trap_assert_stdout_unmatched (string soutpattern); +- [Version (since = "2.16")] +- public static void trap_assert_stderr (string serrpattern); +- [Version (since = "2.16")] +- public static void trap_assert_stderr_unmatched (string serrpattern); +- [Version (since = "2.16")] +- public static bool rand_bit (); +- [Version (since = "2.16")] +- public static int32 rand_int (); +- [Version (since = "2.16")] +- public static int32 rand_int_range (int32 begin, int32 end); +- [Version (since = "2.16")] +- public static double rand_double (); +- [Version (since = "2.16")] +- public static double rand_double_range (double begin, double end); +- [Version (since = "2.22")] +- public static void log_set_fatal_handler (LogFatalFunc log_func); +- } +- +- public delegate bool LogFatalFunc (string? log_domain, LogLevelFlags log_levels, string message); +- +- [Compact] +- [CCode (cname = "GTestCase", ref_function = "", unref_function = "")] +- public class TestCase { +- [Version (since = "2.16")] +- [CCode (cname = "g_test_create_case")] +- public TestCase (string test_name, [CCode (delegate_target_pos = 1.9)] TestFixtureFunc data_setup, [CCode (delegate_target_pos = 1.9)] TestFixtureFunc data_func, [CCode (delegate_target_pos = 1.9)] TestFixtureFunc data_teardown, [CCode (pos = 1.8)] size_t data_size = 0); +- } +- +- [Compact] +- [CCode (cname = "GTestSuite", ref_function = "", unref_function = "")] +- public class TestSuite { +- [Version (since = "2.16")] +- [CCode (cname = "g_test_create_suite")] +- public TestSuite (string name); +- [Version (since = "2.16")] +- [CCode (cname = "g_test_get_root")] +- public static TestSuite get_root (); +- [Version (since = "2.16")] +- [CCode (cname = "g_test_suite_add")] +- public void add (TestCase test_case); +- [Version (since = "2.16")] +- [CCode (cname = "g_test_suite_add_suite")] +- public void add_suite (TestSuite test_suite); +- } +- +- [Version (since = "2.26")] +- [CCode (has_target = false)] +- public delegate void TestFunc (); +- [Version (since = "2.26")] +- public delegate void TestDataFunc (); +- [Version (since = "2.26")] +- public delegate void TestFixtureFunc (void* fixture); +- +- [CCode (cprefix = "G_TEST_SUBPROCESS_INHERIT_", has_type_id = false)] +- [Flags] +- public enum TestSubprocessFlags { +- STDIN, +- STDOUT, +- STDERR +- } +- +- [Flags] +- [CCode (cprefix = "G_TEST_TRAP_", has_type_id = false)] +- public enum TestTrapFlags { +- SILENCE_STDOUT, +- SILENCE_STDERR, +- INHERIT_STDIN +- } +- +- /* Doubly-Linked Lists */ +- +- [Compact] +- [CCode (dup_function = "g_list_copy", free_function = "g_list_free")] +- public class List { +- public List (); +- +- [ReturnsModifiedPointer ()] +- public void append (owned G data); +- [ReturnsModifiedPointer ()] +- public void prepend (owned G data); +- [ReturnsModifiedPointer ()] +- public void insert (owned G data, int position); +- [ReturnsModifiedPointer ()] +- public void insert_before (List sibling, owned G data); +- [ReturnsModifiedPointer ()] +- public void insert_sorted (owned G data, CompareFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void remove (G data); +- [ReturnsModifiedPointer ()] +- public void remove_link (List llink); +- [ReturnsModifiedPointer ()] +- public void delete_link (List link_); +- [ReturnsModifiedPointer ()] +- public void remove_all (G data); +- +- public uint length (); +- public List copy (); +- [Version (since = "2.34")] +- public List copy_deep (CopyFunc func); +- [ReturnsModifiedPointer ()] +- public void reverse (); +- [ReturnsModifiedPointer ()] +- public void sort (CompareFunc compare_func); +- [Version (since = "2.10")] +- [ReturnsModifiedPointer ()] +- public void insert_sorted_with_data (owned G data, CompareDataFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void sort_with_data (CompareDataFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void concat (owned List list2); +- public void @foreach (Func func); +- +- public unowned List first (); +- public unowned List last (); +- public unowned List nth (uint n); +- public unowned G nth_data (uint n); +- public unowned List nth_prev (uint n); +- +- public unowned List find (G data); +- public unowned List find_custom (G data, CompareFunc func); +- [CCode (cname = "g_list_find_custom", simple_generics = true)] +- public unowned List search (T data, SearchFunc func); +- +- public int position (List llink); +- public int index (G data); +- +- public G data; +- public List next; +- public unowned List prev; +- } +- +- /* Singly-Linked Lists */ +- +- [Compact] +- [CCode (dup_function = "g_slist_copy", free_function = "g_slist_free")] +- public class SList { +- public SList (); +- +- [ReturnsModifiedPointer ()] +- public void append (owned G data); +- [ReturnsModifiedPointer ()] +- public void prepend (owned G data); +- [ReturnsModifiedPointer ()] +- public void insert (owned G data, int position); +- [ReturnsModifiedPointer ()] +- public void insert_before (SList sibling, owned G data); +- [ReturnsModifiedPointer ()] +- public void insert_sorted (owned G data, CompareFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void remove (G data); +- [ReturnsModifiedPointer ()] +- public void remove_link (SList llink); +- [ReturnsModifiedPointer ()] +- public void delete_link (SList link_); +- [ReturnsModifiedPointer ()] +- public void remove_all (G data); +- +- public uint length (); +- public SList copy (); +- [Version (since = "2.34")] +- public SList copy_deep (CopyFunc func); +- [ReturnsModifiedPointer ()] +- public void reverse (); +- [Version (since = "2.10")] +- [ReturnsModifiedPointer ()] +- public void insert_sorted_with_data (owned G data, CompareDataFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void sort (CompareFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void sort_with_data (CompareDataFunc compare_func); +- [ReturnsModifiedPointer ()] +- public void concat (owned SList list2); +- public void @foreach (Func func); +- +- public unowned SList last (); +- public unowned SList nth (uint n); +- public unowned G nth_data (uint n); +- +- public unowned SList find (G data); +- public unowned SList find_custom (G data, CompareFunc func); +- [CCode (cname = "g_slist_find_custom", simple_generics = true)] +- public unowned SList search (T data, SearchFunc func); +- +- public int position (SList llink); +- public int index (G data); +- +- public G data; +- public SList next; +- } +- +- [CCode (has_target = false)] +- public delegate int CompareFunc (G a, G b); +- +- public delegate int CompareDataFunc (G a, G b); +- +- [Version (since = "2.16")] +- [CCode (cname = "((GCompareFunc) g_strcmp0)")] +- public static GLib.CompareFunc strcmp; +- +- public delegate G CopyFunc (G src); +- +- [CCode (cname = "GCompareFunc", has_target = false)] +- public delegate int SearchFunc (G a, T b); +- +- /* Double-ended Queues */ +- +- [Compact] +- [CCode (dup_function = "g_queue_copy", free_function = "g_queue_free")] +- public class Queue { +- public unowned List head; +- public unowned List tail; +- public uint length; +- +- public Queue (); +- +- [Version (since = "2.14")] +- public void clear (); +- public bool is_empty (); +- [Version (since = "2.4")] +- public uint get_length (); +- [Version (since = "2.4")] +- public void reverse (); +- public Queue copy (); +- [Version (since = "2.4")] +- public unowned List find (G data); +- [Version (since = "2.4")] +- public unowned List find_custom (G data, CompareFunc func); +- [CCode (cname = "g_queue_find_custom", simple_generics = true)] +- public unowned List search (T data, SearchFunc func); +- [Version (since = "2.4")] +- public void sort (CompareDataFunc compare_func); +- public void push_head (owned G data); +- public void push_tail (owned G data); +- [Version (since = "2.4")] +- public void push_nth (owned G data, int n); +- public G pop_head (); +- public G pop_tail (); +- [Version (since = "2.4")] +- public G pop_nth (uint n); +- public unowned G peek_head (); +- public unowned G peek_tail (); +- [Version (since = "2.4")] +- public unowned G peek_nth (uint n); +- [Version (since = "2.4")] +- public int index (G data); +- [Version (since = "2.4")] +- public bool remove (G data); +- [Version (since = "2.4")] +- public uint remove_all (G data); +- [Version (since = "2.4")] +- public void delete_link (List link); +- [Version (since = "2.4")] +- public void unlink (List link); +- [Version (since = "2.4")] +- public void insert_before (List sibling, owned G data); +- [Version (since = "2.4")] +- public void insert_after (List sibling, owned G data); +- [Version (since = "2.4")] +- public void insert_sorted (owned G data, CompareDataFunc func); +- } +- +- /* Sequences */ +- +- [Compact] +- [Version (since = "2.14")] +- [CCode (free_function = "g_sequence_free")] +- public class Sequence { +- [CCode (simple_generics = true)] +- public Sequence (); +- public int get_length (); +- public void @foreach (Func func); +- public void sort (CompareDataFunc cmp_func); +- public void sort_iter (SequenceIterCompareFunc func); +- public SequenceIter get_begin_iter (); +- public SequenceIter get_end_iter (); +- public SequenceIter get_iter_at_pos (int pos); +- public SequenceIter append (owned G data); +- public SequenceIter prepend (owned G data); +- public SequenceIter insert_sorted (owned G data, CompareDataFunc cmp_func); +- [Version (since = "2.48")] +- public bool is_empty (); +- public SequenceIter insert_sorted_iter (owned G data, SequenceIterCompareFunc iter_cmp); +- public SequenceIter search (G data, CompareDataFunc cmp_func); +- public SequenceIter search_iter (G data, SequenceIterCompareFunc iter_cmp); +- [Version (since = "2.28")] +- public SequenceIter lookup (G data, CompareDataFunc cmp_func); +- [Version (since = "2.28")] +- public SequenceIter lookup_iter (G data, SequenceIterCompareFunc iter_cmp); +- +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.foreach_range")] +- public static void foreach_range (SequenceIter begin, SequenceIter end, Func func); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.insert_before")] +- public static SequenceIter insert_before (SequenceIter iter, owned G data); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.move_to")] +- public static void move (SequenceIter src, SequenceIter dest); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.swap")] +- public static void swap (SequenceIter src, SequenceIter dest); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.sort_changed")] +- public static void sort_changed (SequenceIter iter, CompareDataFunc cmp_func); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.sort_changed_iter")] +- public static void sort_changed_iter (SequenceIter iter, SequenceIterCompareFunc iter_cmp); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.remove")] +- public static void remove (SequenceIter iter); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.remove_range")] +- public static void remove_range (SequenceIter begin, SequenceIter end); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.move_range")] +- public static void move_range (SequenceIter dest, SequenceIter begin, SequenceIter end); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.get")] +- public static unowned G get (SequenceIter iter); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.set")] +- public static void set (SequenceIter iter, owned G data); +- [Version (deprecated_since = "vala-0.26", replacement = "SequenceIter.range_get_midpoint")] +- public static SequenceIter range_get_midpoint (SequenceIter begin, SequenceIter end); +- } +- +- [Compact] +- [Version (since = "2.14")] +- [CCode (ref_function = "", unref_function = "")] +- public class SequenceIter { +- public bool is_begin (); +- public bool is_end (); +- public SequenceIter next (); +- public SequenceIter prev (); +- public int get_position (); +- public SequenceIter move (int delta); +- public unowned Sequence get_sequence (); +- public int compare (SequenceIter other); +- +- [CCode (cname = "g_sequence_foreach_range")] +- public void foreach_range (SequenceIter end, Func func); +- [CCode (cname = "g_sequence_insert_before")] +- public SequenceIter insert_before (owned G data); +- [CCode (cname = "g_sequence_move")] +- public void move_to (SequenceIter dest); +- [CCode (cname = "g_sequence_swap")] +- public void swap (SequenceIter dest); +- [CCode (cname = "g_sequence_sort_changed")] +- public void sort_changed (CompareDataFunc cmp_func); +- [CCode (cname = "g_sequence_sort_changed_iter")] +- public void sort_changed_iter (SequenceIterCompareFunc iter_cmp); +- [CCode (cname = "g_sequence_remove")] +- public void remove (); +- [CCode (cname = "g_sequence_remove_range")] +- public void remove_range (SequenceIter end); +- [CCode (cname = "g_sequence_move_range")] +- public void move_range (SequenceIter begin, SequenceIter end); +- [CCode (cname = "g_sequence_get")] +- public unowned G get (); +- [CCode (cname = "g_sequence_set")] +- public void set (owned G data); +- [CCode (cname = "g_sequence_range_get_midpoint")] +- public SequenceIter range_get_midpoint (SequenceIter end); +- } +- +- public delegate int SequenceIterCompareFunc (SequenceIter a, SequenceIter b); +- +- /* Hash Tables */ +- +- [Compact] +- [CCode (ref_function = "g_hash_table_ref", unref_function = "g_hash_table_unref", type_id = "G_TYPE_HASH_TABLE", type_signature = "a{%s}")] +- public class HashTable { +- [CCode (cname = "g_hash_table_new_full", simple_generics = true)] +- public HashTable (HashFunc? hash_func, EqualFunc? key_equal_func); +- public HashTable.full (HashFunc? hash_func, EqualFunc? key_equal_func, DestroyNotify? key_destroy_func, DestroyNotify? value_destroy_func); +- public void insert (owned K key, owned V value); +- public void replace (owned K key, owned V value); +- [Version (since = "2.32", deprecated_since = "vala-0.26", replacement = "GenericSet.add")] +- public void add (owned K key); +- public unowned V? lookup (K key); +- public bool lookup_extended (K lookup_key, out unowned K orig_key, out unowned V value); +- [Version (since = "2.32")] +- public bool contains (K key); +- public bool remove (K key); +- [Version (since = "2.12")] +- public void remove_all (); +- public uint foreach_remove (HRFunc predicate); +- public uint foreach_steal (HRFunc predicate); +- [CCode (cname = "g_hash_table_lookup")] +- public unowned V? @get (K key); +- [CCode (cname = "g_hash_table_insert")] +- public void @set (owned K key, owned V value); +- [Version (since = "2.14")] +- public List get_keys (); +-#if VALA_0_26 +- [CCode (array_length_type = "guint")] +- [Version (since = "2.40")] +- public (unowned K)[] get_keys_as_array (); +-#endif +- [Version (since = "2.14")] +- public List get_values (); +- public void @foreach (HFunc func); +- [CCode (cname = "g_hash_table_foreach")] +- public void for_each (HFunc func); +- [Version (since = "2.4")] +- public unowned V? find (HRFunc predicate); +- public uint size (); +- public bool steal (K key); +- [Version (since = "2.12")] +- public void steal_all (); +- [Version (since = "2.58")] +- public bool steal_extended (K lookup_key, out K stolen_key, out V stolen_value); +- [CCode (cname = "_vala_g_hash_table_take")] +- public V? take (K key, out bool exists = null) { +- GLib.HashTable? ht = null; +- void** htp = &ht; +- *htp = this.lookup (key); +- exists = this.steal (key); +- return ht; +- } +- public uint length { +- [CCode (cname = "g_hash_table_size")] +- get; +- } +- } +- +- [Version (since = "2.16")] +- public struct HashTableIter { +- public HashTableIter (GLib.HashTable table); +- public bool next ([CCode (type = "gpointer*")] out unowned K key, [CCode (type = "gpointer*")] out unowned V value); +- public void remove (); +- public void steal (); +- public unowned GLib.HashTable get_hash_table (); +- } +- +- [Version (since = "2.32")] +- [Compact, CCode (cname = "GHashTable", lower_case_cprefix = "g_hash_table_", ref_function = "g_hash_table_ref", unref_function = "g_hash_table_unref", type_id = "G_TYPE_HASH_TABLE", type_signature = "a{%s}")] +- public class GenericSet { +- [CCode (cname = "g_hash_table_new_full", simple_generics = true)] +- public GenericSet (HashFunc? hash_func, EqualFunc? equal_func, GLib.DestroyNotify? always_pass_null_here = null); +- public void add (owned T value); +- public bool contains (T valule); +- public bool remove (T value); +- public void remove_all (); +- public GLib.List get_values (); +- [CCode (cname = "g_hash_table_iter_init", instance_pos = -1)] +- public GLib.GenericSetIter iterator (); +- [CCode (cname = "_vala_g_hash_set_foreach")] +- public void @foreach (GLib.Func func) { +- ((GLib.HashTable) this).foreach ((k, v) => func (v)); +- } +- public uint length { +- [CCode (cname = "g_hash_table_size")] +- get; +- } +- } +- +- [Version (since = "2.32")] +- [CCode (cname = "GHashTableIter", lower_case_cprefix = "g_hash_table_iter_")] +- public struct GenericSetIter { +- [CCode (cname = "_vala_hash_set_next_value")] +- public unowned T? next_value () { +- void* vi = &this; +- GLib.HashTableIter* htp = vi; +- unowned T? value; +- return htp->next (out value, null) ? value : null; +- } +- public void remove (); +- } +- +- [CCode (has_target = false)] +- public delegate uint HashFunc (K key); +- [CCode (has_target = false)] +- public delegate bool EqualFunc (G a, G b); +- public delegate void HFunc (K key, V value); +- public delegate bool HRFunc (K key, V value); +- +- [CCode (has_target = false)] +- public delegate void DestroyNotify (void* data); +- +- [CCode (cname = "g_direct_hash")] +- public static GLib.HashFunc direct_hash; +- [CCode (cname = "g_direct_equal")] +- public static GLib.EqualFunc direct_equal; +- [CCode (cname = "g_int64_hash")] +- public static GLib.HashFunc int64_hash; +- [Version (since = "2.22")] +- [CCode (cname = "g_int64_equal")] +- public static GLib.EqualFunc int64_equal; +- [Version (since = "2.22")] +- [CCode (cname = "g_int_hash")] +- public static GLib.HashFunc int_hash; +- [CCode (cname = "g_int_equal")] +- public static GLib.EqualFunc int_equal; +- [CCode (cname = "g_str_hash")] +- public static GLib.HashFunc str_hash; +- [CCode (cname = "g_str_equal")] +- public static GLib.EqualFunc str_equal; +- [CCode (cname = "g_free")] +- public static GLib.DestroyNotify g_free; +- [CCode (cname = "g_list_free")] +- public static GLib.DestroyNotify g_list_free; +- [CCode (cname = "((GDestroyNotify) g_variant_unref)")] +- public static GLib.DestroyNotify g_variant_unref; +- +- /* Strings */ +- +- [Compact] +- [GIR (name = "String")] +- [CCode (cname = "GString", cprefix = "g_string_", free_function = "g_string_free", type_id = "G_TYPE_GSTRING")] +- public class StringBuilder { +- public StringBuilder (string init = ""); +- [CCode (cname = "g_string_sized_new")] +- public StringBuilder.sized (size_t dfl_size); +- public unowned StringBuilder assign (string rval); +- public unowned StringBuilder append (string val); +- public unowned StringBuilder append_c (char c); +- public unowned StringBuilder append_unichar (unichar wc); +- public unowned StringBuilder append_len (string val, ssize_t len); +- public unowned StringBuilder prepend (string val); +- public unowned StringBuilder prepend_c (char c); +- public unowned StringBuilder prepend_unichar (unichar wc); +- public unowned StringBuilder prepend_len (string val, ssize_t len); +- public unowned StringBuilder insert (ssize_t pos, string val); +- public unowned StringBuilder insert_len (ssize_t pos, string val, ssize_t len); +- public unowned StringBuilder insert_unichar (ssize_t pos, unichar wc); +- [Version (since = "2.14")] +- public unowned StringBuilder overwrite (size_t pos, string val); +- [Version (since = "2.14")] +- public unowned StringBuilder overwrite_len (size_t pos, string val, ssize_t len); +- public unowned StringBuilder erase (ssize_t pos = 0, ssize_t len = -1); +- public unowned StringBuilder truncate (size_t len = 0); +- +- [PrintfFormat] +- public void printf (string format, ...); +- [PrintfFormat] +- public void append_printf (string format, ...); +- [Version (since = "2.14")] +- public void vprintf (string format, va_list args); +- [Version (since = "2.14")] +- public void append_vprintf (string format, va_list args); +- +- public string str; +- public ssize_t len; +- public ssize_t allocated_len; +- +- public uint8[] data { +- get { +- unowned uint8[] res = (uint8[]) this.str; +- res.length = (int) this.len; +- return res; +- } +- } +- +- [Version (since = "2.34")] +- public static Bytes free_to_bytes (owned StringBuilder str); +- } +- +- /* String Chunks */ +- +- [Compact] +- [CCode (free_function = "g_string_chunk_free")] +- public class StringChunk { +- public StringChunk (size_t size); +- public unowned string insert (string str); +- public unowned string insert_const (string str); +- [Version (since = "2.4")] +- public unowned string insert_len (string str, ssize_t len); +- [Version (since = "2.14")] +- public void clear (); +- } +- +- /* Pointer Arrays */ +- +- [Compact] +- [Version (since = "2.22", deprecated_since = "vala-0.26", replacement="GenericArray")] +- [CCode (ref_function = "g_ptr_array_ref", unref_function = "g_ptr_array_unref", type_id = "G_TYPE_PTR_ARRAY")] +- public class PtrArray { +- public PtrArray (); +- [Version (since = "2.22")] +- public PtrArray.with_free_func (GLib.DestroyNotify? element_free_func); +- [CCode (cname = "g_ptr_array_sized_new")] +- public PtrArray.sized (uint reserved_size); +- public void add (void* data); +- [Version (since = "2.4")] +- public void foreach (GLib.Func func); +- [CCode (cname = "g_ptr_array_index")] +- public void* index(uint index); +- public bool remove (void* data); +- public void* remove_index (uint index); +- public bool remove_fast (void *data); +- public void remove_index_fast (uint index); +- [Version (since = "2.4")] +- public void remove_range (uint index, uint length); +- public void sort (CompareFunc compare_func); +- public void sort_with_data (CompareDataFunc compare_func); +- [Version (since = "2.22")] +- public void set_free_func (GLib.DestroyNotify? element_free_function); +- public void set_size (int length); +- +- public uint len; +- public void** pdata; +- } +- +- [Compact] +- [CCode (cname = "GPtrArray", cprefix = "g_ptr_array_", ref_function = "g_ptr_array_ref", unref_function = "g_ptr_array_unref", type_id = "G_TYPE_PTR_ARRAY")] +- [GIR (name = "PtrArray")] +- public class GenericArray { +- [Version (since = "2.30")] +- [CCode (cname = "g_ptr_array_new_full", simple_generics = true)] +- public GenericArray (uint reserved_size = 0); +- public void add (owned G data); +- [Version (since = "2.54")] +- public bool find (G needle, out uint index = null); +- [Version (since = "2.54")] +- public bool find_with_equal_func (G needle, GLib.EqualFunc? equal_func, out uint index = null); +- public void foreach (GLib.Func func); +- [CCode (cname = "g_ptr_array_index")] +- public unowned G get (uint index); +- [Version (since = "2.40")] +- public void insert (int index, owned G data); +- public bool remove (G data); +- public void remove_index (uint index); +- public bool remove_fast (G data); +- public void remove_index_fast (uint index); +- public void remove_range (uint index, uint length); +- public void set (uint index, owned G data) { +- this.add ((owned) data); +- this.remove_index_fast (index); +- } +- [CCode (cname = "vala_g_ptr_array_sort")] +- public void sort (GLib.CompareFunc compare_func) { +- this._sort_with_data ((a, b) => { +- return compare_func ((G**) (*a), (G**) (*b)); +- }); +- } +- [CCode (cname = "g_ptr_array_sort_with_data")] +- public void _sort_with_data (GLib.CompareDataFunc compare_func); +- [CCode (cname = "vala_g_ptr_array_sort_with_data")] +- public void sort_with_data (GLib.CompareDataFunc compare_func) { +- this._sort_with_data ((a, b) => { +- return compare_func ((G**) (*a), (G**) (*b)); +- }); +- } +- [Version (since = "2.58")] +- public G steal_index (uint index); +- [Version (since = "2.58")] +- public G steal_index_fast (uint index); +- +- private void set_size (int length); +- +- public int length { +- get { return (int) this.len; } +- set { this.set_size (value); } +- } +- +- [CCode (cname = "pdata", array_length_cname = "len", array_length_type = "guint")] +- public G[] data; +- +- private uint len; +- } +- +- [Compact] +- [Version (since = "2.32")] +- [CCode (cprefix = "g_bytes_", ref_function = "g_bytes_ref", unref_function = "g_bytes_unref", type_id = "G_TYPE_BYTES")] +- public class Bytes { +- public Bytes ([CCode (array_length_type = "gsize")] uint8[] data); +- public Bytes.take ([CCode (array_length_type = "gsize")] owned uint8[] data); +- public Bytes.static ([CCode (array_length_type = "gsize")] uint8[] data); +- public Bytes.with_free_func ([CCode (array_length_type = "gsize")] owned uint8[] data, GLib.DestroyNotify? free_func, void* user_data); +- public Bytes.from_bytes (GLib.Bytes bytes, size_t offset, size_t length); +- +- [CCode (cname = "g_bytes_new_with_free_func", simple_generics = true)] +- public static Bytes new_with_owner ([CCode (array_length_type = "gsize")] uint8[] data, [CCode (destroy_notify_pos = 1.9)] owned T? owner = null); +- +- [CCode (array_length_type = "gsize")] +- public unowned uint8[] get_data (); +- public size_t get_size (); +- public uint hash (); +- public int compare (GLib.Bytes bytes2); +- [CCode (array_length_type = "gsize")] +- public static uint8[] unref_to_data (owned GLib.Bytes bytes); +- public static GLib.ByteArray unref_to_array (owned GLib.Bytes bytes); +- +- [CCode (cname = "_vala_g_bytes_get")] +- public uint8 get (int index) { +- unowned uint8[] data = this.get_data (); +- return data[index]; +- } +- +- [CCode (cname = "_vala_g_bytes_slice")] +- public GLib.Bytes slice (size_t start, size_t end) { +- return new GLib.Bytes.from_bytes (this, start, end - start); +- } +- +- public int length { +- [CCode (cname = "_vala_g_bytes_get_length")] +- get { +- return (int) this.get_size (); +- } +- } +- } +- +- /* Byte Arrays */ +- +- [Compact] +- [Version (since = "2.22")] +- [CCode (cprefix = "g_byte_array_", ref_function = "g_byte_array_ref", unref_function = "g_byte_array_unref", type_id = "G_TYPE_BYTE_ARRAY")] +- public class ByteArray { +- public ByteArray (); +- [CCode (cname = "g_byte_array_sized_new")] +- public ByteArray.sized (uint reserved_size); +- [Version (since = "2.32")] +- public ByteArray.take (owned uint8[] data); +- public void append (uint8[] data); +- [Version (since = "2.32")] +- public static GLib.Bytes free_to_bytes (owned GLib.ByteArray array); +- public void prepend (uint8[] data); +- public void remove_index (uint index); +- public void remove_index_fast (uint index); +- [Version (since = "2.4")] +- public void remove_range (uint index, uint length); +- public void sort (CompareFunc compare_func); +- public void sort_with_data (CompareDataFunc compare_func); +- public void set_size (uint length); +- +- public uint len; +- [CCode (array_length_cname = "len", array_length_type = "guint")] +- public uint8[] data; +- } +- +- /* N-ary Trees */ +- +- public delegate bool NodeTraverseFunc (Node node); +- public delegate void NodeForeachFunc (Node node); +- +- [CCode (cprefix = "G_TRAVERSE_")] +- public enum TraverseFlags { +- LEAVES, +- NON_LEAVES, +- ALL, +- MASK, +- LEAFS, +- NON_LEAFS +- } +- +- [Compact] +- [CCode (dup_function = "g_node_copy", free_function = "g_node_destroy")] +- public class Node { +- public Node(owned G? data = null); +- public Node copy (); +- public Node copy_deep (CopyFunc copy_func); +- public unowned Node insert (int position, owned Node node); +- public unowned Node insert_before (Node sibling, owned Node node); +- public unowned Node insert_after (Node sibling, owned Node node); +- public unowned Node append (owned Node node); +- public unowned Node prepend (owned Node node); +- public unowned Node insert_data (int position, owned G data); +- public unowned Node insert_data_before (Node sibling, owned G data); +- public unowned Node append_data (owned G data); +- public unowned Node prepend_data (owned G data); +- public void reverse_children (); +- public void traverse (TraverseType order, TraverseFlags flags, int max_depth, NodeTraverseFunc func); +- public void children_foreach (TraverseFlags flags, NodeForeachFunc func); +- public unowned Node get_root (); +- public unowned Node find (TraverseType order, TraverseFlags flags, G data); +- public unowned Node find_child (TraverseFlags flags, G data); +- public int child_index (G data); +- public int child_position (Node child); +- public unowned Node first_child (); +- public unowned Node last_child (); +- public unowned Node nth_child (uint n); +- public unowned Node first_sibling (); +- public unowned Node next_sibling (); +- public unowned Node prev_sibling (); +- public unowned Node last_sibling (); +- +- [CCode (cname = "G_NODE_IS_LEAF")] +- public bool is_leaf (); +- [CCode (cname = "G_NODE_IS_ROOT")] +- public bool is_root (); +- public bool is_ancestor (Node descendant); +- +- public uint depth (); +- public uint n_nodes (TraverseFlags flags); +- public uint n_children (); +- public uint max_height (); +- +- [CCode (cname = "g_node_unlink")] +- public void _unlink (); +- [CCode (cname = "g_node_unlink_vala")] +- public Node unlink () +- { +- void *ptr = this; +- _unlink (); +- return (Node) (owned) ptr; +- } +- +- public G data; +- public Node next; +- public Node prev; +- public Node parent; +- public Node children; +- } +- +- /* Quarks */ +- +- [CCode (type_id = "G_TYPE_UINT")] +- public struct Quark : uint32 { +- public static Quark from_string (string str); +- public static Quark try_string (string str); +- public unowned string to_string (); +- } +- +- /* Keyed Data Lists */ +- +- [CCode (cname = "GData*")] +- public struct Datalist { +- public Datalist (); +- public void clear (); +- [Version (since = "2.34")] +- public G id_dup_data (Quark key_id, DuplicateFunc dup_func); +- public unowned G id_get_data (Quark key_id); +- public void id_set_data (Quark key_id, owned G data); +- public void id_set_data_full (Quark key_id, owned G data, DestroyNotify? destroy_func); +- public void id_remove_data (Quark key_id); +- public G id_remove_no_notify (Quark key_id); +- [Version (since = "2.34")] +- public bool id_replace_data (Quark key_id, G oldval, owned G newval, GLib.DestroyNotify? destroy, out GLib.DestroyNotify? old_destroy); +- public void @foreach (DataForeachFunc func); +- public unowned G get_data (string key); +- public void set_data_full (string key, owned G data, DestroyNotify? destry_func); +- public G remove_no_notify (string key); +- public void set_data (string key, owned G data); +- public void remove_data (string key); +- } +- +- public delegate void DataForeachFunc (Quark key_id, G data); +- public delegate G DuplicateFunc (G data); +- +- /* GArray */ +- +- [Compact] +- [Version (since = "2.22")] +- [CCode (ref_function = "g_array_ref", unref_function = "g_array_unref", type_id = "G_TYPE_ARRAY")] +- public class Array { +- [CCode (cname = "len")] +- public uint length; +- [CCode (cname = "data", array_length_cname = "len", array_length_type = "uint")] +- public G[] data; +- +- public Array (bool zero_terminated = true, bool clear = true, ulong element_size = 0); +- [CCode (cname = "g_array_sized_new")] +- public Array.sized (bool zero_terminated, bool clear, ulong element_size, uint reserved_size); +- public void append_val (owned G value); +- public void append_vals (void* data, uint len); +- public void prepend_val (owned G value); +- public void prepend_vals (void* data, uint len); +- public void insert_val (uint index, owned G value); +- public void insert_vals (uint index, void* data, uint len); +- [CCode (cname = "g_array_remove_index")] +- public void _remove_index (uint index); +- [CCode (cname = "g_array_remove_index_fast")] +- public void _remove_index_fast (uint index); +- [CCode (cname = "g_array_remove_range")] +- public void _remove_range (uint index, uint length); +- [CCode (cname = "vala_g_array_remove_index")] +- public G remove_index (uint index) { +- assert (length > index); +- G g = (owned) data[index]; +- _remove_index (index); +- return g; +- } +- [CCode (cname = "vala_g_array_remove_index_fast")] +- public G remove_index_fast (uint index) { +- assert (length > index); +- G g = (owned) data[index]; +- _remove_index_fast (index); +- return g; +- } +- [CCode (cname = "vala_g_array_remove_range")] +- public G[] remove_range (uint index, uint length) { +- assert (this.length >= index + length); +- G[] ga = new G[length]; +- for (uint i = 0; i < length; i++) { +- ga[i] = (owned) data[i + index]; +- } +- _remove_range (index, length); +- return ga; +- } +- public void sort (CompareFunc compare_func); +- public void sort_with_data (CompareDataFunc compare_func); +- [CCode (generic_type_pos = 0.1)] +- public unowned G index (uint index); +- public void set_size (uint length); +- [Version (since = "2.32")] +- public void set_clear_func (GLib.DestroyNotify clear_func); +- } +- +- /* GTree */ +- +- public delegate bool TraverseFunc (K key, V value); +- +- [CCode (cprefix = "G_", has_type_id = false)] +- public enum TraverseType { +- IN_ORDER, +- PRE_ORDER, +- POST_ORDER, +- LEVEL_ORDER +- } +- +- public delegate int TreeSearchFunc (K key); +- +- [Compact] +- [Version (since = "2.22")] +- [CCode (ref_function = "g_tree_ref", unref_function = "g_tree_unref")] +- public class Tree { +- [CCode (cname = "g_tree_new_full", simple_generics = true)] +- public Tree (CompareDataFunc key_compare_func); +- [Version (deprecated_since = "vala-0.20", replacement = "Tree ()")] +- public Tree.with_data (CompareDataFunc key_compare_func); +- public Tree.full (CompareDataFunc key_compare_func, DestroyNotify? key_destroy_func, DestroyNotify? value_destroy_func); +- public void insert (owned K key, owned V value); +- public void replace (owned K key, owned V value); +- public int nnodes (); +- public int height (); +- public unowned V lookup (K key); +- public bool lookup_extended (K lookup_key, out unowned K orig_key, out unowned V value); +- public void foreach (TraverseFunc traverse_func); +- public unowned V search (TreeSearchFunc search_func); +- [CCode (cname = "g_tree_search")] +- public unowned V search_key (CompareFunc search_func, K key); +- public bool remove (K key); +- public bool steal (K key); +- } +- +- /* Internationalization */ +- +- [Version (since = "2.4")] +- [CCode (cname = "_", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string _ ([FormatArg] string str); +- [Version (since = "2.4")] +- [CCode (cname = "Q_", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string Q_ ([FormatArg] string str); +- [Version (since = "2.4")] +- [CCode (cname = "N_", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string N_ ([FormatArg] string str); +- [Version (since = "2.16")] +- [CCode (cname = "C_", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string C_ (string context, [FormatArg] string str); +- [Version (since = "2.18")] +- [CCode (cname = "NC_", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string NC_ (string context, [FormatArg] string str); +- [CCode (cname = "ngettext", cheader_filename = "glib.h,glib/gi18n-lib.h")] +- public static unowned string ngettext (string msgid, [FormatArg] string msgid_plural, ulong n); +- [Version (since = "2.18")] +- [CCode (cname = "g_dgettext", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string dgettext (string? domain, [FormatArg] string msgid); +- [Version (since = "2.26")] +- [CCode (cname = "g_dcgettext", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string dcgettext (string? domain, [FormatArg] string msgid, int category); +- [Version (since = "2.18")] +- [CCode (cname = "g_dngettext", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string dngettext (string? domain, string msgid, [FormatArg] string msgid_plural, ulong n); +- [Version (since = "2.16")] +- [CCode (cname = "g_dpgettext", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string dpgettext (string? domain, [FormatArg] string msgctxid, size_t msgidoffset); +- [Version (since = "2.18")] +- [CCode (cname = "g_dpgettext2", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string dpgettext2 (string? domain, string context, [FormatArg] string msgid); +- +- [CCode (cname = "int", cprefix = "LC_", cheader_filename = "locale.h", has_type_id = false)] +- public enum LocaleCategory { +- ALL, +- COLLATE, +- CTYPE, +- MESSAGES, +- MONETARY, +- NUMERIC, +- TIME +- } +- +- namespace Intl { +- [CCode (cname = "setlocale", cheader_filename = "locale.h")] +- public static unowned string? setlocale (LocaleCategory category = GLib.LocaleCategory.ALL, string? locale = ""); +- [CCode (cname = "bindtextdomain", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string? bindtextdomain (string domainname, string? dirname); +- [CCode (cname = "textdomain", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string? textdomain (string? domainname); +- [CCode (cname = "bind_textdomain_codeset", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string? bind_textdomain_codeset (string domainname, string? codeset); +- [Version (since = "2.6")] +- [CCode (cname = "g_get_language_names", array_length = false, array_null_terminated = true)] +- public static unowned string[] get_language_names (); +- [Version (since = "2.58")] +- [CCode (cname = "g_get_language_names_with_category", array_length = false, array_null_terminated = true)] +- public static unowned string[] get_language_names_with_category (string category_name); +- [Version (since = "2.4")] +- [CCode (cname = "g_strip_context", cheader_filename = "glib/gi18n-lib.h")] +- public static unowned string strip_context (string msgid, string msgval); +- } +- +- [Compact] +- public class PatternSpec { +- public PatternSpec (string pattern); +- public bool equal (PatternSpec pspec); +- [CCode (cname = "g_pattern_match")] +- public bool match (uint string_length, string str, string? str_reversed); +- [CCode (cname = "g_pattern_match_string")] +- public bool match_string (string str); +- [CCode (cname = "g_pattern_match_simple")] +- public static bool match_simple (string pattern, string str); +- } +- +- [CCode (lower_case_cprefix = "glib_version_")] +- namespace Version { +- [CCode (cname = "glib_major_version")] +- public const uint major; +- [CCode (cname = "glib_minor_version")] +- public const uint minor; +- [CCode (cname = "glib_micro_version")] +- public const uint micro; +- [CCode (cname = "glib_check_version")] +- public static unowned string? check (uint required_major, uint required_minor = 0, uint required_micro = 0); +- +- [CCode (cname = "GLIB_MAJOR_VERSION")] +- public const uint MAJOR; +- [CCode (cname = "GLIB_MINOR_VERSION")] +- public const uint MINOR; +- [CCode (cname = "GLIB_MICRO_VERSION")] +- public const uint MICRO; +- [CCode (cname = "GLIB_CHECK_VERSION")] +- public static bool CHECK (uint required_major, uint required_minor = 0, uint required_micro = 0); +- +- [CCode (cname = "G_ENCODE_VERSION")] +- public static uint encode (uint major, uint minor); +- +- public const uint CUR_STABLE; +- public const uint PREV_STABLE; +- public const uint MIN_REQUIRED; +- public const uint MAX_ALLOWED; +- +- public const uint @2_26; +- public const uint @2_28; +- public const uint @2_30; +- public const uint @2_32; +- public const uint @2_34; +- public const uint @2_36; +- public const uint @2_38; +- public const uint @2_40; +- public const uint @2_42; +- public const uint @2_44; +- public const uint @2_46; +- public const uint @2_48; +- public const uint @2_50; +- public const uint @2_52; +- public const uint @2_54; +- public const uint @2_56; +- public const uint @2_58; +- +- [CCode (cname = "glib_binary_age")] +- public const uint binary_age; +- [CCode (cname = "glib_interface_age")] +- public const uint interface_age; +- } +- +- namespace Win32 { +- public enum OSType { +- [CCode (cname = "G_WIN32_OS_ANY")] +- ANY, +- [CCode (cname = "G_WIN32_OS_WORKSTATION")] +- WORKSTATION, +- [CCode (cname = "G_WIN32_OS_SERVER")] +- SERVER, +- } +- [Version (since = "2.44")] +- public bool check_windows_version (int major, int minor, int spver, GLib.Win32.OSType os_type); +- +- public string error_message (int error); +- public string getlocale (); +- [Version (since = "2.16")] +- public string get_package_installation_directory_of_module (void* hmodule); +- public uint get_windows_version (); +- [Version (since = "2.8")] +- public string locale_filename_from_utf8 (string utf8filename); +- [CCode (cname = "G_WIN32_HAVE_WIDECHAR_API")] +- public bool have_widechar_api (); +- [CCode (cname = "G_WIN32_IS_NT_BASED")] +- public bool is_nt_based (); +- [Version (since = "2.40")] +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] get_command_line (); +- } +- +- [Compact] +- [Immutable] +- [Version (since = "2.24")] +- [CCode (copy_function = "g_variant_type_copy", free_function = "g_variant_type_free", type_id = "G_TYPE_VARIANT_TYPE")] +- public class VariantType { +- [CCode (cname = "G_VARIANT_TYPE_BOOLEAN")] +- public static VariantType BOOLEAN; +- [CCode (cname = "G_VARIANT_TYPE_BYTE")] +- public static VariantType BYTE; +- [CCode (cname = "G_VARIANT_TYPE_INT16")] +- public static VariantType INT16; +- [CCode (cname = "G_VARIANT_TYPE_UINT16")] +- public static VariantType UINT16; +- [CCode (cname = "G_VARIANT_TYPE_INT32")] +- public static VariantType INT32; +- [CCode (cname = "G_VARIANT_TYPE_UINT32")] +- public static VariantType UINT32; +- [CCode (cname = "G_VARIANT_TYPE_INT64")] +- public static VariantType INT64; +- [CCode (cname = "G_VARIANT_TYPE_UINT64")] +- public static VariantType UINT64; +- [CCode (cname = "G_VARIANT_TYPE_HANDLE")] +- public static VariantType HANDLE; +- [CCode (cname = "G_VARIANT_TYPE_DOUBLE")] +- public static VariantType DOUBLE; +- [CCode (cname = "G_VARIANT_TYPE_STRING")] +- public static VariantType STRING; +- [CCode (cname = "G_VARIANT_TYPE_OBJECT_PATH")] +- public static VariantType OBJECT_PATH; +- [CCode (cname = "G_VARIANT_TYPE_SIGNATURE")] +- public static VariantType SIGNATURE; +- [CCode (cname = "G_VARIANT_TYPE_VARIANT")] +- public static VariantType VARIANT; +- [CCode (cname = "G_VARIANT_TYPE_UNIT")] +- public static VariantType UNIT; +- [CCode (cname = "G_VARIANT_TYPE_ANY")] +- public static VariantType ANY; +- [CCode (cname = "G_VARIANT_TYPE_BASIC")] +- public static VariantType BASIC; +- [CCode (cname = "G_VARIANT_TYPE_MAYBE")] +- public static VariantType MAYBE; +- [CCode (cname = "G_VARIANT_TYPE_ARRAY")] +- public static VariantType ARRAY; +- [CCode (cname = "G_VARIANT_TYPE_TUPLE")] +- public static VariantType TUPLE; +- [CCode (cname = "G_VARIANT_TYPE_DICT_ENTRY")] +- public static VariantType DICT_ENTRY; +- [CCode (cname = "G_VARIANT_TYPE_DICTIONARY")] +- public static VariantType DICTIONARY; +- [CCode (cname = "G_VARIANT_TYPE_STRING_ARRAY")] +- public static VariantType STRING_ARRAY; +- [CCode (cname = "G_VARIANT_TYPE_OBJECT_PATH_ARRAY")] +- public static VariantType OBJECT_PATH_ARRAY; +- [CCode (cname = "G_VARIANT_TYPE_BYTESTRING")] +- public static VariantType BYTESTRING; +- [CCode (cname = "G_VARIANT_TYPE_BYTESTRING_ARRAY")] +- public static VariantType BYTESTRING_ARRAY; +- [Version (since = "2.30")] +- [CCode (cname = "G_VARIANT_TYPE_VARDICT")] +- public static VariantType VARDICT; +- +- public static bool string_is_valid (string type_string); +- public static bool string_scan (string type_string, char *limit, out char* endptr); +- +- public VariantType (string type_string); +- public size_t get_string_length (); +- public char* peek_string (); +- public string dup_string (); +- +- public bool is_definite (); +- public bool is_container (); +- public bool is_basic (); +- public bool is_maybe (); +- public bool is_array (); +- public bool is_tuple (); +- public bool is_dict_entry (); +- public bool is_variant (); +- +- public uint hash (); +- public bool equal (VariantType other); +- public bool is_subtype_of (VariantType supertype); +- +- public unowned VariantType element (); +- public unowned VariantType first (); +- public unowned VariantType next (); +- public unowned VariantType n_items (); +- public unowned VariantType key (); +- public unowned VariantType value (); +- +- public VariantType.array (VariantType element); +- public VariantType.maybe (VariantType element); +- public VariantType.tuple (VariantType[] items); +- public VariantType.dict_entry (VariantType key, VariantType value); +- } +- +- [Compact] +- [Version (since = "2.24")] +- [CCode (ref_function = "g_variant_ref", unref_function = "g_variant_unref", ref_sink_function = "g_variant_ref_sink", type_id = "G_TYPE_VARIANT", marshaller_type_name = "VARIANT", param_spec_function = "g_param_spec_variant", get_value_function = "g_value_get_variant", set_value_function = "g_value_set_variant", take_value_function = "g_value_take_variant", type_signature = "v")] +- public class Variant { +- [CCode (has_type_id = false)] +- public enum Class { +- BOOLEAN, BYTE, INT16, UINT16, INT32, UINT32, INT64, +- UINT64, HANDLE, DOUBLE, STRING, OBJECT_PATH, +- SIGNATURE, VARIANT, MAYBE, ARRAY, TUPLE, DICT_ENTRY +- } +- +- public unowned VariantType get_type (); +- public unowned string get_type_string (); +- public bool is_of_type (VariantType type); +- public bool is_container (); +- [Version (since = "2.26")] +- public bool is_floating (); +- public Class classify (); +- [Version (since = "2.26")] +- public int compare (Variant other); +- +- public Variant.boolean (bool value); +- public Variant.byte (uint8 value); +- public Variant.int16 (int16 value); +- public Variant.uint16 (uint16 value); +- public Variant.int32 (int32 value); +- public Variant.uint32 (uint32 value); +- public Variant.int64 (int64 value); +- public Variant.uint64 (uint64 value); +- public Variant.handle (int32 value); +- public Variant.double (double value); +- public Variant.string (string value); +- [Version (since = "2.26")] +- public Variant.bytestring (string value); +- public Variant.object_path (string object_path); +- public static bool is_object_path (string object_path); +- public Variant.signature (string signature); +- public static bool is_signature (string signature); +- +- public bool get_boolean (); +- public uint8 get_byte (); +- public int16 get_int16 (); +- public uint16 get_uint16 (); +- public int32 get_int32 (); +- public uint32 get_uint32 (); +- public int64 get_int64 (); +- public uint64 get_uint64 (); +- public int32 get_handle (); +- public double get_double (); +- public unowned string get_string (out size_t length = null); +- public string dup_string (out size_t length = null); +- [Version (since = "2.26")] +- public unowned string get_bytestring (); +- [Version (since = "2.26")] +- public string dup_bytestring (out size_t length); +- +- public Variant.strv (string[] value); +- [CCode (array_length_type = "size_t")] +-#if VALA_0_26 +- public (unowned string)[] get_strv (); +-#else +- public string*[] get_strv (); +-#endif +- [CCode (array_length_type = "size_t")] +- public string[] dup_strv (); +- +- [Version (since = "2.26")] +- public Variant.bytestring_array (string[] value); +- [Version (since = "2.26")] +- [CCode (array_length_type = "size_t")] +-#if VALA_0_26 +- public (unowned string)[] get_bytestring_array (); +-#else +- public string*[] get_bytestring_array (); +-#endif +- [Version (since = "2.26")] +- [CCode (array_length_type = "size_t")] +- public string[] dup_bytestring_array (); +- +- [Version (since = "2.30")] +- public Variant.objv (string[] value); +- [Version (since = "2.30")] +- [CCode (array_length_type = "size_t")] +-#if VALA_0_26 +- public (unowned string)[] get_objv (); +-#else +- public string*[] get_objv (); +-#endif +- [Version (since = "2.30")] +- [CCode (array_length_type = "size_t")] +- public string[] dup_objv (); +- +- public Variant (string format, ...); +- // note: the function changes its behaviour when end_ptr is null, so 'out char *' is wrong +- public Variant.va (string format, char **end_ptr, va_list *app); +- public void get (string format, ...); +- public void get_va (string format, char **end_ptr, va_list *app); +- +- public Variant.variant (Variant value); +- public Variant.maybe (VariantType? child_type, Variant? child); +- public Variant.array (VariantType? child_type, Variant[] children); +- [Version (since = "2.32")] +- [CCode (simple_generics = true)] +- public static Variant new_fixed_array (VariantType? element_type, [CCode (array_length_type = "gsize")] T[] elements, size_t element_size); +- public Variant.tuple (Variant[] children); +- public Variant.dict_entry (Variant key, Variant value); +- public Variant get_variant (); +- public Variant? get_maybe (); +- +- public size_t n_children (); +- public Variant get_child_value (size_t index); +- public void get_child (size_t index, string format_string, ...); +- +- [Version (since = "2.28")] +- public Variant? lookup_value (string key, VariantType? expected_type); +- [Version (since = "2.28")] +- public bool lookup (string key, string format_string, ...); +- +- public size_t get_size (); +- public void *get_data (); +- public void store (void *data); +- +- public string print (bool type_annotate); +- public StringBuilder print_string (StringBuilder? builder, bool type_annotate); +- +- public uint hash (); +- public bool equal (Variant other); +- +- public Variant byteswap (); +- public Variant get_normal_form (); +- public bool is_normal_form (); +- [CCode (returns_floating_reference = true, simple_generics = true)] +- public static Variant new_from_data (VariantType type, uchar[] data, bool trusted, [CCode (destroy_notify_pos = 3.9)] owned T? owner = null); +- +- [CCode (cname = "g_variant_iter_new")] +- public VariantIter iterator (); +- +- public static Variant parse (VariantType? type, string text, char *limit = null, char **endptr = null) throws GLib.VariantParseError; +- public Variant.parsed (string format_string, ...); +- +- [Version (since = "2.34")] +- public bool check_format_string (string format_string, bool copy_only); +- +- [Version (since = "2.36")] +- public Variant.from_bytes (VariantType type, Bytes bytes, bool trusted); +- [Version (since = "2.36")] +- public Bytes get_data_as_bytes (); +- +- [Version (since = "2.38")] +- public Variant.printf (string format_string, ...); +- [Version (since = "2.38")] +- public Variant.take_string (owned string str); +- +- [Version (since = "2.40")] +- public static void parse_error_print_context (GLib.VariantParseError error, string source_str); +- } +- +- [Version (since = "2.24")] +- public errordomain VariantParseError { +- FAILED, +- BASIC_TYPE_EXPECTED, +- CANNOT_INFER_TYPE, +- DEFINITE_TYPE_EXPECTED, +- INPUT_NOT_AT_END, +- INVALID_CHARACTER, +- INVALID_FORMAT_STRING, +- INVALID_OBJECT_PATH, +- INVALID_SIGNATURE, +- INVALID_TYPE_STRING, +- NO_COMMON_TYPE, +- NUMBER_OUT_OF_RANGE, +- NUMBER_TOO_BIG, +- TYPE_ERROR, +- UNEXPECTED_TOKEN, +- UNKNOWN_KEYWORD, +- UNTERMINATED_STRING_CONSTANT, +- VALUE_EXPECTED; +- public static GLib.Quark quark (); +- } +- +- [Compact] +- [Version (since = "2.24")] +- public class VariantIter { +- public VariantIter (Variant value); +- public size_t n_children (); +- public Variant? next_value (); +- public bool next (string format_string, ...); +- } +- +- [Compact] +- [Version (since = "2.24")] +- [CCode (ref_function = "g_variant_builder_ref", unref_function = "g_variant_builder_unref")] +- public class VariantBuilder { +- public VariantBuilder (VariantType type); +- public void open (VariantType type); +- public void close (); +- public void add_value (Variant value); +- public void add (string format_string, ...); +- [CCode (returns_floating_reference = true)] +- public Variant end (); +- } +- +- [Version (since = "2.40")] +- [Compact, CCode (ref_function = "g_variant_dict_ref", unref_function = "g_variant_dict_unref")] +- public class VariantDict { +- public VariantDict (GLib.Variant? from_asv = null); +- public bool lookup (string key, string format_string, ...); +- public GLib.Variant lookup_value (string key, GLib.VariantType expected_type); +- public bool contains (string key); +- public void insert (string key, string format_string, ...); +- public void insert_value (string key, GLib.Variant value); +- public bool remove (string key); +- public void clear (); +- [CCode (returns_floating_reference = true)] +- public GLib.Variant end (); +- } +- +- [CCode (cname = "char", const_cname = "const char", copy_function = "g_strdup", free_function = "g_free", cheader_filename = "stdlib.h,string.h,glib.h", type_id = "G_TYPE_STRING", marshaller_type_name = "STRING", param_spec_function = "g_param_spec_string", get_value_function = "g_value_get_string", set_value_function = "g_value_set_string", take_value_function = "g_value_take_string", type_signature = "o")] +- public class ObjectPath : string { +- [CCode (cname = "g_strdup")] +- public ObjectPath (string path); +- } +- +- [CCode (cname = "char", const_cname = "const char", copy_function = "g_strdup", free_function = "g_free", cheader_filename = "stdlib.h,string.h,glib.h", type_id = "G_TYPE_STRING", marshaller_type_name = "STRING", param_spec_function = "g_param_spec_string", get_value_function = "g_value_get_string", set_value_function = "g_value_set_string", take_value_function = "g_value_take_string")] +- public class BusName : string { +- [CCode (cname = "g_strdup")] +- public BusName (string bus_name); +- } +- +- [CCode (cname = "G_LIKELY", cheader_filename = "glib.h")] +- public static bool likely (bool expression); +- [CCode (cname = "G_UNLIKELY", cheader_filename = "glib.h")] +- public static bool unlikely (bool expression); +- [Version (since = "2.20")] +- [CCode (cname = "G_STATIC_ASSERT", cheader_filename = "glib.h")] +- public static void static_assert (bool expression); +- +- [CCode (simple_generics = true, cname = "g_qsort_with_data")] +- private static void _qsort_with_data (T[] elems, size_t size, [CCode (type = "GCompareDataFunc")] GLib.CompareDataFunc compare_func); +- +- [CCode (cname = "_vala_g_qsort_with_data")] +- public static void qsort_with_data (T[] elems, size_t size, [CCode (type = "GCompareDataFunc")] GLib.CompareDataFunc compare_func) { +- _qsort_with_data (elems, size, (a, b) => { +- return compare_func (*a, *b); +- }); +- } +- +- [Version (since = "2.54")] +- public errordomain NumberParserError { +- INVALID, +- OUT_OF_BOUNDS; +- public static GLib.Quark quark (); +- } +- +- /* Unix-specific functions. All of these have to include glib-unix.h. */ +- namespace Unix { +- [Version (since = "2.30")] +- [CCode (cheader_filename = "glib-unix.h", cname = "g_unix_signal_add_full")] +- public static uint signal_add (int signum, owned GLib.SourceFunc handler, [CCode (pos = 0.9)] int priority = Priority.DEFAULT); +- +- [CCode (cheader_filename = "glib-unix.h", cname = "GSource")] +- public class SignalSource : GLib.Source { +- public SignalSource (int signum); +- } +- +- [Version (since = "2.30")] +- [CCode (cheader_filename = "glib-unix.h")] +- public static bool open_pipe ([CCode (array_length = false, array_null_terminated = false)] int[] fds, int flags) throws GLib.Error; +- [Version (since = "2.30")] +- [CCode (cheader_filename = "glib-unix.h")] +- public static bool set_fd_nonblocking (int fd, bool nonblock) throws GLib.Error; +- } +- +- [CCode (cname = "GUnicodeScript", cprefix = "G_UNICODE_SCRIPT_", has_type_id = false)] +- public enum UnicodeScript { +- INVALID_CODE, +- COMMON, +- INHERITED, +- ARABIC, +- ARMENIAN, +- BENGALI, +- BOPOMOFO, +- CHEROKEE, +- COPTIC, +- CYRILLIC, +- DESERET, +- DEVANAGARI, +- ETHIOPIC, +- GEORGIAN, +- GOTHIC, +- GREEK, +- GUJARATI, +- GURMUKHI, +- HAN, +- HANGUL, +- HEBREW, +- HIRAGANA, +- KANNADA, +- KATAKANA, +- KHMER, +- LAO, +- LATIN, +- MALAYALAM, +- MONGOLIAN, +- MYANMAR, +- OGHAM, +- OLD_ITALIC, +- ORIYA, +- RUNIC, +- SINHALA, +- SYRIAC, +- TAMIL, +- TELUGU, +- THAANA, +- THAI, +- TIBETAN, +- CANADIAN_ABORIGINAL, +- YI, +- TAGALOG, +- HANUNOO, +- BUHID, +- TAGBANWA, +- +- BRAILLE, +- CYPRIOT, +- LIMBU, +- OSMANYA, +- SHAVIAN, +- LINEAR_B, +- TAI_LE, +- UGARITIC, +- +- NEW_TAI_LUE, +- BUGINESE, +- GLAGOLITIC, +- TIFINAGH, +- SYLOTI_NAGRI, +- OLD_PERSIAN, +- KHAROSHTHI, +- +- UNKNOWN, +- BALINESE, +- CUNEIFORM, +- PHOENICIAN, +- PHAGS_PA, +- NKO, +- +- KAYAH_LI, +- LEPCHA, +- REJANG, +- SUNDANESE, +- SAURASHTRA, +- CHAM, +- OL_CHIKI, +- VAI, +- CARIAN, +- LYCIAN, +- LYDIAN, +- +- /* Unicode-5.2 additions */ +- AVESTAN, /* Avst */ +- BAMUM, /* Bamu */ +- EGYPTIAN_HIEROGLYPHS, /* Egyp */ +- IMPERIAL_ARAMAIC, /* Armi */ +- INSCRIPTIONAL_PAHLAVI, /* Phli */ +- INSCRIPTIONAL_PARTHIAN, /* Prti */ +- JAVANESE, /* Java */ +- KAITHI, /* Kthi */ +- LISU, /* Lisu */ +- MEETEI_MAYEK, /* Mtei */ +- OLD_SOUTH_ARABIAN, /* Sarb */ +- OLD_TURKIC, /* Orkh */ +- SAMARITAN, /* Samr */ +- TAI_THAM, /* Lana */ +- TAI_VIET, /* Tavt */ +- +- /* Unicode-6.0 additions */ +- BATAK, /* Batk */ +- BRAHMI, /* Brah */ +- MANDAIC, /* Mand */ +- +- /* Unicode-6.1 additions */ +- CHAKMA, /* Cakm */ +- MEROITIC_CURSIVE, /* Merc */ +- MEROITIC_HIEROGLYPHS, /* Mero */ +- MIAO, /* Plrd */ +- SHARADA, /* Shrd */ +- SORA_SOMPENG, /* Sora */ +- TAKRI, /* Takr */ +- +- /* Unicode 7.0 additions */ +- BASSA_VAH, /* Bass */ +- CAUCASIAN_ALBANIAN, /* Aghb */ +- DUPLOYAN, /* Dupl */ +- ELBASAN, /* Elba */ +- GRANTHA, /* Gran */ +- KHOJKI, /* Khoj */ +- KHUDAWADI, /* Sind */ +- LINEAR_A, /* Lina */ +- MAHAJANI, /* Mahj */ +- MANICHAEAN, /* Manu */ +- MENDE_KIKAKUI, /* Mend */ +- MODI, /* Modi */ +- MRO, /* Mroo */ +- NABATAEAN, /* Nbat */ +- OLD_NORTH_ARABIAN, /* Narb */ +- OLD_PERMIC, /* Perm */ +- PAHAWH_HMONG, /* Hmng */ +- PALMYRENE, /* Palm */ +- PAU_CIN_HAU, /* Pauc */ +- PSALTER_PAHLAVI, /* Phlp */ +- SIDDHAM, /* Sidd */ +- TIRHUTA, /* Tirh */ +- WARANG_CITI, /* Wara */ +- +- /* Unicode 8.0 additions */ +- AHOM, /* Ahom */ +- ANATOLIAN_HIEROGLYPHS, /* Hluw */ +- HATRAN, /* Hatr */ +- MULTANI, /* Mult */ +- OLD_HUNGARIAN, /* Hung */ +- SIGNWRITING, /* Sgnw */ +- +- /* Unicode 9.0 additions */ +- ADLAM, /* Adlm */ +- BHAIKSUKI, /* Bhks */ +- MARCHEN, /* Marc */ +- NEWA, /* Newa */ +- OSAGE, /* Osge */ +- TANGUT, /* Tang */ +- +- /* Unicode 10.0 additions */ +- MASARAM_GONDI, /* Gonm */ +- NUSHU, /* Nshu */ +- SOYOMBO, /* Soyo */ +- ZANABAZAR_SQUARE, /* Zanb */ +- +- /* Unicode 11.0 additions */ +- DOGRA, /* Dogr */ +- GUNJALA_GONDI, /* Gong */ +- HANIFI_ROHINGYA, /* Rohg */ +- MAKASAR, /* Maka */ +- MEDEFAIDRIN, /* Medf */ +- OLD_SOGDIAN, /* Sogo */ +- SOGDIAN; /* Sogd */ +- +- [CCode (cname = "g_unicode_script_to_iso15924")] +- public uint32 to_iso15924 (); +- [CCode (cname = "g_unicode_script_from_iso15924")] +- public static GLib.UnicodeScript from_iso15924 (uint32 iso15924); +- } +- +- [CCode (cname = "GUnicodeType", cprefix = "G_UNICODE_", has_type_id = false)] +- public enum UnicodeType { +- CONTROL, +- FORMAT, +- UNASSIGNED, +- PRIVATE_USE, +- SURROGATE, +- LOWERCASE_LETTER, +- MODIFIER_LETTER, +- OTHER_LETTER, +- TITLECASE_LETTER, +- UPPERCASE_LETTER, +- COMBINING_MARK, +- ENCLOSING_MARK, +- NON_SPACING_MARK, +- DECIMAL_NUMBER, +- LETTER_NUMBER, +- OTHER_NUMBER, +- CONNECT_PUNCTUATION, +- DASH_PUNCTUATION, +- CLOSE_PUNCTUATION, +- FINAL_PUNCTUATION, +- INITIAL_PUNCTUATION, +- OTHER_PUNCTUATION, +- OPEN_PUNCTUATION, +- CURRENCY_SYMBOL, +- MODIFIER_SYMBOL, +- MATH_SYMBOL, +- OTHER_SYMBOL, +- LINE_SEPARATOR, +- PARAGRAPH_SEPARATOR, +- SPACE_SEPARATOR +- } +- +- [CCode (cname = "GUnicodeBreakType", cprefix = "G_UNICODE_BREAK_", has_type_id = false)] +- public enum UnicodeBreakType { +- MANDATORY, +- CARRIAGE_RETURN, +- LINE_FEED, +- COMBINING_MARK, +- SURROGATE, +- ZERO_WIDTH_SPACE, +- INSEPARABLE, +- NON_BREAKING_GLUE, +- CONTINGENT, +- SPACE, +- AFTER, +- BEFORE, +- BEFORE_AND_AFTER, +- HYPHEN, +- NON_STARTER, +- OPEN_PUNCTUATION, +- CLOSE_PUNCTUATION, +- QUOTATION, +- EXCLAMATION, +- IDEOGRAPHIC, +- NUMERIC, +- INFIX_SEPARATOR, +- SYMBOL, +- ALPHABETIC, +- PREFIX, +- POSTFIX, +- COMPLEX_CONTEXT, +- AMBIGUOUS, +- UNKNOWN, +- NEXT_LINE, +- WORD_JOINER, +- HANGUL_L_JAMO, +- HANGUL_V_JAMO, +- HANGUL_T_JAMO, +- HANGUL_LV_SYLLABLE, +- HANGUL_LVT_SYLLABLE, +- CLOSE_PARANTHESIS, +- CONDITIONAL_JAPANESE_STARTER, +- HEBREW_LETTER, +- REGIONAL_INDICATOR, +- EMOJI_BASE, +- EMOJI_MODIFIER, +- ZERO_WIDTH_JOINER +- } +- +- [CCode (cname = "GNormalizeMode", cprefix = "G_NORMALIZE_", has_type_id = false)] +- public enum NormalizeMode { +- DEFAULT, +- NFD, +- DEFAULT_COMPOSE, +- NFC, +- ALL, +- NFKD, +- ALL_COMPOSE, +- NFKC +- } +-} +diff --git a/vapi/gtksourceview-3.0.deps b/vapi/gtksourceview-3.0.deps +deleted file mode 100644 +index 1306ac49..00000000 +--- vapi/gtksourceview-3.0.deps ++++ /dev/null +@@ -1,7 +0,0 @@ +-atk +-gdk-3.0 +-gdk-pixbuf-2.0 +-gio-2.0 +-gtk+-3.0 +-pango +-cairo +diff --git a/vapi/gtksourceview-3.0.vapi b/vapi/gtksourceview-3.0.vapi +deleted file mode 100644 +index f1b8f66e..00000000 +--- vapi/gtksourceview-3.0.vapi ++++ /dev/null +@@ -1,937 +0,0 @@ +-/* gtksourceview-3.0.vapi generated by vapigen-0.28, do not modify. */ +- +-[CCode (cprefix = "Gtk", gir_namespace = "GtkSource", gir_version = "3.0", lower_case_cprefix = "gtk_")] +-namespace Gtk { +- namespace SourceUtils { +- [CCode (cheader_filename = "gtksourceview/gtksource.h")] +- public static string escape_search_text (string text); +- [CCode (cheader_filename = "gtksourceview/gtksource.h")] +- public static string unescape_search_text (string text); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_buffer_get_type ()")] +- [GIR (name = "Buffer")] +- public class SourceBuffer : Gtk.TextBuffer { +- [CCode (has_construct_function = false)] +- public SourceBuffer (Gtk.TextTagTable? table); +- public bool backward_iter_to_source_mark (ref Gtk.TextIter iter, string? category); +- public void begin_not_undoable_action (); +- public void change_case (Gtk.SourceChangeCaseType case_type, Gtk.TextIter start, Gtk.TextIter end); +- public unowned Gtk.SourceMark create_source_mark (string? name, string category, Gtk.TextIter where); +- public void end_not_undoable_action (); +- public void ensure_highlight (Gtk.TextIter start, Gtk.TextIter end); +- public bool forward_iter_to_source_mark (ref Gtk.TextIter iter, string? category); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] get_context_classes_at_iter (Gtk.TextIter iter); +- public bool get_highlight_matching_brackets (); +- public bool get_highlight_syntax (); +- public bool get_implicit_trailing_newline (); +- public unowned Gtk.SourceLanguage? get_language (); +- public int get_max_undo_levels (); +- public GLib.SList get_source_marks_at_iter (Gtk.TextIter iter, string? category); +- public GLib.SList get_source_marks_at_line (int line, string? category); +- public unowned Gtk.SourceStyleScheme? get_style_scheme (); +- public unowned Gtk.SourceUndoManager? get_undo_manager (); +- public bool iter_backward_to_context_class_toggle (ref Gtk.TextIter iter, string context_class); +- public bool iter_forward_to_context_class_toggle (ref Gtk.TextIter iter, string context_class); +- public bool iter_has_context_class (Gtk.TextIter iter, string context_class); +- public void join_lines (Gtk.TextIter start, Gtk.TextIter end); +- public void remove_source_marks (Gtk.TextIter start, Gtk.TextIter end, string? category); +- public void set_highlight_matching_brackets (bool highlight); +- public void set_highlight_syntax (bool highlight); +- public void set_implicit_trailing_newline (bool implicit_trailing_newline); +- public void set_language (Gtk.SourceLanguage? language); +- public void set_max_undo_levels (int max_undo_levels); +- public void set_style_scheme (Gtk.SourceStyleScheme? scheme); +- public void set_undo_manager (Gtk.SourceUndoManager? manager); +- public void sort_lines (Gtk.TextIter start, Gtk.TextIter end, Gtk.SourceSortFlags flags, int column); +- [CCode (has_construct_function = false)] +- public SourceBuffer.with_language (Gtk.SourceLanguage language); +- [NoAccessorMethod] +- public bool can_redo { get; } +- [NoAccessorMethod] +- public bool can_undo { get; } +- public bool highlight_matching_brackets { get; set; } +- public bool highlight_syntax { get; set; } +- public bool implicit_trailing_newline { get; set construct; } +- public Gtk.SourceLanguage language { get; set; } +- public int max_undo_levels { get; set; } +- public Gtk.SourceStyleScheme style_scheme { get; set; } +- public Gtk.SourceUndoManager undo_manager { get; set construct; } +- public virtual signal void bracket_matched (Gtk.TextIter iter, Gtk.SourceBracketMatchType state); +- public signal void highlight_updated (Gtk.TextIter start, Gtk.TextIter end); +- [HasEmitter] +- public virtual signal void redo (); +- public signal void source_mark_updated (Gtk.TextMark mark); +- [HasEmitter] +- public virtual signal void undo (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_get_type ()")] +- [GIR (name = "Completion")] +- public class SourceCompletion : GLib.Object, Gtk.Buildable { +- [CCode (has_construct_function = false)] +- protected SourceCompletion (); +- public bool add_provider (Gtk.SourceCompletionProvider provider) throws GLib.Error; +- public void block_interactive (); +- public unowned Gtk.SourceCompletionContext create_context (Gtk.TextIter? position); +- public unowned Gtk.SourceCompletionInfo get_info_window (); +- public unowned GLib.List get_providers (); +- public unowned Gtk.SourceView? get_view (); +- [Version (deprecated = true, deprecated_since = "3.8")] +- public void move_window (Gtk.TextIter iter); +- [NoWrapper] +- public virtual bool proposal_activated (Gtk.SourceCompletionProvider provider, Gtk.SourceCompletionProposal proposal); +- public bool remove_provider (Gtk.SourceCompletionProvider provider) throws GLib.Error; +- [CCode (cname = "gtk_source_completion_show")] +- public bool start (GLib.List? providers, Gtk.SourceCompletionContext context); +- public void unblock_interactive (); +- [NoAccessorMethod] +- public uint accelerators { get; set construct; } +- [NoAccessorMethod] +- public uint auto_complete_delay { get; set construct; } +- [NoAccessorMethod] +- public uint proposal_page_size { get; set construct; } +- [NoAccessorMethod] +- public uint provider_page_size { get; set construct; } +- [NoAccessorMethod] +- public bool remember_info_visibility { get; set construct; } +- [NoAccessorMethod] +- public bool select_on_show { get; set construct; } +- [NoAccessorMethod] +- public bool show_headers { get; set construct; } +- [NoAccessorMethod] +- public bool show_icons { get; set construct; } +- public Gtk.SourceView view { get; construct; } +- public virtual signal void activate_proposal (); +- [HasEmitter] +- public virtual signal void hide (); +- public virtual signal void move_cursor (Gtk.ScrollStep step, int num); +- public virtual signal void move_page (Gtk.ScrollStep step, int num); +- public virtual signal void populate_context (Gtk.SourceCompletionContext context); +- public virtual signal void show (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_context_get_type ()")] +- [GIR (name = "CompletionContext")] +- public class SourceCompletionContext : GLib.InitiallyUnowned { +- [CCode (has_construct_function = false)] +- protected SourceCompletionContext (); +- public void add_proposals (Gtk.SourceCompletionProvider provider, GLib.List? proposals, bool finished); +- public Gtk.SourceCompletionActivation get_activation (); +- public bool get_iter (out Gtk.TextIter iter); +- [NoAccessorMethod] +- public Gtk.SourceCompletionActivation activation { get; set construct; } +- [NoAccessorMethod] +- public Gtk.SourceCompletion completion { owned get; construct; } +- [NoAccessorMethod] +- public Gtk.TextIter iter { get; set; } +- public virtual signal void cancelled (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_info_get_type ()")] +- [GIR (name = "CompletionInfo")] +- public class SourceCompletionInfo : Gtk.Window, Atk.Implementor, Gtk.Buildable { +- [CCode (has_construct_function = false)] +- public SourceCompletionInfo (); +- [Version ( deprecated = true, deprecated_since = "3.8" )] +- public unowned Gtk.Widget get_widget (); +- public void move_to_iter (Gtk.TextView view, Gtk.TextIter? iter); +- [Version ( deprecated = true, deprecated_since = "3.8" )] +- public void set_widget (Gtk.Widget? widget); +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public virtual signal void before_show (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_item_get_type ()")] +- [GIR (name = "CompletionItem")] +- public class SourceCompletionItem : GLib.Object, Gtk.SourceCompletionProposal { +- [CCode (has_construct_function = false)] +- public SourceCompletionItem (string label, string text, Gdk.Pixbuf? icon, string? info); +- [CCode (has_construct_function = false)] +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public SourceCompletionItem.from_stock (string? label, string text, string stock, string? info); +- [CCode (has_construct_function = false)] +- public SourceCompletionItem.with_markup (string markup, string text, Gdk.Pixbuf? icon, string? info); +- [NoAccessorMethod] +- public GLib.Icon gicon { owned get; set; } +- [NoAccessorMethod] +- public Gdk.Pixbuf icon { owned get; set; } +- [NoAccessorMethod] +- public string icon_name { owned get; set; } +- [NoAccessorMethod] +- public string info { owned get; set; } +- [NoAccessorMethod] +- public string label { owned get; set; } +- [NoAccessorMethod] +- public string markup { owned get; set; } +- [NoAccessorMethod] +- public string text { owned get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_words_get_type ()")] +- [GIR (name = "CompletionWords")] +- public class SourceCompletionWords : GLib.Object, Gtk.SourceCompletionProvider { +- [CCode (has_construct_function = false)] +- public SourceCompletionWords (string? name, Gdk.Pixbuf? icon); +- public void register (Gtk.TextBuffer buffer); +- public void unregister (Gtk.TextBuffer buffer); +- [NoAccessorMethod] +- public Gtk.SourceCompletionActivation activation { get; set construct; } +- [NoAccessorMethod] +- public Gdk.Pixbuf icon { owned get; set construct; } +- [NoAccessorMethod] +- public int interactive_delay { get; set construct; } +- [NoAccessorMethod] +- public uint minimum_word_size { get; set construct; } +- [NoAccessorMethod] +- public string name { owned get; set construct; } +- [NoAccessorMethod] +- public int priority { get; set construct; } +- [NoAccessorMethod] +- public uint proposals_batch_size { get; set construct; } +- [NoAccessorMethod] +- public uint scan_batch_size { get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "gtk_source_encoding_get_type ()")] +- [Compact] +- [GIR (name = "Encoding")] +- public class SourceEncoding { +- public Gtk.SourceEncoding copy (); +- [CCode (cname = "gtk_source_encoding_get_all")] +- public static GLib.SList et_all (); +- [CCode (cname = "gtk_source_encoding_get_current")] +- public static unowned Gtk.SourceEncoding et_current (); +- [CCode (cname = "gtk_source_encoding_get_default_candidates")] +- public static GLib.SList et_default_candidates (); +- [CCode (cname = "gtk_source_encoding_get_from_charset")] +- public static unowned Gtk.SourceEncoding? et_from_charset (string charset); +- [CCode (cname = "gtk_source_encoding_get_utf8")] +- public static unowned Gtk.SourceEncoding et_utf8 (); +- public void free (); +- public unowned string get_charset (); +- public unowned string get_name (); +- public string to_string (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_file_get_type ()")] +- [GIR (name = "File")] +- public class SourceFile : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceFile (); +- public void check_file_on_disk (); +- public Gtk.SourceCompressionType get_compression_type (); +- public unowned Gtk.SourceEncoding get_encoding (); +- public unowned GLib.File get_location (); +- public Gtk.SourceNewlineType get_newline_type (); +- public bool is_deleted (); +- public bool is_externally_modified (); +- public bool is_local (); +- public bool is_readonly (); +- public void set_location (GLib.File? location); +- public Gtk.SourceCompressionType compression_type { get; } +- public Gtk.SourceEncoding encoding { get; } +- public GLib.File location { get; set construct; } +- public Gtk.SourceNewlineType newline_type { get; } +- [NoAccessorMethod] +- public bool read_only { get; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_file_loader_get_type ()")] +- [GIR (name = "FileLoader")] +- public class SourceFileLoader : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceFileLoader (Gtk.SourceBuffer buffer, Gtk.SourceFile file); +- [CCode (has_construct_function = false)] +- public SourceFileLoader.from_stream (Gtk.SourceBuffer buffer, Gtk.SourceFile file, GLib.InputStream stream); +- public unowned Gtk.SourceBuffer get_buffer (); +- public Gtk.SourceCompressionType get_compression_type (); +- public unowned Gtk.SourceEncoding get_encoding (); +- public unowned Gtk.SourceFile get_file (); +- public unowned GLib.InputStream? get_input_stream (); +- public unowned GLib.File? get_location (); +- public Gtk.SourceNewlineType get_newline_type (); +- public async bool load_async (int io_priority, GLib.Cancellable? cancellable, owned GLib.FileProgressCallback? progress_callback) throws GLib.Error; +- public void set_candidate_encodings (GLib.SList candidate_encodings); +- public Gtk.SourceBuffer buffer { get; construct; } +- public Gtk.SourceFile file { get; construct; } +- public GLib.InputStream input_stream { get; construct; } +- public GLib.File location { get; construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_file_saver_get_type ()")] +- [GIR (name = "FileSaver")] +- public class SourceFileSaver : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceFileSaver (Gtk.SourceBuffer buffer, Gtk.SourceFile file); +- public unowned Gtk.SourceBuffer get_buffer (); +- public Gtk.SourceCompressionType get_compression_type (); +- public unowned Gtk.SourceEncoding get_encoding (); +- public unowned Gtk.SourceFile get_file (); +- public Gtk.SourceFileSaverFlags get_flags (); +- public unowned GLib.File get_location (); +- public Gtk.SourceNewlineType get_newline_type (); +- public async bool save_async (int io_priority, GLib.Cancellable? cancellable, owned GLib.FileProgressCallback? progress_callback) throws GLib.Error; +- public void set_compression_type (Gtk.SourceCompressionType compression_type); +- public void set_encoding (Gtk.SourceEncoding? encoding); +- public void set_flags (Gtk.SourceFileSaverFlags flags); +- public void set_newline_type (Gtk.SourceNewlineType newline_type); +- [CCode (has_construct_function = false)] +- public SourceFileSaver.with_target (Gtk.SourceBuffer buffer, Gtk.SourceFile file, GLib.File target_location); +- public Gtk.SourceBuffer buffer { get; construct; } +- public Gtk.SourceCompressionType compression_type { get; set construct; } +- public Gtk.SourceEncoding encoding { get; set construct; } +- public Gtk.SourceFile file { get; construct; } +- public Gtk.SourceFileSaverFlags flags { get; set construct; } +- public GLib.File location { get; construct; } +- public Gtk.SourceNewlineType newline_type { get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_get_type ()")] +- [GIR (name = "Gutter")] +- public class SourceGutter : GLib.Object { +- [CCode (has_construct_function = false)] +- protected SourceGutter (); +- [Version ( deprecated = true, deprecated_since = "3.12" )] +- public void get_padding (int xpad, int ypad); +- public unowned Gtk.SourceGutterRenderer? get_renderer_at_pos (int x, int y); +- [Version ( deprecated = true, deprecated_since = "3.12" )] +- public unowned Gdk.Window get_window (); +- public bool insert (Gtk.SourceGutterRenderer renderer, int position); +- public void queue_draw (); +- public void remove (Gtk.SourceGutterRenderer renderer); +- public void reorder (Gtk.SourceGutterRenderer renderer, int position); +- [Version ( deprecated = true, deprecated_since = "3.12" )] +- public void set_padding (int xpad, int ypad); +- [NoAccessorMethod] +- public Gtk.SourceView view { owned get; construct; } +- [NoAccessorMethod] +- public Gtk.TextWindowType window_type { get; construct; } +- [Version ( deprecated = true, deprecated_since = "3.12" )] +- [NoAccessorMethod] +- public int xpad { get; set construct; } +- [Version ( deprecated = true, deprecated_since = "3.12" )] +- [NoAccessorMethod] +- public int ypad { get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_renderer_get_type ()")] +- [GIR (name = "GutterRenderer")] +- public abstract class SourceGutterRenderer : GLib.InitiallyUnowned { +- [CCode (has_construct_function = false)] +- protected SourceGutterRenderer (); +- public virtual void begin (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end); +- [NoWrapper] +- public virtual void change_buffer (Gtk.TextBuffer old_buffer); +- [NoWrapper] +- public virtual void change_view (Gtk.TextView? old_view); +- public virtual void draw (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end, Gtk.SourceGutterRendererState state); +- public virtual void end (); +- public void get_alignment (out float xalign, out float yalign); +- public Gtk.SourceGutterRendererAlignmentMode get_alignment_mode (); +- public bool get_background (out Gdk.RGBA color); +- public void get_padding (out int xpad, out int ypad); +- public int get_size (); +- public unowned Gtk.TextView get_view (); +- public bool get_visible (); +- public Gtk.TextWindowType get_window_type (); +- public void set_alignment (float xalign, float yalign); +- public void set_alignment_mode (Gtk.SourceGutterRendererAlignmentMode mode); +- public void set_background (Gdk.RGBA? color); +- public void set_padding (int xpad, int ypad); +- public void set_size (int size); +- public void set_visible (bool visible); +- public Gtk.SourceGutterRendererAlignmentMode alignment_mode { get; set construct; } +- [NoAccessorMethod] +- public Gdk.RGBA background_rgba { get; set; } +- [NoAccessorMethod] +- public bool background_set { get; set construct; } +- public int size { get; set construct; } +- public Gtk.TextView view { get; } +- public bool visible { get; set construct; } +- public Gtk.TextWindowType window_type { get; } +- [NoAccessorMethod] +- public float xalign { get; set construct; } +- [NoAccessorMethod] +- public int xpad { get; set construct; } +- [NoAccessorMethod] +- public float yalign { get; set construct; } +- [NoAccessorMethod] +- public int ypad { get; set construct; } +- [HasEmitter] +- public virtual signal void activate (Gtk.TextIter iter, Cairo.RectangleInt area, Gdk.Event event); +- [HasEmitter] +- public virtual signal bool query_activatable (Gtk.TextIter iter, Cairo.RectangleInt area, Gdk.Event event); +- [HasEmitter] +- public virtual signal void query_data (Gtk.TextIter start, Gtk.TextIter end, Gtk.SourceGutterRendererState state); +- [HasEmitter] +- public virtual signal bool query_tooltip (Gtk.TextIter iter, Cairo.RectangleInt area, int x, int y, Gtk.Tooltip tooltip); +- [HasEmitter] +- public virtual signal void queue_draw (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_renderer_pixbuf_get_type ()")] +- [GIR (name = "GutterRendererPixbuf")] +- public class SourceGutterRendererPixbuf : Gtk.SourceGutterRenderer { +- [CCode (has_construct_function = false, type = "GtkSourceGutterRenderer*")] +- public SourceGutterRendererPixbuf (); +- public unowned GLib.Icon get_gicon (); +- public unowned string get_icon_name (); +- public unowned Gdk.Pixbuf get_pixbuf (); +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public unowned string get_stock_id (); +- public void set_gicon (GLib.Icon? icon); +- public void set_icon_name (string? icon_name); +- public void set_pixbuf (Gdk.Pixbuf? pixbuf); +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public void set_stock_id (string? stock_id); +- public GLib.Icon gicon { get; set; } +- public string icon_name { get; set; } +- public Gdk.Pixbuf pixbuf { get; set; } +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public string stock_id { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_renderer_text_get_type ()")] +- [GIR (name = "GutterRendererText")] +- public class SourceGutterRendererText : Gtk.SourceGutterRenderer { +- [CCode (has_construct_function = false, type = "GtkSourceGutterRenderer*")] +- public SourceGutterRendererText (); +- public void measure (string text, out int width, out int height); +- public void measure_markup (string markup, out int width, out int height); +- public void set_markup (string markup, int length); +- public void set_text (string text, int length); +- [NoAccessorMethod] +- public string markup { owned get; set construct; } +- [NoAccessorMethod] +- public string text { owned get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_language_get_type ()")] +- [GIR (name = "Language")] +- public class SourceLanguage : GLib.Object { +- [CCode (has_construct_function = false)] +- protected SourceLanguage (); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[]? get_globs (); +- public bool get_hidden (); +- public unowned string get_id (); +- public unowned string? get_metadata (string name); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[]? get_mime_types (); +- public unowned string get_name (); +- public unowned string get_section (); +- public unowned string? get_style_fallback (string style_id); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[]? get_style_ids (); +- public unowned string? get_style_name (string style_id); +- public bool hidden { get; } +- public string id { get; } +- public string name { get; } +- public string section { get; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_language_manager_get_type ()")] +- [GIR (name = "LanguageManager")] +- public class SourceLanguageManager : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceLanguageManager (); +- public static unowned Gtk.SourceLanguageManager get_default (); +- public unowned Gtk.SourceLanguage? get_language (string id); +- [CCode (array_length = false, array_null_terminated = true)] +- public unowned string[]? get_language_ids (); +- [CCode (array_length = false, array_null_terminated = true)] +- public unowned string[] get_search_path (); +- public unowned Gtk.SourceLanguage? guess_language (string? filename, string? content_type); +- public void set_search_path ([CCode (array_length = false, array_null_terminated = true)] string[]? dirs); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] language_ids { get; } +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] search_path { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_map_get_type ()")] +- [GIR (name = "Map")] +- public class SourceMap : Gtk.SourceView, Atk.Implementor, Gtk.Buildable, Gtk.Scrollable { +- [CCode (has_construct_function = false, type = "GtkWidget*")] +- public SourceMap (); +- public unowned Gtk.SourceView? get_view (); +- public void set_view (Gtk.SourceView view); +- [NoAccessorMethod] +- public Pango.FontDescription font_desc { owned get; set; } +- public Gtk.SourceView view { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_mark_get_type ()")] +- [GIR (name = "Mark")] +- public class SourceMark : Gtk.TextMark { +- [CCode (has_construct_function = false)] +- public SourceMark (string name, string category); +- public unowned string get_category (); +- public unowned Gtk.SourceMark? next (string? category); +- public unowned Gtk.SourceMark? prev (string category); +- public string category { get; construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_mark_attributes_get_type ()")] +- [GIR (name = "MarkAttributes")] +- public class SourceMarkAttributes : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceMarkAttributes (); +- public bool get_background (out Gdk.RGBA background); +- public unowned GLib.Icon get_gicon (); +- public unowned string get_icon_name (); +- public unowned Gdk.Pixbuf get_pixbuf (); +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public unowned string get_stock_id (); +- public string get_tooltip_markup (Gtk.SourceMark mark); +- public string get_tooltip_text (Gtk.SourceMark mark); +- public unowned Gdk.Pixbuf render_icon (Gtk.Widget widget, int size); +- public void set_background (Gdk.RGBA background); +- public void set_gicon (GLib.Icon gicon); +- public void set_icon_name (string icon_name); +- public void set_pixbuf (Gdk.Pixbuf pixbuf); +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public void set_stock_id (string stock_id); +- [NoAccessorMethod] +- public Gdk.RGBA background { get; set; } +- public GLib.Icon gicon { get; set; } +- public string icon_name { get; set; } +- public Gdk.Pixbuf pixbuf { get; set; } +- [Version ( deprecated = true, deprecated_since = "3.10" )] +- public string stock_id { get; set; } +- public signal string query_tooltip_markup (Gtk.SourceMark mark); +- public signal string query_tooltip_text (Gtk.SourceMark mark); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_print_compositor_get_type ()")] +- [GIR (name = "PrintCompositor")] +- public class SourcePrintCompositor : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourcePrintCompositor (Gtk.SourceBuffer buffer); +- public void draw_page (Gtk.PrintContext context, int page_nr); +- [CCode (has_construct_function = false)] +- public SourcePrintCompositor.from_view (Gtk.SourceView view); +- public string get_body_font_name (); +- public double get_bottom_margin (Gtk.Unit unit); +- public unowned Gtk.SourceBuffer get_buffer (); +- public string get_footer_font_name (); +- public string get_header_font_name (); +- public bool get_highlight_syntax (); +- public double get_left_margin (Gtk.Unit unit); +- public string get_line_numbers_font_name (); +- public int get_n_pages (); +- public double get_pagination_progress (); +- public bool get_print_footer (); +- public bool get_print_header (); +- public uint get_print_line_numbers (); +- public double get_right_margin (Gtk.Unit unit); +- public uint get_tab_width (); +- public double get_top_margin (Gtk.Unit unit); +- public Gtk.WrapMode get_wrap_mode (); +- public bool paginate (Gtk.PrintContext context); +- public void set_body_font_name (string font_name); +- public void set_bottom_margin (double margin, Gtk.Unit unit); +- public void set_footer_font_name (string? font_name); +- public void set_footer_format (bool separator, string? left, string? center, string? right); +- public void set_header_font_name (string? font_name); +- public void set_header_format (bool separator, string? left, string? center, string? right); +- public void set_highlight_syntax (bool highlight); +- public void set_left_margin (double margin, Gtk.Unit unit); +- public void set_line_numbers_font_name (string? font_name); +- public void set_print_footer (bool print); +- public void set_print_header (bool print); +- public void set_print_line_numbers (uint interval); +- public void set_right_margin (double margin, Gtk.Unit unit); +- public void set_tab_width (uint width); +- public void set_top_margin (double margin, Gtk.Unit unit); +- public void set_wrap_mode (Gtk.WrapMode wrap_mode); +- public string body_font_name { owned get; set; } +- public Gtk.SourceBuffer buffer { get; construct; } +- public string footer_font_name { owned get; set; } +- public string header_font_name { owned get; set; } +- public bool highlight_syntax { get; set; } +- public string line_numbers_font_name { owned get; set; } +- public int n_pages { get; } +- public bool print_footer { get; set; } +- public bool print_header { get; set; } +- public uint print_line_numbers { get; set; } +- public uint tab_width { get; set; } +- public Gtk.WrapMode wrap_mode { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_search_context_get_type ()")] +- [GIR (name = "SearchContext")] +- public class SourceSearchContext : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceSearchContext (Gtk.SourceBuffer buffer, Gtk.SourceSearchSettings? settings); +- public bool backward (Gtk.TextIter iter, out Gtk.TextIter match_start, out Gtk.TextIter match_end); +- public async bool backward_async (Gtk.TextIter iter, GLib.Cancellable? cancellable, out Gtk.TextIter match_start, out Gtk.TextIter match_end) throws GLib.Error; +- public bool forward (Gtk.TextIter iter, out Gtk.TextIter match_start, out Gtk.TextIter match_end); +- public async bool forward_async (Gtk.TextIter iter, GLib.Cancellable? cancellable, out Gtk.TextIter match_start, out Gtk.TextIter match_end) throws GLib.Error; +- public unowned Gtk.SourceBuffer get_buffer (); +- public bool get_highlight (); +- public unowned Gtk.SourceStyle get_match_style (); +- public int get_occurrence_position (Gtk.TextIter match_start, Gtk.TextIter match_end); +- public int get_occurrences_count (); +- public GLib.Error? get_regex_error (); +- public unowned Gtk.SourceSearchSettings get_settings (); +- public bool replace (Gtk.TextIter match_start, Gtk.TextIter match_end, string replace, int replace_length) throws GLib.Error; +- public uint replace_all (string replace, int replace_length) throws GLib.Error; +- public void set_highlight (bool highlight); +- public void set_match_style (Gtk.SourceStyle? match_style); +- public void set_settings (Gtk.SourceSearchSettings? settings); +- public Gtk.SourceBuffer buffer { get; construct; } +- public bool highlight { get; set construct; } +- public Gtk.SourceStyle match_style { get; set construct; } +- public int occurrences_count { get; } +- public GLib.Error? regex_error { owned get; } +- public Gtk.SourceSearchSettings settings { get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_search_settings_get_type ()")] +- [GIR (name = "SearchSettings")] +- public class SourceSearchSettings : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceSearchSettings (); +- public bool get_at_word_boundaries (); +- public bool get_case_sensitive (); +- public bool get_regex_enabled (); +- public unowned string? get_search_text (); +- public bool get_wrap_around (); +- public void set_at_word_boundaries (bool at_word_boundaries); +- public void set_case_sensitive (bool case_sensitive); +- public void set_regex_enabled (bool regex_enabled); +- public void set_search_text (string? search_text); +- public void set_wrap_around (bool wrap_around); +- public bool at_word_boundaries { get; set construct; } +- public bool case_sensitive { get; set construct; } +- public bool regex_enabled { get; set construct; } +- public string search_text { get; set construct; } +- public bool wrap_around { get; set construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_get_type ()")] +- [GIR (name = "Style")] +- public class SourceStyle : GLib.Object { +- [CCode (has_construct_function = false)] +- protected SourceStyle (); +- public Gtk.SourceStyle copy (); +- [NoAccessorMethod] +- public string background { owned get; construct; } +- [NoAccessorMethod] +- public bool background_set { get; construct; } +- [NoAccessorMethod] +- public bool bold { get; construct; } +- [NoAccessorMethod] +- public bool bold_set { get; construct; } +- [NoAccessorMethod] +- public string foreground { owned get; construct; } +- [NoAccessorMethod] +- public bool foreground_set { get; construct; } +- [NoAccessorMethod] +- public bool italic { get; construct; } +- [NoAccessorMethod] +- public bool italic_set { get; construct; } +- [NoAccessorMethod] +- public string line_background { owned get; construct; } +- [NoAccessorMethod] +- public bool line_background_set { get; construct; } +- [NoAccessorMethod] +- public Pango.Underline pango_underline { get; construct; } +- [NoAccessorMethod] +- public string scale { owned get; construct; } +- [NoAccessorMethod] +- public bool scale_set { get; construct; } +- [NoAccessorMethod] +- public bool strikethrough { get; construct; } +- [NoAccessorMethod] +- public bool strikethrough_set { get; construct; } +- [Version ( deprecated = true, deprecated_since = "3.18" )] +- [NoAccessorMethod] +- public bool underline { get; construct; } +- [NoAccessorMethod] +- public string underline_color { owned get; construct; } +- [NoAccessorMethod] +- public bool underline_color_set { get; construct; } +- [NoAccessorMethod] +- public bool underline_set { get; construct; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_scheme_get_type ()")] +- [GIR (name = "StyleScheme")] +- public class SourceStyleScheme : GLib.Object { +- [CCode (has_construct_function = false)] +- protected SourceStyleScheme (); +- [CCode (array_length = false, array_null_terminated = true)] +- public unowned string[]? get_authors (); +- public unowned string? get_description (); +- public unowned string? get_filename (); +- public unowned string get_id (); +- public unowned string get_name (); +- public unowned Gtk.SourceStyle? get_style (string style_id); +- public string description { get; } +- public string filename { get; } +- public string id { get; construct; } +- public string name { get; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_scheme_chooser_button_get_type ()")] +- [GIR (name = "StyleSchemeChooserButton")] +- public class SourceStyleSchemeChooserButton : Gtk.Button, Atk.Implementor, Gtk.Actionable, Gtk.Activatable, Gtk.Buildable, Gtk.SourceStyleSchemeChooser { +- [CCode (has_construct_function = false, type = "GtkWidget*")] +- public SourceStyleSchemeChooserButton (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_scheme_chooser_widget_get_type ()")] +- [GIR (name = "StyleSchemeChooserWidget")] +- public class SourceStyleSchemeChooserWidget : Gtk.Bin, Atk.Implementor, Gtk.Buildable, Gtk.SourceStyleSchemeChooser { +- [CCode (has_construct_function = false, type = "GtkWidget*")] +- public SourceStyleSchemeChooserWidget (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_scheme_manager_get_type ()")] +- [GIR (name = "StyleSchemeManager")] +- public class SourceStyleSchemeManager : GLib.Object { +- [CCode (has_construct_function = false)] +- public SourceStyleSchemeManager (); +- public void append_search_path (string path); +- public void force_rescan (); +- public static unowned Gtk.SourceStyleSchemeManager get_default (); +- public unowned Gtk.SourceStyleScheme get_scheme (string scheme_id); +- [CCode (array_length = false, array_null_terminated = true)] +- public unowned string[]? get_scheme_ids (); +- [CCode (array_length = false, array_null_terminated = true)] +- public unowned string[] get_search_path (); +- public void prepend_search_path (string path); +- public void set_search_path ([CCode (array_length = false, array_null_terminated = true)] string[]? path); +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] scheme_ids { get; } +- [CCode (array_length = false, array_null_terminated = true)] +- public string[] search_path { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_view_get_type ()")] +- [GIR (name = "View")] +- public class SourceView : Gtk.TextView, Atk.Implementor, Gtk.Buildable, Gtk.Scrollable { +- [CCode (has_construct_function = false, type = "GtkWidget*")] +- public SourceView (); +- public bool get_auto_indent (); +- public Gtk.SourceBackgroundPatternType get_background_pattern (); +- public unowned Gtk.SourceCompletion get_completion (); +- public Gtk.SourceDrawSpacesFlags get_draw_spaces (); +- public unowned Gtk.SourceGutter get_gutter (Gtk.TextWindowType window_type); +- public bool get_highlight_current_line (); +- public bool get_indent_on_tab (); +- public int get_indent_width (); +- public bool get_insert_spaces_instead_of_tabs (); +- public unowned Gtk.SourceMarkAttributes get_mark_attributes (string category, int priority); +- public uint get_right_margin_position (); +- public bool get_show_line_marks (); +- public bool get_show_line_numbers (); +- public bool get_show_right_margin (); +- public bool get_smart_backspace (); +- public Gtk.SourceSmartHomeEndType get_smart_home_end (); +- public uint get_tab_width (); +- public uint get_visual_column (Gtk.TextIter iter); +- public void indent_lines (Gtk.TextIter start, Gtk.TextIter end); +- public void set_auto_indent (bool enable); +- public void set_background_pattern (Gtk.SourceBackgroundPatternType background_pattern); +- public void set_draw_spaces (Gtk.SourceDrawSpacesFlags flags); +- public void set_highlight_current_line (bool highlight); +- public void set_indent_on_tab (bool enable); +- public void set_indent_width (int width); +- public void set_insert_spaces_instead_of_tabs (bool enable); +- public void set_mark_attributes (string category, Gtk.SourceMarkAttributes attributes, int priority); +- public void set_right_margin_position (uint pos); +- public void set_show_line_marks (bool show); +- public void set_show_line_numbers (bool show); +- public void set_show_right_margin (bool show); +- public void set_smart_backspace (bool smart_backspace); +- public void set_smart_home_end (Gtk.SourceSmartHomeEndType smart_home_end); +- public void set_tab_width (uint width); +- public void unindent_lines (Gtk.TextIter start, Gtk.TextIter end); +- [CCode (has_construct_function = false, type = "GtkWidget*")] +- public SourceView.with_buffer (Gtk.SourceBuffer buffer); +- public bool auto_indent { get; set; } +- public Gtk.SourceBackgroundPatternType background_pattern { get; set; } +- public Gtk.SourceCompletion completion { get; } +- public Gtk.SourceDrawSpacesFlags draw_spaces { get; set; } +- public bool highlight_current_line { get; set; } +- public bool indent_on_tab { get; set; } +- public int indent_width { get; set; } +- public bool insert_spaces_instead_of_tabs { get; set; } +- public uint right_margin_position { get; set; } +- public bool show_line_marks { get; set; } +- public bool show_line_numbers { get; set; } +- public bool show_right_margin { get; set; } +- public bool smart_backspace { get; set; } +- public Gtk.SourceSmartHomeEndType smart_home_end { get; set; } +- public uint tab_width { get; set; } +- public signal void change_case (Gtk.SourceChangeCaseType case_type); +- public signal void change_number (int count); +- public signal void join_lines (); +- public virtual signal void line_mark_activated (Gtk.TextIter iter, Gdk.Event event); +- public virtual signal void move_lines (bool copy, int step); +- public signal void move_to_matching_bracket (bool extend_selection); +- public virtual signal void move_words (int step); +- public virtual signal void redo (); +- public virtual signal void show_completion (); +- public virtual signal void undo (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_proposal_get_type ()")] +- [GIR (name = "CompletionProposal")] +- public interface SourceCompletionProposal : GLib.Object { +- public virtual bool equal (Gtk.SourceCompletionProposal other); +- public abstract unowned GLib.Icon? get_gicon (); +- public virtual unowned Gdk.Pixbuf? get_icon (); +- public abstract unowned string? get_icon_name (); +- public abstract string? get_info (); +- public abstract string get_label (); +- public abstract string get_markup (); +- public abstract string get_text (); +- public virtual uint hash (); +- [HasEmitter] +- public virtual signal void changed (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_provider_get_type ()")] +- [GIR (name = "CompletionProvider")] +- public interface SourceCompletionProvider : GLib.Object { +- public virtual bool activate_proposal (Gtk.SourceCompletionProposal proposal, Gtk.TextIter iter); +- public virtual Gtk.SourceCompletionActivation get_activation (); +- public virtual unowned GLib.Icon? get_gicon (); +- public virtual unowned Gdk.Pixbuf? get_icon (); +- public virtual unowned string? get_icon_name (); +- public virtual unowned Gtk.Widget? get_info_widget (Gtk.SourceCompletionProposal proposal); +- public virtual int get_interactive_delay (); +- public virtual string get_name (); +- public virtual int get_priority (); +- public virtual bool get_start_iter (Gtk.SourceCompletionContext context, Gtk.SourceCompletionProposal proposal, out Gtk.TextIter iter); +- public virtual bool match (Gtk.SourceCompletionContext context); +- public virtual void populate (Gtk.SourceCompletionContext context); +- public virtual void update_info (Gtk.SourceCompletionProposal proposal, Gtk.SourceCompletionInfo info); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_scheme_chooser_get_type ()")] +- [GIR (name = "StyleSchemeChooser")] +- public interface SourceStyleSchemeChooser : GLib.Object { +- public abstract unowned Gtk.SourceStyleScheme get_style_scheme (); +- public abstract void set_style_scheme (Gtk.SourceStyleScheme scheme); +- public abstract Gtk.SourceStyleScheme style_scheme { get; set; } +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_undo_manager_get_type ()")] +- [GIR (name = "UndoManager")] +- public interface SourceUndoManager : GLib.Object { +- public abstract void begin_not_undoable_action (); +- public abstract bool can_redo (); +- public abstract bool can_undo (); +- public abstract void end_not_undoable_action (); +- public abstract void redo (); +- public abstract void undo (); +- [HasEmitter] +- public virtual signal void can_redo_changed (); +- [HasEmitter] +- public virtual signal void can_undo_changed (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_BACKGROUND_PATTERN_TYPE_", type_id = "gtk_source_background_pattern_type_get_type ()")] +- [GIR (name = "BackgroundPatternType")] +- public enum SourceBackgroundPatternType { +- NONE, +- GRID +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_BRACKET_MATCH_", type_id = "gtk_source_bracket_match_type_get_type ()")] +- [GIR (name = "BracketMatchType")] +- public enum SourceBracketMatchType { +- NONE, +- OUT_OF_RANGE, +- NOT_FOUND, +- FOUND +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_CHANGE_CASE_", type_id = "gtk_source_change_case_type_get_type ()")] +- [GIR (name = "ChangeCaseType")] +- public enum SourceChangeCaseType { +- LOWER, +- UPPER, +- TOGGLE, +- TITLE +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_COMPLETION_ACTIVATION_", type_id = "gtk_source_completion_activation_get_type ()")] +- [Flags] +- [GIR (name = "CompletionActivation")] +- public enum SourceCompletionActivation { +- NONE, +- INTERACTIVE, +- USER_REQUESTED +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_COMPRESSION_TYPE_", type_id = "gtk_source_compression_type_get_type ()")] +- [GIR (name = "CompressionType")] +- public enum SourceCompressionType { +- NONE, +- GZIP +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_DRAW_SPACES_", type_id = "gtk_source_draw_spaces_flags_get_type ()")] +- [Flags] +- [GIR (name = "DrawSpacesFlags")] +- public enum SourceDrawSpacesFlags { +- SPACE, +- TAB, +- NEWLINE, +- NBSP, +- LEADING, +- TEXT, +- TRAILING, +- ALL +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_FILE_SAVER_FLAGS_", type_id = "gtk_source_file_saver_flags_get_type ()")] +- [Flags] +- [GIR (name = "FileSaverFlags")] +- public enum SourceFileSaverFlags { +- NONE, +- IGNORE_INVALID_CHARS, +- IGNORE_MODIFICATION_TIME, +- CREATE_BACKUP +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_", type_id = "gtk_source_gutter_renderer_alignment_mode_get_type ()")] +- [GIR (name = "GutterRendererAlignmentMode")] +- public enum SourceGutterRendererAlignmentMode { +- CELL, +- FIRST, +- LAST +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_GUTTER_RENDERER_STATE_", type_id = "gtk_source_gutter_renderer_state_get_type ()")] +- [Flags] +- [GIR (name = "GutterRendererState")] +- public enum SourceGutterRendererState { +- NORMAL, +- CURSOR, +- PRELIT, +- SELECTED +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_NEWLINE_TYPE_", type_id = "gtk_source_newline_type_get_type ()")] +- [GIR (name = "NewlineType")] +- public enum SourceNewlineType { +- LF, +- CR, +- CR_LF +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_SMART_HOME_END_", type_id = "gtk_source_smart_home_end_type_get_type ()")] +- [GIR (name = "SmartHomeEndType")] +- public enum SourceSmartHomeEndType { +- DISABLED, +- BEFORE, +- AFTER, +- ALWAYS +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_SORT_FLAGS_", type_id = "gtk_source_sort_flags_get_type ()")] +- [Flags] +- [GIR (name = "SortFlags")] +- public enum SourceSortFlags { +- NONE, +- CASE_SENSITIVE, +- REVERSE_ORDER, +- REMOVE_DUPLICATES +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_VIEW_GUTTER_POSITION_", type_id = "gtk_source_view_gutter_position_get_type ()")] +- [GIR (name = "ViewGutterPosition")] +- public enum SourceViewGutterPosition { +- LINES, +- MARKS +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_COMPLETION_ERROR_")] +- [GIR (name = "CompletionError")] +- public errordomain SourceCompletionError { +- ALREADY_BOUND, +- NOT_BOUND; +- [CCode (cname = "gtk_source_completion_error_quark")] +- public static GLib.Quark uark (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_FILE_LOADER_ERROR_")] +- [GIR (name = "FileLoaderError")] +- public errordomain SourceFileLoaderError { +- TOO_BIG, +- ENCODING_AUTO_DETECTION_FAILED, +- CONVERSION_FALLBACK; +- [CCode (cname = "gtk_source_file_loader_error_quark")] +- public static GLib.Quark uark (); +- } +- [CCode (cheader_filename = "gtksourceview/gtksource.h", cprefix = "GTK_SOURCE_FILE_SAVER_ERROR_")] +- [GIR (name = "FileSaverError")] +- public errordomain SourceFileSaverError { +- INVALID_CHARS, +- EXTERNALLY_MODIFIED; +- [CCode (cname = "gtk_source_file_saver_error_quark")] +- public static GLib.Quark uark (); +- } +-} +diff --git a/vapi/libsoup-2.4.deps b/vapi/libsoup-2.4.deps +deleted file mode 100644 +index cd10dfde..00000000 +--- vapi/libsoup-2.4.deps ++++ /dev/null +@@ -1 +0,0 @@ +-gio-2.0 +diff --git a/vapi/libsoup-2.4.vapi b/vapi/libsoup-2.4.vapi +deleted file mode 100644 +index bcbe7d00..00000000 +--- vapi/libsoup-2.4.vapi ++++ /dev/null +@@ -1,1396 +0,0 @@ +-/* libsoup-2.4.vapi generated by vapigen, do not modify. */ +- +-[CCode (cprefix = "Soup", gir_namespace = "Soup", gir_version = "2.4", lower_case_cprefix = "soup_")] +-namespace Soup { +- namespace Form { +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable decode (string encoded_form); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable decode_multipart (Soup.Message msg, string file_control_name, out string filename, out string content_type, out Soup.Buffer file); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string encode (...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string encode_datalist (GLib.Datalist form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string encode_hash (GLib.HashTable form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string encode_valist (string first_field, va_list args); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static Soup.Message request_new (string method, string uri, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static Soup.Message request_new_from_datalist (string method, string uri, GLib.Datalist form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static Soup.Message request_new_from_hash (string method, string uri, GLib.HashTable form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static Soup.Message request_new_from_multipart (string uri, Soup.Multipart multipart); +- } +- namespace XMLRPC { +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_XMLRPC_ERROR_")] +- [GIR (name = "XMLRPCError")] +- public errordomain Error { +- ARGUMENTS, +- RETVAL +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_XMLRPC_FAULT_")] +- [GIR (name = "XMLRPCFault")] +- public errordomain Fault { +- PARSE_ERROR_NOT_WELL_FORMED, +- PARSE_ERROR_UNSUPPORTED_ENCODING, +- PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING, +- SERVER_ERROR_INVALID_XML_RPC, +- SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND, +- SERVER_ERROR_INVALID_METHOD_PARAMETERS, +- SERVER_ERROR_INTERNAL_XML_RPC_ERROR, +- APPLICATION_ERROR, +- SYSTEM_ERROR, +- TRANSPORT_ERROR +- } +- [CCode (cheader_filename = "libsoup/soup.h")] +- [PrintfFormat] +- public static string build_fault (int fault_code, string fault_format, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string build_method_call (string method_name, [CCode (array_length_cname = "n_params", array_length_pos = 2.1)] GLib.Value[] @params); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string build_method_response (GLib.Value value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.Quark error_quark (); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- public static bool extract_method_call (string method_call, int length, out string method_name, ...); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- public static bool extract_method_response (string method_response, int length, ...) throws Soup.XMLRPC.Fault; +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.Quark fault_quark (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool parse_method_call (string method_call, int length, out string method_name, out GLib.ValueArray @params); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool parse_method_response (string method_response, int length, out GLib.Value value) throws Soup.XMLRPC.Fault; +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- public static Soup.Message request_new (string uri, string method_name, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [PrintfFormat] +- public static void set_fault (Soup.Message msg, int fault_code, string fault_format, ...); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- public static void set_response (Soup.Message msg, ...); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_address_get_type ()")] +- public class Address : GLib.Object, GLib.SocketConnectable { +- [CCode (has_construct_function = false)] +- public Address (string name, uint port); +- [CCode (has_construct_function = false)] +- public Address.any (Soup.AddressFamily family, uint port); +- public bool equal_by_ip ([CCode (type = "gconstpointer")] Soup.Address addr2); +- public bool equal_by_name ([CCode (type = "gconstpointer")] Soup.Address addr2); +- [CCode (has_construct_function = false)] +- public Address.from_sockaddr (void* sa, int len); +- public GLib.SocketAddress get_gsockaddr (); +- public unowned string get_name (); +- public unowned string get_physical (); +- public uint get_port (); +- public void* get_sockaddr (int len); +- public uint hash_by_ip (); +- public uint hash_by_name (); +- public bool is_resolved (); +- public void resolve_async (GLib.MainContext? async_context, GLib.Cancellable? cancellable, Soup.AddressCallback callback); +- public uint resolve_sync (GLib.Cancellable? cancellable); +- [NoAccessorMethod] +- public Soup.AddressFamily family { get; construct; } +- public string name { get; construct; } +- public string physical { get; } +- public int port { get; construct; } +- [NoAccessorMethod] +- public void* sockaddr { get; construct; } +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_get_type ()")] +- public abstract class Auth : GLib.Object { +- [CCode (has_construct_function = false)] +- public Auth (GLib.Type type, Soup.Message msg, string auth_header); +- public virtual void authenticate (string username, string password); +- public virtual string get_authorization (Soup.Message msg); +- public unowned string get_host (); +- public string get_info (); +- public virtual GLib.SList get_protection_space (Soup.URI source_uri); +- public unowned string get_realm (); +- public unowned string get_scheme_name (); +- public virtual bool update (Soup.Message msg, GLib.HashTable auth_params); +- public string host { get; construct; } +- [NoAccessorMethod] +- public virtual bool is_authenticated { get; } +- [NoAccessorMethod] +- public bool is_for_proxy { get; construct; } +- public string realm { get; construct; } +- public string scheme_name { get; } +- public signal void save_password (string username, string password); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_basic_get_type ()")] +- public class AuthBasic : Soup.Auth { +- [CCode (has_construct_function = false)] +- protected AuthBasic (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_digest_get_type ()")] +- public class AuthDigest : Soup.Auth { +- [CCode (has_construct_function = false)] +- protected AuthDigest (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_get_type ()")] +- public abstract class AuthDomain : GLib.Object { +- [CCode (has_construct_function = false)] +- protected AuthDomain (); +- [NoWrapper] +- public virtual string accepts (Soup.Message msg, string header); +- public void add_path (string path); +- [CCode (vfunc_name = "challenge")] +- public virtual string challenge (Soup.Message msg); +- public virtual bool check_password (Soup.Message msg, string username, string password); +- public bool covers (Soup.Message msg); +- public unowned string get_realm (); +- public void remove_path (string path); +- public void set_filter (owned Soup.AuthDomainFilter filter); +- public void set_generic_auth_callback (owned Soup.AuthDomainGenericAuthCallback auth_callback); +- public bool try_generic_auth_callback (Soup.Message msg, string username); +- [NoAccessorMethod] +- public void* filter { get; set; } +- [NoAccessorMethod] +- public void* filter_data { get; set; } +- [NoAccessorMethod] +- public void* generic_auth_callback { get; set; } +- [NoAccessorMethod] +- public void* generic_auth_data { get; set; } +- [NoAccessorMethod] +- public bool proxy { get; construct; } +- public string realm { get; construct; } +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_basic_get_type ()")] +- public class AuthDomainBasic : Soup.AuthDomain { +- [CCode (has_construct_function = false, type = "SoupAuthDomain*")] +- public AuthDomainBasic (string optname1, ...); +- public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainBasicAuthCallback callback); +- [NoAccessorMethod] +- public void* auth_callback { get; set; } +- [NoAccessorMethod] +- public void* auth_data { get; set; } +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_domain_digest_get_type ()")] +- public class AuthDomainDigest : Soup.AuthDomain { +- [CCode (has_construct_function = false, type = "SoupAuthDomain*")] +- public AuthDomainDigest (string optname1, ...); +- public static string encode_password (string username, string realm, string password); +- public static void set_auth_callback (Soup.AuthDomain domain, owned Soup.AuthDomainDigestAuthCallback callback); +- [NoAccessorMethod] +- public void* auth_callback { get; set; } +- [NoAccessorMethod] +- public void* auth_data { get; set; } +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_auth_ntlm_get_type ()")] +- public class AuthNTLM : Soup.Auth { +- [CCode (has_construct_function = false)] +- protected AuthNTLM (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_buffer_get_type ()")] +- [Compact] +- public class Buffer { +- [CCode (array_length_cname = "length", array_length_type = "gsize")] +- public uint8[] data; +- public size_t length; +- [CCode (has_construct_function = false)] +- public Buffer (Soup.MemoryUse use, [CCode (array_length_cname = "length", array_length_pos = 2.1, array_length_type = "gsize", type = "gconstpointer")] uint8[] data); +- public Soup.Buffer copy (); +- public void free (); +- public void get_data ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] out unowned uint8[] data); +- public void* get_owner (); +- [CCode (has_construct_function = false)] +- public Buffer.subbuffer (Soup.Buffer parent, size_t offset, size_t length); +- [CCode (has_construct_function = false)] +- public Buffer.take ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] owned uint8[] data); +- [CCode (has_construct_function = false)] +- public Buffer.with_owner ([CCode (array_length_cname = "length", array_length_pos = 1.5, array_length_type = "gsize", type = "gconstpointer")] uint8[] data, void* owner, GLib.DestroyNotify? owner_dnotify); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_byte_array_get_type ()")] +- [Compact] +- public class ByteArray { +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_client_context_get_type ()")] +- [Compact] +- public class ClientContext { +- public unowned Soup.Address get_address (); +- public unowned Soup.AuthDomain get_auth_domain (); +- public unowned string get_auth_user (); +- public unowned string get_host (); +- public unowned Soup.Socket get_socket (); +- } +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Compact] +- public class Connection { +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_content_decoder_get_type ()")] +- public class ContentDecoder : GLib.Object, Soup.SessionFeature { +- [CCode (has_construct_function = false)] +- protected ContentDecoder (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_content_sniffer_get_type ()")] +- public class ContentSniffer : GLib.Object, Soup.SessionFeature { +- [CCode (has_construct_function = false)] +- public ContentSniffer (); +- [NoWrapper] +- public virtual size_t get_buffer_size (); +- public virtual string sniff (Soup.Message msg, Soup.Buffer buffer, out GLib.HashTable? @params); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_cookie_get_type ()")] +- [Compact] +- public class Cookie { +- public weak string domain; +- public weak Soup.Date expires; +- public bool http_only; +- public weak string name; +- public weak string path; +- public bool secure; +- public weak string value; +- [CCode (has_construct_function = false)] +- public Cookie (string name, string value, string domain, string path, int max_age); +- public bool applies_to_uri (Soup.URI uri); +- public Soup.Cookie copy (); +- public bool domain_matches (string host); +- public bool equal (Soup.Cookie cookie2); +- public void free (); +- public unowned string get_domain (); +- public unowned Soup.Date get_expires (); +- public bool get_http_only (); +- public unowned string get_name (); +- public unowned string get_path (); +- public bool get_secure (); +- public unowned string get_value (); +- public static Soup.Cookie parse (string header, Soup.URI origin); +- public void set_domain (string domain); +- public void set_expires (Soup.Date expires); +- public void set_http_only (bool http_only); +- public void set_max_age (int max_age); +- public void set_name (string name); +- public void set_path (string path); +- public void set_secure (bool secure); +- public void set_value (string value); +- public string to_cookie_header (); +- public string to_set_cookie_header (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_cookie_jar_get_type ()")] +- public class CookieJar : GLib.Object, Soup.SessionFeature { +- [CCode (has_construct_function = false)] +- public CookieJar (); +- public void add_cookie (Soup.Cookie cookie); +- public GLib.SList all_cookies (); +- public void delete_cookie (Soup.Cookie cookie); +- public Soup.CookieJarAcceptPolicy get_accept_policy (); +- public string get_cookies (Soup.URI uri, bool for_http); +- public virtual void save (); +- public void set_accept_policy (Soup.CookieJarAcceptPolicy policy); +- public void set_cookie (Soup.URI uri, string cookie); +- public void set_cookie_with_first_party (Soup.URI uri, Soup.URI first_party, string cookie); +- public Soup.CookieJarAcceptPolicy accept_policy { get; set; } +- [NoAccessorMethod] +- public bool read_only { get; construct; } +- public virtual signal void changed (Soup.Cookie old_cookie, Soup.Cookie new_cookie); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_cookie_jar_text_get_type ()")] +- public class CookieJarText : Soup.CookieJar, Soup.SessionFeature { +- [CCode (has_construct_function = false, type = "SoupCookieJar*")] +- public CookieJarText (string filename, bool read_only); +- [NoAccessorMethod] +- public string filename { owned get; construct; } +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_date_get_type ()")] +- [Compact] +- public class Date { +- public int day; +- public int hour; +- public int minute; +- public int month; +- public int offset; +- public int second; +- public bool utc; +- public int year; +- [CCode (has_construct_function = false)] +- public Date (int year, int month, int day, int hour, int minute, int second); +- public Soup.Date copy (); +- public void free (); +- [CCode (has_construct_function = false)] +- public Date.from_now (int offset_seconds); +- [CCode (has_construct_function = false)] +- public Date.from_string (string date_string); +- [CCode (has_construct_function = false)] +- public Date.from_time_t ([CCode (type = "time_t")] time_t when); +- public int get_day (); +- public int get_hour (); +- public int get_minute (); +- public int get_month (); +- public int get_offset (); +- public int get_second (); +- public int get_utc (); +- public int get_year (); +- public bool is_past (); +- public string to_string (Soup.DateFormat format); +- public time_t to_time_t (); +- public GLib.TimeVal to_timeval (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_logger_get_type ()")] +- public class Logger : GLib.Object, Soup.SessionFeature { +- [CCode (has_construct_function = false)] +- public Logger (Soup.LoggerLogLevel level, int max_body_size); +- public void set_printer (owned Soup.LoggerPrinter printer); +- public void set_request_filter (owned Soup.LoggerFilter request_filter); +- public void set_response_filter (owned Soup.LoggerFilter response_filter); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_message_get_type ()")] +- public class Message : GLib.Object { +- public weak Soup.MessageBody request_body; +- public weak Soup.MessageHeaders request_headers; +- public weak Soup.MessageBody response_body; +- public weak Soup.MessageHeaders response_headers; +- [CCode (has_construct_function = false)] +- public Message (string method, string uri_string); +- public uint add_header_handler (string @signal, string header, GLib.Callback callback); +- public uint add_status_code_handler (string @signal, uint status_code, GLib.Callback callback); +- public void disable_feature (GLib.Type feature_type); +- [CCode (has_construct_function = false)] +- public Message.from_uri (string method, Soup.URI uri); +- public unowned Soup.Address get_address (); +- public unowned Soup.URI get_first_party (); +- public Soup.MessageFlags get_flags (); +- public Soup.HTTPVersion get_http_version (); +- public bool get_https_status (out unowned GLib.TlsCertificate certificate, out GLib.TlsCertificateFlags errors); +- public unowned Soup.URI get_uri (); +- public bool is_keepalive (); +- public void set_chunk_allocator (owned Soup.ChunkAllocator allocator); +- public void set_first_party (Soup.URI first_party); +- public void set_flags (Soup.MessageFlags flags); +- public void set_http_version (Soup.HTTPVersion version); +- public void set_redirect (uint status_code, string redirect_uri); +- public void set_request (string content_type, Soup.MemoryUse req_use, [CCode (array_length_cname = "req_length", array_length_pos = 3.1, array_length_type = "gsize", type = "char*")] uint8[] req_body); +- public void set_response (string? content_type, Soup.MemoryUse resp_use, [CCode (array_length_cname = "resp_length", array_length_pos = 3.1, array_length_type = "gsize")] uint8[] resp_body); +- public void set_status (uint status_code); +- public void set_status_full (uint status_code, string reason_phrase); +- public void set_uri (Soup.URI uri); +- public Soup.URI first_party { get; set; } +- public Soup.MessageFlags flags { get; set; } +- public Soup.HTTPVersion http_version { get; set; } +- [NoAccessorMethod] +- public string method { owned get; set; } +- [NoAccessorMethod] +- public string reason_phrase { owned get; set; } +- [NoAccessorMethod] +- public bool server_side { get; construct; } +- [NoAccessorMethod] +- public uint status_code { get; set; } +- [NoAccessorMethod] +- public GLib.TlsCertificate tls_certificate { owned get; set; } +- [NoAccessorMethod] +- public GLib.TlsCertificateFlags tls_errors { get; set; } +- public Soup.URI uri { get; set; } +- [HasEmitter] +- public signal void content_sniffed (string content_type, GLib.HashTable @params); +- [HasEmitter] +- public virtual signal void finished (); +- [HasEmitter] +- public virtual signal void got_body (); +- [HasEmitter] +- public virtual signal void got_chunk (Soup.Buffer chunk); +- [HasEmitter] +- public virtual signal void got_headers (); +- [HasEmitter] +- public virtual signal void got_informational (); +- public signal void network_event (GLib.SocketClientEvent event, GLib.IOStream connection); +- [HasEmitter] +- public virtual signal void restarted (); +- [HasEmitter] +- public virtual signal void wrote_body (); +- [HasEmitter] +- public signal void wrote_body_data (Soup.Buffer chunk); +- [HasEmitter] +- public virtual signal void wrote_chunk (); +- [HasEmitter] +- public virtual signal void wrote_headers (); +- [HasEmitter] +- public virtual signal void wrote_informational (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_message_body_get_type ()")] +- [Compact] +- public class MessageBody { +- [CCode (array_length_cname = "length", array_length_type = "gint64")] +- public uint8[] data; +- public int64 length; +- [CCode (has_construct_function = false)] +- public MessageBody (); +- public void append (Soup.MemoryUse use, [CCode (array_length_cname = "length", array_length_pos = 2.1, array_length_type = "gsize")] uint8[] data); +- public void append_buffer (Soup.Buffer buffer); +- public void append_take ([CCode (array_length_cname = "length", array_length_pos = 1.1, array_length_type = "gsize")] owned uint8[] data); +- public void complete (); +- public Soup.Buffer flatten (); +- public void free (); +- public bool get_accumulate (); +- public Soup.Buffer get_chunk (int64 offset); +- public void got_chunk (Soup.Buffer chunk); +- public void set_accumulate (bool accumulate); +- public void truncate (); +- public void wrote_chunk (Soup.Buffer chunk); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_message_headers_get_type ()")] +- [Compact] +- public class MessageHeaders { +- [CCode (has_construct_function = false)] +- public MessageHeaders (Soup.MessageHeadersType type); +- public void append (string name, string value); +- public void clean_connection_headers (); +- public void clear (); +- public void @foreach (Soup.MessageHeadersForeachFunc func); +- public void free (); +- public void free_ranges (Soup.Range ranges); +- public unowned string @get (string name); +- public bool get_content_disposition (out string disposition, out GLib.HashTable @params); +- public int64 get_content_length (); +- public bool get_content_range (int64 start, int64 end, int64 total_length); +- public unowned string get_content_type (out GLib.HashTable @params); +- public Soup.Encoding get_encoding (); +- public Soup.Expectation get_expectations (); +- public unowned string get_list (string name); +- public unowned string get_one (string name); +- public bool get_ranges (int64 total_length, [CCode (array_length_cname = "length", array_length_pos = 2.1, type = "SoupRange**")] out Soup.Range[] ranges); +- public void remove (string name); +- public void replace (string name, string value); +- public void set_content_disposition (string disposition, GLib.HashTable? @params); +- public void set_content_length (int64 content_length); +- public void set_content_range (int64 start, int64 end, int64 total_length); +- public void set_content_type (string content_type, GLib.HashTable? @params); +- public void set_encoding (Soup.Encoding encoding); +- public void set_expectations (Soup.Expectation expectations); +- public void set_range (int64 start, int64 end); +- public void set_ranges (Soup.Range ranges, int length); +- } +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Compact] +- public class MessageQueue { +- } +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Compact] +- public class MessageQueueItem { +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_multipart_get_type ()")] +- [Compact] +- public class Multipart { +- [CCode (has_construct_function = false)] +- public Multipart (string mime_type); +- public void append_form_file (string control_name, string filename, string content_type, Soup.Buffer body); +- public void append_form_string (string control_name, string data); +- public void append_part (Soup.MessageHeaders headers, Soup.Buffer body); +- public void free (); +- [CCode (has_construct_function = false)] +- public Multipart.from_message (Soup.MessageHeaders headers, Soup.MessageBody body); +- public int get_length (); +- public bool get_part (int part, out unowned Soup.MessageHeaders headers, out unowned Soup.Buffer body); +- public void to_message (Soup.MessageHeaders dest_headers, Soup.MessageBody dest_body); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_proxy_resolver_default_get_type ()")] +- public class ProxyResolverDefault : GLib.Object, Soup.ProxyURIResolver, Soup.SessionFeature { +- [CCode (has_construct_function = false)] +- protected ProxyResolverDefault (); +- [NoAccessorMethod] +- public GLib.ProxyResolver gproxy_resolver { set; } +- } +- [CCode (cheader_filename = "libsoup/soup-request.h", type_id = "soup_request_get_type ()")] +- public class Request : GLib.Object { +- public class string[] schemes; +- +- [CCode (has_construct_function = false)] +- protected Request (); +- +- public virtual bool check_uri(Soup.URI uri) throws GLib.Error; +- public virtual GLib.InputStream? send(GLib.Cancellable? cancellable) throws GLib.Error; +- public virtual void send_async(GLib.Cancellable? cancellable, GLib.AsyncReadyCallback callback) throws GLib.Error; +- public virtual GLib.InputStream? send_finish(GLib.AsyncResult result) throws GLib.Error; +- public virtual int64 get_content_length(); +- public virtual unowned string? get_content_type(); +- +- public Soup.Session session { get; } +- public Soup.URI uri { get; } +- } +- [CCode (cheader_filename = "libsoup/soup-requester.h", type_id = "soup_requester_get_type ()")] +- public class Requester : GLib.Object, Soup.SessionFeature { +- public Requester(); +- +- public Soup.Request request(string uri_string) throws GLib.Error; +- public Soup.Request request_uri(Soup.URI uri) throws GLib.Error; +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_server_get_type ()")] +- public class Server : GLib.Object { +- [CCode (has_construct_function = false)] +- public Server (string optname1, ...); +- public void add_auth_domain (Soup.AuthDomain auth_domain); +- public void add_handler (string? path, owned Soup.ServerCallback callback); +- public void disconnect (); +- public unowned GLib.MainContext get_async_context (); +- public unowned Soup.Socket get_listener (); +- public uint get_port (); +- public bool is_https (); +- public void pause_message (Soup.Message msg); +- public void quit (); +- public void remove_auth_domain (Soup.AuthDomain auth_domain); +- public void remove_handler (string path); +- public void run (); +- public void run_async (); +- public void unpause_message (Soup.Message msg); +- public GLib.MainContext async_context { get; owned construct; } +- [NoAccessorMethod] +- public Soup.Address @interface { owned get; construct; } +- public uint port { get; construct; } +- [NoAccessorMethod] +- public bool raw_paths { get; construct; } +- [NoAccessorMethod] +- public string server_header { owned get; set construct; } +- [NoAccessorMethod] +- public string ssl_cert_file { owned get; construct; } +- [NoAccessorMethod] +- public string ssl_key_file { owned get; construct; } +- [NoAccessorMethod] +- public GLib.TlsCertificate tls_certificate { owned get; construct; } +- public virtual signal void request_aborted (Soup.Message msg, Soup.ClientContext client); +- public virtual signal void request_finished (Soup.Message msg, Soup.ClientContext client); +- public virtual signal void request_read (Soup.Message msg, Soup.ClientContext client); +- public virtual signal void request_started (Soup.Message msg, Soup.ClientContext client); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_get_type ()")] +- public abstract class Session : GLib.Object { +- [CCode (has_construct_function = false)] +- protected Session (); +- public void abort (); +- public void add_feature (Soup.SessionFeature feature); +- public void add_feature_by_type (GLib.Type feature_type); +- [NoWrapper] +- public virtual void auth_required (Soup.Message msg, Soup.Auth auth, bool retrying); +- public virtual void cancel_message (Soup.Message msg, uint status_code); +- [NoWrapper] +- public virtual void flush_queue (); +- public unowned GLib.MainContext get_async_context (); +- public unowned Soup.SessionFeature get_feature (GLib.Type feature_type); +- public unowned Soup.SessionFeature get_feature_for_message (GLib.Type feature_type, Soup.Message msg); +- public GLib.SList get_features (GLib.Type feature_type); +- [NoWrapper] +- public virtual void kick (); +- public void pause_message (Soup.Message msg); +- public void prepare_for_uri (Soup.URI uri); +- public virtual void queue_message (owned Soup.Message msg, Soup.SessionCallback? callback); +- public bool redirect_message (Soup.Message msg); +- public void remove_feature (Soup.SessionFeature feature); +- public void remove_feature_by_type (GLib.Type feature_type); +- public virtual void requeue_message (Soup.Message msg); +- public virtual uint send_message (Soup.Message msg); +- public void unpause_message (Soup.Message msg); +- public bool would_redirect (Soup.Message msg); +- [NoAccessorMethod] +- public string accept_language { owned get; set; } +- [NoAccessorMethod] +- public bool accept_language_auto { get; set; } +- public GLib.MainContext async_context { get; owned construct; } +- [CCode (array_length = false, array_null_terminated = true)] +- [NoAccessorMethod] +- public string[] http_aliases { owned get; set; } +- [CCode (array_length = false, array_null_terminated = true)] +- [NoAccessorMethod] +- public string[] https_aliases { owned get; set; } +- [NoAccessorMethod] +- public uint idle_timeout { get; set; } +- [NoAccessorMethod] +- public int max_conns { get; set; } +- [NoAccessorMethod] +- public int max_conns_per_host { get; set; } +- [NoAccessorMethod] +- public Soup.URI proxy_uri { owned get; set; } +- [NoAccessorMethod] +- public string ssl_ca_file { owned get; set; } +- [NoAccessorMethod] +- public bool ssl_strict { get; set; } +- [NoAccessorMethod] +- public bool ssl_use_system_ca_file { get; set; } +- [NoAccessorMethod] +- public uint timeout { get; set; } +- [NoAccessorMethod] +- public GLib.TlsDatabase tls_database { owned get; set; } +- [NoAccessorMethod] +- public bool use_ntlm { get; set; } +- [NoAccessorMethod] +- public bool use_thread_context { get; set; } +- [NoAccessorMethod] +- public string user_agent { owned get; set; } +- public virtual signal void authenticate (Soup.Message msg, Soup.Auth auth, bool retrying); +- public signal void connection_created (GLib.Object connection); +- public signal void request_queued (Soup.Message msg); +- public virtual signal void request_started (Soup.Message msg, Soup.Socket socket); +- public signal void request_unqueued (Soup.Message msg); +- public signal void tunneling (GLib.Object connection); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_async_get_type ()")] +- public class SessionAsync : Soup.Session { +- [CCode (has_construct_function = false, type = "SoupSession*")] +- public SessionAsync (); +- [CCode (has_construct_function = false, type = "SoupSession*")] +- public SessionAsync.with_options (string optname1, ...); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_session_sync_get_type ()")] +- public class SessionSync : Soup.Session { +- [CCode (has_construct_function = false, type = "SoupSession*")] +- public SessionSync (); +- [CCode (has_construct_function = false, type = "SoupSession*")] +- public SessionSync.with_options (string optname1, ...); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_id = "soup_socket_get_type ()")] +- public class Socket : GLib.Object { +- [CCode (has_construct_function = false)] +- public Socket (string optname1, ...); +- public void connect_async (GLib.Cancellable? cancellable, Soup.SocketCallback callback); +- public uint connect_sync (GLib.Cancellable? cancellable); +- public void disconnect (); +- public int get_fd (); +- public unowned Soup.Address get_local_address (); +- public unowned Soup.Address get_remote_address (); +- public bool is_connected (); +- public bool is_ssl (); +- public bool listen (); +- public Soup.SocketIOStatus read ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gpointer")] uint8[] buffer, out size_t nread, GLib.Cancellable? cancellable) throws GLib.Error; +- public Soup.SocketIOStatus read_until ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gpointer")] uint8[] buffer, void* boundary, size_t boundary_len, out size_t nread, bool got_boundary, GLib.Cancellable? cancellable) throws GLib.Error; +- public bool start_proxy_ssl (string ssl_host, GLib.Cancellable? cancellable); +- public bool start_ssl (GLib.Cancellable? cancellable); +- public Soup.SocketIOStatus write ([CCode (array_length_cname = "len", array_length_pos = 1.5, array_length_type = "gsize", type = "gconstpointer")] uint8[] buffer, out size_t nwrote, GLib.Cancellable? cancellable) throws GLib.Error; +- [NoAccessorMethod] +- public GLib.MainContext async_context { owned get; construct; } +- public bool clean_dispose { construct; } +- [NoAccessorMethod] +- public bool is_server { get; } +- public Soup.Address local_address { get; construct; } +- [NoAccessorMethod] +- public bool non_blocking { get; set; } +- public Soup.Address remote_address { get; construct; } +- [NoAccessorMethod] +- public void* ssl_creds { get; set; } +- [NoAccessorMethod] +- public bool ssl_fallback { get; construct; } +- [NoAccessorMethod] +- public bool ssl_strict { get; construct; } +- [NoAccessorMethod] +- public uint timeout { get; set; } +- [NoAccessorMethod] +- public GLib.TlsCertificate tls_certificate { owned get; } +- [NoAccessorMethod] +- public GLib.TlsCertificateFlags tls_errors { get; } +- [NoAccessorMethod] +- public bool trusted_certificate { get; } +- [NoAccessorMethod] +- public bool use_thread_context { get; construct; } +- public virtual signal void disconnected (); +- public signal void event (GLib.SocketClientEvent event, GLib.IOStream connection); +- public virtual signal void new_connection (Soup.Socket arg1); +- public virtual signal void readable (); +- public virtual signal void writable (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", type_id = "soup_uri_get_type ()")] +- [Compact] +- public class URI { +- public weak string fragment; +- public weak string host; +- public weak string password; +- public weak string path; +- public uint port; +- public weak string query; +- public weak string scheme; +- public weak string user; +- [CCode (has_construct_function = false)] +- public URI (string uri_string); +- public Soup.URI copy (); +- public Soup.URI copy_host (); +- public static string decode (string part); +- public static string encode (string part, string? escape_extra); +- public bool equal (Soup.URI uri2); +- public void free (); +- public unowned string get_fragment (); +- public unowned string get_host (); +- public unowned string get_password (); +- public unowned string get_path (); +- public uint get_port (); +- public unowned string get_query (); +- public unowned string get_scheme (); +- public unowned string get_user (); +- public bool host_equal (Soup.URI v2); +- public uint host_hash (); +- public static string normalize (string part, string unescape_extra); +- public void set_fragment (string? fragment); +- public void set_host (string? host); +- public void set_password (string? password); +- public void set_path (string path); +- public void set_port (uint port); +- public void set_query (string? query); +- public void set_query_from_fields (...); +- public void set_query_from_form (GLib.HashTable form); +- public void set_scheme (string scheme); +- public void set_user (string? user); +- public string to_string (bool just_path_and_query); +- public bool uses_default_port (); +- [CCode (has_construct_function = false)] +- public URI.with_base (Soup.URI @base, string uri_string); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupProxyResolverInterface", type_id = "soup_proxy_resolver_get_type ()")] +- [Version ( deprecated = true, replacement = "Soup.ProxyURIResolver" )] +- public interface ProxyResolver : Soup.SessionFeature, GLib.Object { +- public abstract void get_proxy_async (Soup.Message msg, GLib.MainContext async_context, GLib.Cancellable? cancellable, Soup.ProxyResolverCallback callaback); +- public abstract uint get_proxy_sync (Soup.Message msg, GLib.Cancellable? cancellable, out unowned Soup.Address addr); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupProxyURIResolverInterface", type_id = "soup_proxy_uri_resolver_get_type ()")] +- public interface ProxyURIResolver : GLib.Object { +- public abstract void get_proxy_uri_async (Soup.URI uri, GLib.MainContext? async_context, GLib.Cancellable? cancellable, Soup.ProxyURIResolverCallback callback); +- public abstract uint get_proxy_uri_sync (Soup.URI uri, GLib.Cancellable? cancellable, out Soup.URI proxy_uri); +- } +- [CCode (cheader_filename = "libsoup/soup.h", type_cname = "SoupSessionFeatureInterface", type_id = "soup_session_feature_get_type ()")] +- public interface SessionFeature : GLib.Object { +- public abstract bool add_feature (GLib.Type type); +- public abstract void attach (Soup.Session session); +- public abstract void detach (Soup.Session session); +- public abstract bool has_feature (GLib.Type type); +- public abstract bool remove_feature (GLib.Type type); +- [NoWrapper] +- public abstract void request_queued (Soup.Session session, Soup.Message msg); +- [NoWrapper] +- public abstract void request_started (Soup.Session session, Soup.Message msg, Soup.Socket socket); +- [NoWrapper] +- public abstract void request_unqueued (Soup.Session session, Soup.Message msg); +- } +- [CCode (cheader_filename = "libsoup/soup.h", has_type_id = false)] +- public struct MessageHeadersIter { +- public void init (Soup.MessageHeaders hdrs); +- public bool next (out unowned string name, out unowned string value); +- } +- [CCode (cheader_filename = "libsoup/soup.h", has_type_id = false)] +- public struct Range { +- public int64 start; +- public int64 end; +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_ADDRESS_FAMILY_")] +- public enum AddressFamily { +- INVALID, +- IPV4, +- IPV6 +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_CACHE_RESPONSE_")] +- public enum CacheResponse { +- FRESH, +- NEEDS_VALIDATION, +- STALE +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_CACHE_")] +- public enum CacheType { +- SINGLE_USER, +- SHARED +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_CACHE_")] +- [Flags] +- public enum Cacheability { +- CACHEABLE, +- UNCACHEABLE, +- INVALIDATES, +- VALIDATES +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_CONNECTION_")] +- public enum ConnectionState { +- NEW, +- CONNECTING, +- IDLE, +- IN_USE, +- REMOTE_DISCONNECTED, +- DISCONNECTED +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_COOKIE_JAR_ACCEPT_")] +- public enum CookieJarAcceptPolicy { +- ALWAYS, +- NEVER, +- NO_THIRD_PARTY +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_DATE_")] +- public enum DateFormat { +- HTTP, +- COOKIE, +- RFC2822, +- ISO8601_COMPACT, +- ISO8601_FULL, +- ISO8601, +- ISO8601_XMLRPC +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_ENCODING_")] +- public enum Encoding { +- UNRECOGNIZED, +- NONE, +- CONTENT_LENGTH, +- EOF, +- CHUNKED, +- BYTERANGES +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_EXPECTATION_")] +- [Flags] +- public enum Expectation { +- UNRECOGNIZED, +- CONTINUE +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_HTTP_")] +- public enum HTTPVersion { +- @1_0, +- @1_1 +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_STATUS_")] +- public enum KnownStatusCode { +- NONE, +- CANCELLED, +- CANT_RESOLVE, +- CANT_RESOLVE_PROXY, +- CANT_CONNECT, +- CANT_CONNECT_PROXY, +- SSL_FAILED, +- IO_ERROR, +- MALFORMED, +- TRY_AGAIN, +- TOO_MANY_REDIRECTS, +- TLS_FAILED, +- CONTINUE, +- SWITCHING_PROTOCOLS, +- PROCESSING, +- OK, +- CREATED, +- ACCEPTED, +- NON_AUTHORITATIVE, +- NO_CONTENT, +- RESET_CONTENT, +- PARTIAL_CONTENT, +- MULTI_STATUS, +- MULTIPLE_CHOICES, +- MOVED_PERMANENTLY, +- FOUND, +- MOVED_TEMPORARILY, +- SEE_OTHER, +- NOT_MODIFIED, +- USE_PROXY, +- NOT_APPEARING_IN_THIS_PROTOCOL, +- TEMPORARY_REDIRECT, +- BAD_REQUEST, +- UNAUTHORIZED, +- PAYMENT_REQUIRED, +- FORBIDDEN, +- NOT_FOUND, +- METHOD_NOT_ALLOWED, +- NOT_ACCEPTABLE, +- PROXY_AUTHENTICATION_REQUIRED, +- PROXY_UNAUTHORIZED, +- REQUEST_TIMEOUT, +- CONFLICT, +- GONE, +- LENGTH_REQUIRED, +- PRECONDITION_FAILED, +- REQUEST_ENTITY_TOO_LARGE, +- REQUEST_URI_TOO_LONG, +- UNSUPPORTED_MEDIA_TYPE, +- REQUESTED_RANGE_NOT_SATISFIABLE, +- INVALID_RANGE, +- EXPECTATION_FAILED, +- UNPROCESSABLE_ENTITY, +- LOCKED, +- FAILED_DEPENDENCY, +- INTERNAL_SERVER_ERROR, +- NOT_IMPLEMENTED, +- BAD_GATEWAY, +- SERVICE_UNAVAILABLE, +- GATEWAY_TIMEOUT, +- HTTP_VERSION_NOT_SUPPORTED, +- INSUFFICIENT_STORAGE, +- NOT_EXTENDED +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_LOGGER_LOG_")] +- public enum LoggerLogLevel { +- NONE, +- MINIMAL, +- HEADERS, +- BODY +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MEMORY_")] +- public enum MemoryUse { +- STATIC, +- TAKE, +- COPY, +- TEMPORARY +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MESSAGE_")] +- [Flags] +- public enum MessageFlags { +- NO_REDIRECT, +- CAN_REBUILD, +- OVERWRITE_CHUNKS, +- CONTENT_DECODED, +- CERTIFICATE_TRUSTED, +- NEW_CONNECTION +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_MESSAGE_HEADERS_")] +- public enum MessageHeadersType { +- REQUEST, +- RESPONSE, +- MULTIPART +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_REQUESTER_ERROR_")] +- public enum RequesterError { +- BAD_URI, +- UNSUPPORTED_URI_SCHEME +- } +- [CCode (cheader_filename = "libsoup/soup.h", cprefix = "SOUP_SOCKET_")] +- public enum SocketIOStatus { +- OK, +- WOULD_BLOCK, +- EOF, +- ERROR +- } +- [CCode (cheader_filename = "libsoup/soup.h")] +- public errordomain SSLError { +- HANDSHAKE_NEEDS_READ, +- HANDSHAKE_NEEDS_WRITE, +- CERTIFICATE, +- HANDSHAKE_FAILED; +- public static GLib.Quark quark (); +- } +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate void AddressCallback (Soup.Address addr, uint status); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 4.9)] +- public delegate bool AuthDomainBasicAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username, string password); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 3.9)] +- public delegate string AuthDomainDigestAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate bool AuthDomainFilter (Soup.AuthDomain domain, Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 3.9)] +- public delegate bool AuthDomainGenericAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate Soup.Buffer ChunkAllocator (Soup.Message msg, size_t max_len); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate Soup.LoggerLogLevel LoggerFilter (Soup.Logger logger, Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 4.9)] +- public delegate void LoggerPrinter (Soup.Logger logger, Soup.LoggerLogLevel level, char direction, string data); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate void MessageHeadersForeachFunc (string name, string value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public delegate void ProxyResolverCallback (Soup.ProxyResolver p1, Soup.Message p2, uint p3, Soup.Address p4); +- [CCode (cheader_filename = "libsoup/soup.h", has_target = false)] +- public delegate void ProxyURIResolverCallback (Soup.ProxyURIResolver resolver, uint status, Soup.URI proxy_uri); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 5.9)] +- public delegate void ServerCallback (Soup.Server server, Soup.Message msg, string path, GLib.HashTable? query, Soup.ClientContext client); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate void SessionCallback (Soup.Session session, Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h", instance_pos = 2.9)] +- public delegate void SocketCallback (Soup.Socket sock, uint status); +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_ANY_PORT")] +- public const int ADDRESS_ANY_PORT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_FAMILY")] +- public const string ADDRESS_FAMILY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_NAME")] +- public const string ADDRESS_NAME; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_PHYSICAL")] +- public const string ADDRESS_PHYSICAL; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_PORT")] +- public const string ADDRESS_PORT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_ADDRESS_SOCKADDR")] +- public const string ADDRESS_SOCKADDR; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_ADD_PATH")] +- public const string AUTH_DOMAIN_ADD_PATH; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK")] +- public const string AUTH_DOMAIN_BASIC_AUTH_CALLBACK; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA")] +- public const string AUTH_DOMAIN_BASIC_AUTH_DATA; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_BASIC_H")] +- public const int AUTH_DOMAIN_BASIC_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK")] +- public const string AUTH_DOMAIN_DIGEST_AUTH_CALLBACK; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA")] +- public const string AUTH_DOMAIN_DIGEST_AUTH_DATA; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_DIGEST_H")] +- public const int AUTH_DOMAIN_DIGEST_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_FILTER")] +- public const string AUTH_DOMAIN_FILTER; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_FILTER_DATA")] +- public const string AUTH_DOMAIN_FILTER_DATA; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_GENERIC_AUTH_CALLBACK")] +- public const string AUTH_DOMAIN_GENERIC_AUTH_CALLBACK; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_GENERIC_AUTH_DATA")] +- public const string AUTH_DOMAIN_GENERIC_AUTH_DATA; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_H")] +- public const int AUTH_DOMAIN_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_PROXY")] +- public const string AUTH_DOMAIN_PROXY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_REALM")] +- public const string AUTH_DOMAIN_REALM; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_DOMAIN_REMOVE_PATH")] +- public const string AUTH_DOMAIN_REMOVE_PATH; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_H")] +- public const int AUTH_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_HOST")] +- public const string AUTH_HOST; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_IS_AUTHENTICATED")] +- public const string AUTH_IS_AUTHENTICATED; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_IS_FOR_PROXY")] +- public const string AUTH_IS_FOR_PROXY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_REALM")] +- public const string AUTH_REALM; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_AUTH_SCHEME_NAME")] +- public const string AUTH_SCHEME_NAME; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CACHE_H")] +- public const int CACHE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CHAR_HTTP_CTL")] +- public const int CHAR_HTTP_CTL; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CHAR_HTTP_SEPARATOR")] +- public const int CHAR_HTTP_SEPARATOR; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CHAR_URI_GEN_DELIMS")] +- public const int CHAR_URI_GEN_DELIMS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CHAR_URI_PERCENT_ENCODED")] +- public const int CHAR_URI_PERCENT_ENCODED; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CHAR_URI_SUB_DELIMS")] +- public const int CHAR_URI_SUB_DELIMS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CONTENT_DECODER_H")] +- public const int CONTENT_DECODER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_CONTENT_SNIFFER_H")] +- public const int CONTENT_SNIFFER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_H")] +- public const int COOKIE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_JAR_ACCEPT_POLICY")] +- public const string COOKIE_JAR_ACCEPT_POLICY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_JAR_H")] +- public const int COOKIE_JAR_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_JAR_READ_ONLY")] +- public const string COOKIE_JAR_READ_ONLY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_JAR_TEXT_FILENAME")] +- public const string COOKIE_JAR_TEXT_FILENAME; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_JAR_TEXT_H")] +- public const int COOKIE_JAR_TEXT_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_MAX_AGE_ONE_DAY")] +- public const int COOKIE_MAX_AGE_ONE_DAY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_MAX_AGE_ONE_HOUR")] +- public const int COOKIE_MAX_AGE_ONE_HOUR; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_MAX_AGE_ONE_WEEK")] +- public const int COOKIE_MAX_AGE_ONE_WEEK; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_COOKIE_MAX_AGE_ONE_YEAR")] +- public const int COOKIE_MAX_AGE_ONE_YEAR; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_DATE_H")] +- public const int DATE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_FORM_H")] +- public const int FORM_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_FORM_MIME_TYPE_MULTIPART")] +- public const string FORM_MIME_TYPE_MULTIPART; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_FORM_MIME_TYPE_URLENCODED")] +- public const string FORM_MIME_TYPE_URLENCODED; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_HEADERS_H")] +- public const int HEADERS_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_LOGGER_H")] +- public const int LOGGER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_BODY_H")] +- public const int MESSAGE_BODY_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_FIRST_PARTY")] +- public const string MESSAGE_FIRST_PARTY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_FLAGS")] +- public const string MESSAGE_FLAGS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_H")] +- public const int MESSAGE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_HEADERS_H")] +- public const int MESSAGE_HEADERS_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_HTTP_VERSION")] +- public const string MESSAGE_HTTP_VERSION; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_METHOD")] +- public const string MESSAGE_METHOD; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_REASON_PHRASE")] +- public const string MESSAGE_REASON_PHRASE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_REQUEST_BODY")] +- public const string MESSAGE_REQUEST_BODY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_REQUEST_HEADERS")] +- public const string MESSAGE_REQUEST_HEADERS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_RESPONSE_BODY")] +- public const string MESSAGE_RESPONSE_BODY; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_RESPONSE_HEADERS")] +- public const string MESSAGE_RESPONSE_HEADERS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_SERVER_SIDE")] +- public const string MESSAGE_SERVER_SIDE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_STATUS_CODE")] +- public const string MESSAGE_STATUS_CODE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_TLS_CERTIFICATE")] +- public const string MESSAGE_TLS_CERTIFICATE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_TLS_ERRORS")] +- public const string MESSAGE_TLS_ERRORS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MESSAGE_URI")] +- public const string MESSAGE_URI; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_METHOD_H")] +- public const int METHOD_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MISC_H")] +- public const int MISC_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_MULTIPART_H")] +- public const int MULTIPART_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_PASSWORD_MANAGER_H")] +- public const int PASSWORD_MANAGER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_PROXY_RESOLVER_DEFAULT_H")] +- public const int PROXY_RESOLVER_DEFAULT_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_PROXY_URI_RESOLVER_H")] +- public const int PROXY_URI_RESOLVER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUESTER_H")] +- public const int REQUESTER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_DATA_H")] +- public const int REQUEST_DATA_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_FILE_H")] +- public const int REQUEST_FILE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_H")] +- public const int REQUEST_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_HTTP_H")] +- public const int REQUEST_HTTP_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_SESSION")] +- public const string REQUEST_SESSION; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_REQUEST_URI")] +- public const string REQUEST_URI; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_ASYNC_CONTEXT")] +- public const string SERVER_ASYNC_CONTEXT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_H")] +- public const int SERVER_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_INTERFACE")] +- public const string SERVER_INTERFACE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_PORT")] +- public const string SERVER_PORT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_RAW_PATHS")] +- public const string SERVER_RAW_PATHS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_SERVER_HEADER")] +- public const string SERVER_SERVER_HEADER; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_SSL_CERT_FILE")] +- public const string SERVER_SSL_CERT_FILE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_SSL_KEY_FILE")] +- public const string SERVER_SSL_KEY_FILE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SERVER_TLS_CERTIFICATE")] +- public const string SERVER_TLS_CERTIFICATE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_ACCEPT_LANGUAGE")] +- public const string SESSION_ACCEPT_LANGUAGE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_ACCEPT_LANGUAGE_AUTO")] +- public const string SESSION_ACCEPT_LANGUAGE_AUTO; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_ASYNC_CONTEXT")] +- public const string SESSION_ASYNC_CONTEXT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_ASYNC_H")] +- public const int SESSION_ASYNC_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_FEATURE_H")] +- public const int SESSION_FEATURE_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_H")] +- public const int SESSION_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_HTTPS_ALIASES")] +- public const string SESSION_HTTPS_ALIASES; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_HTTP_ALIASES")] +- public const string SESSION_HTTP_ALIASES; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_IDLE_TIMEOUT")] +- public const string SESSION_IDLE_TIMEOUT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_MAX_CONNS")] +- public const string SESSION_MAX_CONNS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_MAX_CONNS_PER_HOST")] +- public const string SESSION_MAX_CONNS_PER_HOST; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_PROXY_URI")] +- public const string SESSION_PROXY_URI; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_SSL_CA_FILE")] +- public const string SESSION_SSL_CA_FILE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_SSL_STRICT")] +- public const string SESSION_SSL_STRICT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE")] +- public const string SESSION_SSL_USE_SYSTEM_CA_FILE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_SYNC_H")] +- public const int SESSION_SYNC_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_TIMEOUT")] +- public const string SESSION_TIMEOUT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_TLS_DATABASE")] +- public const string SESSION_TLS_DATABASE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_USER_AGENT")] +- public const string SESSION_USER_AGENT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_USE_NTLM")] +- public const string SESSION_USE_NTLM; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SESSION_USE_THREAD_CONTEXT")] +- public const string SESSION_USE_THREAD_CONTEXT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_ASYNC_CONTEXT")] +- public const string SOCKET_ASYNC_CONTEXT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_FLAG_NONBLOCKING")] +- public const string SOCKET_FLAG_NONBLOCKING; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_H")] +- public const int SOCKET_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_IS_SERVER")] +- public const string SOCKET_IS_SERVER; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_LOCAL_ADDRESS")] +- public const string SOCKET_LOCAL_ADDRESS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_REMOTE_ADDRESS")] +- public const string SOCKET_REMOTE_ADDRESS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_SSL_CREDENTIALS")] +- public const string SOCKET_SSL_CREDENTIALS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_SSL_FALLBACK")] +- public const string SOCKET_SSL_FALLBACK; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_SSL_STRICT")] +- public const string SOCKET_SSL_STRICT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_TIMEOUT")] +- public const string SOCKET_TIMEOUT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_TLS_CERTIFICATE")] +- public const string SOCKET_TLS_CERTIFICATE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_TLS_ERRORS")] +- public const string SOCKET_TLS_ERRORS; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_TRUSTED_CERTIFICATE")] +- public const string SOCKET_TRUSTED_CERTIFICATE; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_SOCKET_USE_THREAD_CONTEXT")] +- public const string SOCKET_USE_THREAD_CONTEXT; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_STATUS_H")] +- public const int STATUS_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_TYPES_H")] +- public const int TYPES_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_URI_H")] +- public const int URI_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_VALUE_UTILS_H")] +- public const int VALUE_UTILS_H; +- [CCode (cheader_filename = "libsoup/soup.h", cname = "SOUP_XMLRPC_H")] +- public const int XMLRPC_H; +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static unowned GLib.TimeoutSource add_completion (GLib.MainContext? async_context, GLib.SourceFunc function); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static unowned GLib.TimeoutSource add_idle (GLib.MainContext? async_context, GLib.SourceFunc function); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static unowned GLib.TimeoutSource add_io_watch (GLib.MainContext? async_context, GLib.IOChannel chan, GLib.IOCondition condition, GLib.IOFunc function); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static unowned GLib.TimeoutSource add_timeout (GLib.MainContext? async_context, uint interval, GLib.SourceFunc function); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.SList cookies_from_request (Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.SList cookies_from_response (Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static string cookies_to_cookie_header (GLib.SList cookies); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void cookies_to_request (GLib.SList cookies, Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void cookies_to_response (GLib.SList cookies, Soup.Message msg); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.decode", deprecated_since = "vala-0.12" )] +- public static GLib.HashTable form_decode (string encoded_form); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.decode_multipart", deprecated_since = "vala-0.12" )] +- public static GLib.HashTable form_decode_multipart (Soup.Message msg, string file_control_name, out string filename, out string content_type, out Soup.Buffer file); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.encode", deprecated_since = "vala-0.12" )] +- public static string form_encode (...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.encode_datalist", deprecated_since = "vala-0.12" )] +- public static string form_encode_datalist (void* form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.encode_hash", deprecated_since = "vala-0.12" )] +- public static string form_encode_hash (GLib.HashTable form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, deprecated_since = "vala-0.12" )] +- public static string form_encode_valist (string first_field, void* args); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.request_new", deprecated_since = "vala-0.12" )] +- public static Soup.Message form_request_new (string method, string uri, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.request_new_from_datalist", deprecated_since = "vala-0.12" )] +- public static Soup.Message form_request_new_from_datalist (string method, string uri, void* form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.request_new_from_hash", deprecated_since = "vala-0.12" )] +- public static Soup.Message form_request_new_from_hash (string method, string uri, GLib.HashTable form_data_set); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "Form.request_new_from_multipart", deprecated_since = "vala-0.12" )] +- public static Soup.Message form_request_new_from_multipart (string uri, Soup.Multipart multipart); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool header_contains (string header, string token); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void header_free_param_list (GLib.HashTable param_list); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void header_g_string_append_param (GLib.StringBuilder string, string name, string value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void header_g_string_append_param_quoted (GLib.StringBuilder string, string name, string value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.SList header_parse_list (string header); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable header_parse_param_list (string header); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.SList header_parse_quality_list (string header, out GLib.SList unacceptable); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable header_parse_semi_param_list (string header); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool headers_parse (string str, int len, Soup.MessageHeaders dest); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static uint headers_parse_request (string str, int len, Soup.MessageHeaders req_headers, out string req_method, out string req_path, out Soup.HTTPVersion ver); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool headers_parse_response (string str, int len, Soup.MessageHeaders headers, out Soup.HTTPVersion ver, out uint status_code, out string reason_phrase); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool headers_parse_status_line (string status_line, out Soup.HTTPVersion ver, out uint status_code, out string reason_phrase); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.Quark http_error_quark (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "SSLError.quark", deprecated_since = "vala-0.14" )] +- public static GLib.Quark ssl_error_quark (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static unowned string status_get_phrase (uint status_code); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static uint status_proxify (uint status_code); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool str_case_equal (void* v1, void* v2); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static uint str_case_hash (void* key); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_array_append (GLib.ValueArray array, GLib.Type type, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_array_append_vals (GLib.ValueArray array, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.ValueArray value_array_from_args (va_list args); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool value_array_get_nth (GLib.ValueArray array, uint index_, GLib.Type type, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_array_insert (GLib.ValueArray array, uint index_, GLib.Type type, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.ValueArray value_array_new (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.ValueArray value_array_new_with_vals (...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool value_array_to_args (GLib.ValueArray array, va_list args); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_hash_insert (GLib.HashTable hash, string key, GLib.Type type, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_hash_insert_vals (GLib.HashTable hash, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static void value_hash_insert_value (GLib.HashTable hash, string key, GLib.Value value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool value_hash_lookup (GLib.HashTable hash, string key, GLib.Type type, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static bool value_hash_lookup_vals (GLib.HashTable hash, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable value_hash_new (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- public static GLib.HashTable value_hash_new_with_vals (...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.build_fault", deprecated_since = "vala-0.12" )] +- [PrintfFormat] +- public static unowned string xmlrpc_build_fault (int fault_code, string fault_format, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.build_method_call", deprecated_since = "vala-0.12" )] +- public static unowned string xmlrpc_build_method_call (string method_name, GLib.Value[] @params); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.build_method_response", deprecated_since = "vala-0.12" )] +- public static unowned string xmlrpc_build_method_response (GLib.Value value); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.error_quark", deprecated_since = "vala-0.12" )] +- public static GLib.Quark xmlrpc_error_quark (); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- [Version ( deprecated = true, replacement = "XMLRPC.extract_method_call", deprecated_since = "vala-0.12" )] +- public static bool xmlrpc_extract_method_call (string method_call, int length, out unowned string method_name, ...); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- [Version ( deprecated = true, replacement = "XMLRPC.extract_method_response", deprecated_since = "vala-0.12" )] +- public static bool xmlrpc_extract_method_response (string method_response, int length, ...) throws GLib.Error; +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.fault_quark", deprecated_since = "vala-0.12" )] +- public static GLib.Quark xmlrpc_fault_quark (); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.parse_method_call", deprecated_since = "vala-0.12" )] +- public static bool xmlrpc_parse_method_call (string method_call, int length, out unowned string method_name, out unowned GLib.ValueArray @params); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.parse_method_response", deprecated_since = "vala-0.12" )] +- public static bool xmlrpc_parse_method_response (string method_response, int length, GLib.Value value) throws GLib.Error; +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- [Version ( deprecated = true, replacement = "XMLRPC.request_new", deprecated_since = "vala-0.12" )] +- public static unowned Soup.Message xmlrpc_request_new (string uri, string method_name, ...); +- [CCode (cheader_filename = "libsoup/soup.h")] +- [Version ( deprecated = true, replacement = "XMLRPC.set_fault", deprecated_since = "vala-0.12" )] +- [PrintfFormat] +- public static void xmlrpc_set_fault (Soup.Message msg, int fault_code, string fault_format, ...); +- [CCode (cheader_filename = "libsoup/soup.h", sentinel = "G_TYPE_INVALID")] +- [Version ( deprecated = true, replacement = "XMLRPC.set_response", deprecated_since = "vala-0.12" )] +- public static void xmlrpc_set_response (Soup.Message msg, ...); +-} +-- +GitLab + diff --git a/srcpkgs/gitg/template b/srcpkgs/gitg/template index 0e6fffaac5..fc7903de77 100644 --- a/srcpkgs/gitg/template +++ b/srcpkgs/gitg/template @@ -1,7 +1,7 @@ # Template file for 'gitg' pkgname=gitg version=3.32.1 -revision=3 +revision=4 build_style=meson build_helper="qemu" hostmakedepends="intltool gettext glib-devel gobject-introspection pkg-config vala"